calendarwatch_backend/quickstart.py

from __future__ import print_function
import datetime
import dateutil.parser
import pickle
import json
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request

# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']

visibleList = ['Hightower', 'Home \ud83c\udfe0', 'Office', 'Life', 'Social', 'Grey']

class Event:
    def __init__(self, name_, colorId_, start_, end_):
        self.name = name_
        self.colorId = colorId_
        self.start = start_
        self.end = end_
        self.colorHex = '#adfff5'

        if self.start == None or self.end == None :
            self.allDay = True
        else:
            self.allDay = False

    def startDateTime(self):
        if self.allDay:
            return None
        return self.jsonFromDT(self.start)

    def stopDateTime(self):
        if self.allDay:
            return None
        return self.jsonFromDT(self.end)

    def jsonFromDT(self, string):
        sdt = dateutil.parser.parse(string)
        data = {
            'date': {
            'year': sdt.year,
            'month': sdt.month,
            'day': sdt.day
            },
            'time': {
            'hour': sdt.hour,
            'minute': sdt.minute,
            'second': sdt.second
            }
        }
        return data

    def print(self):
        if self.allDay:
            print(self.name + "All Day")
        else:
            print(self.name + ": " + self.start + ", " + self.end)


class Calendar:
    def __init__(self, summary_, calendarId_, color_):
        self.summary = summary_
        self.calendarId = calendarId_
        self.color = color_

def calendarCredentials():
    creds = None
    # The file token.pickle stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

    service = build('calendar', 'v3', credentials=creds)
    
    return service
    
def getCalendarColors(service):
    colors = service.colors().get().execute()
    return colors

def getCalendars(service):
    page_token = None
    calendars = []
    while True:
        calendar_list = service.calendarList().list(pageToken=page_token).execute()
        for calendar in calendar_list['items']:
            calendars.append(Calendar(calendar['summary'], calendar['id'], calendar['colorId']))
        page_token = calendar_list.get('nextPageToken')
        if not page_token:
            break

    return calendars

def purgeCalendars(calendars):
    purged = []
    for calendar in calendars:
        print(calendar.summary)
        if calendar.summary in visibleList:
            purged.append(calendar)
    return purged

def getCalendarEvents(service, startDate, endDate):
    
    calendars = getCalendars(service)
    calendars = purgeCalendars(calendars)

    all_events = []

    for calendar in calendars:
        events_result = service.events().list(calendarId=calendar.calendarId, timeMin=startDate,
                                            timeMax=endDate,
                                            maxResults=10, singleEvents=True,
                                            orderBy='startTime').execute()

        for event in events_result.get('items', []):
            
            name = event['summary']
            start = event['start'].get('dateTime')
            end = event['end'].get('dateTime')
            color = event.get('colorId')
            if color == None:
                color = calendar.color

            event = Event(name, color, start, end)
            all_events.append(event)

    return all_events

def colorizeEvents(allEvents, colors):
    for event in allEvents:
        event.colorHex = colors['calendar'][event.colorId]['background']
        
def toJson(events):
    data = {}
    data['kind'] = 'calendar#events'
    data['events'] = []

    for event in events:
        if event.allDay:
            continue
        data['events'].append({
            'name': event.name,
            'isAllDay': event.allDay,
            'color': event.colorHex,
            'startDateTime': event.startDateTime(),
            'stopDateTime': event.stopDateTime()
            })

    with open('./calendarevents.json', 'w') as outfile:
        json.dump(data, outfile)


def main():
    service = calendarCredentials()

    # define today and tomorrow
    now = datetime.datetime.now(datetime.timezone.utc).astimezone()
    today = now.replace(hour=0, minute=0, second = 0).isoformat() 
    tomorrow = now.replace(hour=23, minute=59, second=59).isoformat() # + '+01:00'
    
    allEvents = getCalendarEvents(service, today, tomorrow)

    colors = getCalendarColors(service)
    colorizeEvents(allEvents, colors)
    # if not events:
    #    print('No upcoming events found.')

    toJson(allEvents)


if __name__ == '__main__':
    main()