gmail2slack.py

#!/usr/bin/env python

import pickle
import time
import traceback

import httplib2
import arrow
from oauth2client import tools
from oauth2client.client import flow_from_clientsecrets
from oauth2client.file import Storage

# from pprint import pprint

from googleapiclient.discovery import build
from slacker import Slacker
import os
import sys
import argparse
from oauth2client.client import AccessTokenRefreshError


from yaml import load

try:
    from yaml import CLoader as Loader, CDumper as Dumper
except ImportError:
    from yaml import Loader, Dumper


class Gmail2Slack():
    def __init__(self, config, slack):
        self.slack = slack
        self.config = config

        # Check https://developers.google.com/admin-sdk/directory/v1/guides/authorizing for all available scopes
        OAUTH_SCOPE = 'https://www.googleapis.com/auth/gmail.readonly'

        # Location of the credentials storage file
        STORAGE = Storage(self.config['gmail_storage'])

        # Start the OAuth flow to retrieve credentials
        flow = flow_from_clientsecrets(config['client_secret'], scope=OAUTH_SCOPE)
        http = httplib2.Http()

        # Try to retrieve credentials from storage or run the flow to generate them
        parser = argparse.ArgumentParser(parents=[tools.argparser])
        flags = parser.parse_args([])

        credentials = None

        storage = Storage(self.config['gmail2slack_oauth'])
        try:
            credentials = storage.get()
        except:
            sys.exit("Unable to retrieve credentials")

        if not credentials:
            credentials = tools.run_flow(flow, STORAGE, flags)

        storage.put(credentials)
        # Authorize the httplib2.Http object with our credentials
        http = credentials.authorize(http)

        # Build the Gmail service from discovery
        self.gmail_service = build('gmail', 'v1', http=http)
        self.user_id = 'me'

        if 'gmail_label' in self.config:
            self.label_name = self.config['gmail_label']
        else:
            self.label_name = 'INBOX'

        try:
            self.state = pickle.load(open(self.config['gmail2slack_pickle'], "rb"))
        except IOError:
            self.state = dict()
            self.state['timestamp'] = arrow.utcnow().timestamp

            # self.new_timestamp = arrow.utcnow().timestamp # BUG?  Move to gmail2slack?

    def save_state(self):
        # Save timestamp so we don't process the same files again
        # self.state['timestamp'] = self.new_timestamp
        self.state['timestamp'] = arrow.utcnow().timestamp
        pickle.dump(self.state, open(self.config['gmail2slack_pickle'], "wb"))

    def getLabelIdByName(self,name):
        response=self.gmail_service.users().labels().list(userId=self.user_id).execute()
        if "labels" in response:
            for label in response["labels"]:
                if label["name"] == name:
                    return label["id"]
        return None

    def gmail2slack(self):
        try:
            label_id = self.getLabelIdByName(self.label_name)
            if not label_id: raise Exception("target label name not found")
            response = self.gmail_service.users().messages().list(userId=self.user_id, labelIds=label_id).execute()
        except AccessTokenRefreshError:
            return

        message_ids = []
        if 'messages' in response:
            message_ids.extend(response['messages'])
        for msg_id in message_ids:
            message = self.gmail_service.users().messages().get(userId=self.user_id, id=msg_id['id']).execute()
            headers = dict()
            for header in message['payload']['headers']:
                headers[header['name']] = header['value']

            try:  # due to issue @ https://github.com/crsmithdev/arrow/issues/176
                from_ts = arrow.get(headers['Date'], 'ddd, D MMM YYYY HH:mm:ss ZZ').timestamp
            except:
                continue

            if from_ts < self.state['timestamp']:
                break
            from_date = arrow.get(from_ts).to('US/Eastern').format('YYYY-MM-DD HH:mm:ss ZZ')
            say = "New Email\n>From: %s\n>Date: %s\n>Subject: %s\n>\n>%s" % \
                  (headers['From'], from_date, headers['Subject'], message['snippet'])
            self.slack.direct_message(say, self.config['slack_user_id'], self.config['slack_from'])
        self.save_state()


class Slack():
    def __init__(self, apikey):
        self.slack = Slacker(apikey)

    def get_name_id(self, name):
        users = self.slack.users.list()
        user_id = None
        for member in users.body['members']:
            if member['name'] == name:
                user_id = member['id']
                break
        return user_id

    def direct_message(self, message, user_id, slack_from):
        self.slack.chat.post_message(user_id, message, username=slack_from)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("-v", "--verbose", help="verbosity", action="store_true")
    parser.add_argument("-c", "--config", help="path to gmail2slack.yaml", action="store",
                        default=os.getenv("HOME") + "/.config/gmail2slack/default.yaml")
    parser.add_argument("-l", "--loop", help="loop every x seconds", action="store", default=0)
    args = parser.parse_args()

    try:
        config = load(open(args.config, "r"), Loader=Loader)
    except IOError:
        sys.exit("Unable to open config file %s" % args.config)

    slack = Slack(config['slack_apikey'])
    # validate config
    if not 'slack_user_id' in config:
        config['slack_user_id'] = slack.get_name_id(config['slack_user'])
    if not config['slack_user_id']:
        sys.exit("Could not find slack id for user %s" % config['slack_user'])
    # Make sure all paths are absolute
    if 'dir' not in config or not os.path.isdir(config['dir']):
        config['dir'] = os.path.basename(args.config)
    for key in ['client_secret', 'gmail2slack_pickle', 'gmail2slack_oauth', 'gmail_storage']:
        if not os.path.isabs(config[key]):
            config[key] = "%s/%s" % (os.path.dirname(args.config), config[key])
    if not os.path.isfile(config['client_secret']):
        sys.exit("Unable to open client_secret file %s" % config['client_secret'])

    g2s = Gmail2Slack(config, slack)
    if int(args.loop) > 0:
        delay = int(args.loop)
    else:
        delay = 0
    while True:
        try:
            g2s.gmail2slack()
        except:
            traceback.print_exc()
        if delay:
            time.sleep(delay)
        else:
            break


if __name__ == "__main__":
    main()