[gooswapper] / gooswapper.py

#!/usr/bin/env python3

import sys
import getpass
import os
import pickle
import collections
import logging
logger = logging.getLogger('gooswapper')
logger.setLevel(logging.INFO)
consolelog = logging.StreamHandler()
consolelog.setLevel(logging.INFO)
logformatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
consolelog.setFormatter(logformatter)
logger.addHandler(consolelog)
#We can't use this, because that way all the libraries' logs spam us
#logging.basicConfig(level=logging.INFO)

#Exchange-related library
sys.path.append("/upstreams/exchangelib")
import exchangelib

#Google calendar-api libraries
import httplib2
import apiclient.discovery
import oauth2client
import oauth2client.file
import oauth2client.client

#Not sure what the distribution approach here is...
gcal_client_id = '805127902516-ptbbtgpq9o8pjr6r3k6hsm60j589o85u.apps.googleusercontent.com'
gcal_client_secret = '8hpdxV3MauorryTDoZ1YK8JO'

#scope URL for r/w calendar access
scope = 'https://www.googleapis.com/auth/calendar'
#flow object, for doing OAuth2.0 stuff
flow = oauth2client.client.OAuth2WebServerFlow(gcal_client_id,
                                               gcal_client_secret,
                                               scope)


gcal_authpath=".gooswap_gcal_creds.dat"

cachepath=".gooswapcache"

exchange_credential = None

CachedExEvent=collections.namedtuple('CachedExEvent',
                                     ['changekey','gcal_link'])

class ex_gcal_link(exchangelib.ExtendedProperty):
    distinguished_property_set_id = 'PublicStrings'
    property_name = "google calendar event id"
    property_type = 'String'

exchangelib.CalendarItem.register('gcal_link',ex_gcal_link)

def get_ex_event_by_itemid(calendar,itemid):
    return calendar.get(item_id=itemid)

def get_ex_event_by_id_and_changekey(acct,itemid,changekey):
    l=list(acct.fetch([(itemid,changekey)]))
    return list(acct.fetch([(itemid,changekey)]))[0]

def get_ex_cred(username="SANGER\mv3",password=None):
    if password is None:
        password = getpass.getpass(prompt="Password for user %s: " % username)
    return exchangelib.ServiceAccount(username,password)

def ex_login(emailaddr,ad_cache_path=None):
    global exchange_credential
    autodiscover = True
    if exchange_credential is None:
        exchange_credential = get_ex_cred()
    if ad_cache_path is not None:
        try:
            with open(ad_cache_path,"rb") as f:
                url,auth_type = pickle.load(f)
                autodiscover = False
        except FileNotFoundError:
            pass

    if autodiscover:
        ex_ac = exchangelib.Account(emailaddr,
                                    credentials = exchange_credential,
                                    autodiscover = autodiscover)
        if ad_cache_path is not None:
            cache=(ex_ac.protocol.service_endpoint,
                   ex_ac.protocol.auth_type)
            with open(ad_cache_path,"wb") as f:
                pickle.dump(cache,f)
    else:
        ex_conf = exchangelib.Configuration(service_endpoint=url,
                                            credentials=exchange_credential,
                                            auth_type=auth_type)
        ex_ac = exchangelib.Account(emailaddr,
                                    config=ex_conf,
                                    autodiscover=False,
                                    access_type=exchangelib.DELEGATE)

    return ex_ac

def get_ex_events(calendar):
    ans={}
    for event in calendar.all().only('changekey','item_id','gcal_link'):
        if event.item_id in ans:
            logger.warning("Event item_id %s was duplicated!" % event.item_id)
        ans[event.item_id] = CachedExEvent(event.changekey,event.gcal_link)
    logger.info("%d events found" % len(ans))
    return ans

def ex_event_changes(old,new):
    olds = set(old.keys())
    news = set(new.keys())
    added = list(news-olds)
    deleted = list(olds-news)
    changed = []
    #intersection - i.e. common to both sets
    for event in olds & news:
        if old[event].changekey != new[event].changekey:
            changed.append(event)
    logger.info("%d events updated, %d added, %d deleted" % (len(changed),
                                                              len(added),
                                                              len(deleted)))
    return added, deleted, changed

def add_ex_to_gcal(ex_acct,
                   gcal_acct,gcal_tz,events,
                   added,
                   gcal_id="primary"):
    for ev_id in added:
        event = get_ex_event_by_itemid(ex_acct.calendar,ev_id)
        if not event.is_recurring:
            gevent={}
            gevent["summary"]=event.subject
            if event.is_all_day:
                gevent["end"]={"date": str(event.end.astimezone(gcal_tz).date())}
                gevent["start"]={"date": str(event.start.astimezone(gcal_tz).date())}
            else:
                gevent["end"]={"dateTime": event.end.isoformat(),
                               "timeZone": event.end.tzname()}
                gevent["start"]={"dateTime": event.start.isoformat(),
                                 "timeZone": event.start.tzname()}
            if event.text_body.strip() != '':
                gevent["description"] = event.text_body
            if event.location is not None:
                gevent["location"] = event.location
            gevent["extendedProperties"]={"shared": {"ex_id": event.item_id}}
            gevent=gcal_acct.events().insert(calendarId=gcal_id, body=gevent).execute()
            event.gcal_link = gevent.get("id")
            event.save()
            events[event.item_id] = events[event.item_id]._replace(changekey=event.changekey,gcal_link=event.gcal_link)
        else:
            logger.warning("recurring events not yet supported")

def del_ex_to_gcal(ex_acct, gcal_acct, events, deleted, gcal_id="primary"):
    for ev_id in deleted:
        if events[ev_id].gcal_link is not None:
            gcal_acct.events().delete(calendarId=gcal_id,
                                      eventId=events[ev_id].gcal_link,
                                      sendUpdates="none").execute()
    
def get_gcal_cred():
    #each such file can only store a single credential
    storage = oauth2client.file.Storage(gcal_authpath)
    gcal_credential = storage.get()
    #if no credential found, or they're invalid (e.g. expired),
    #then get a new one; pass --noauth_local_webserver on the command line
    #if you don't want it to spawn a browser
    if gcal_credential is None or gcal_credential.invalid:
        gcal_credential = oauth2client.tools.run_flow(flow,
                                                      storage,
                                                      oauth2client.tools.argparser.parse_args())
    return gcal_credential

def gcal_login():
    gcal_credential = get_gcal_cred()
    # Object to handle http requests; could add proxy details
    http = httplib2.Http()
    http = gcal_credential.authorize(http)
    return apiclient.discovery.build('calendar', 'v3', http=http)

def get_gcal_timezone(gcal_account,calendarid="primary"):
    gcal = gcal_account.calendars().get(calendarId=calendarid).execute()
    return exchangelib.EWSTimeZone.timezone(gcal['timeZone'])

def main():
    try:
        with open(cachepath,"rb") as f:
            cache = pickle.load(f)
    except FileNotFoundError:
        cache = None

    ex_account = ex_login("mv3@sanger.ac.uk",".gooswapper_exch_conf.dat")
    current = get_ex_events(ex_account.calendar)

    gcal_account = gcal_login()
    gcal_tz = get_gcal_timezone(gcal_account)
    
    if cache is not None:
        added,deleted,changed = ex_event_changes(cache,current)
        add_ex_to_gcal(ex_account,gcal_account,gcal_tz,current,added)
        #delete op needs the "cache" set, as that has the link ids in
        #for events that are now deleted
        del_ex_to_gcal(ex_account,gcal_account,cache,deleted)
        
    with open(cachepath,"wb") as f:
        pickle.dump(current,f)

if __name__ == "__main__":
    main()