284 lines
8.7 KiB
Python
284 lines
8.7 KiB
Python
import logging
|
|
import sys
|
|
|
|
import google.auth
|
|
from google.oauth2 import service_account
|
|
from googleapiclient import discovery
|
|
from pytz import utc
|
|
|
|
|
|
class GoogleCalendarService():
|
|
"""class for make google calendar service Resource
|
|
|
|
Returns:
|
|
service Resource
|
|
"""
|
|
|
|
@staticmethod
|
|
def from_srv_acc_file(service_account_file):
|
|
"""make service Resource from service account filename (authorize)
|
|
|
|
Returns:
|
|
service Resource
|
|
"""
|
|
|
|
scopes = ['https://www.googleapis.com/auth/calendar']
|
|
credentials = service_account.Credentials.from_service_account_file(service_account_file)
|
|
scoped_credentials = credentials.with_scopes(scopes)
|
|
service = discovery.build('calendar', 'v3', credentials=scoped_credentials)
|
|
return service
|
|
|
|
def select_event_key(event):
|
|
"""select event key for logging
|
|
|
|
Arguments:
|
|
event -- event resource
|
|
|
|
Returns:
|
|
key name or None if no key found
|
|
"""
|
|
|
|
key = None
|
|
if 'iCalUID' in event:
|
|
key = 'iCalUID'
|
|
elif 'id' in event:
|
|
key = 'id'
|
|
return key
|
|
|
|
|
|
class GoogleCalendar():
|
|
"""class to interact with calendar on google
|
|
"""
|
|
|
|
logger = logging.getLogger('GoogleCalendar')
|
|
|
|
def __init__(self, service, calendarId):
|
|
self.service = service
|
|
self.calendarId = calendarId
|
|
|
|
def _make_request_callback(self, action, events_by_req):
|
|
"""make callback for log result of batch request
|
|
|
|
Arguments:
|
|
action -- action name
|
|
events_by_req -- list of events ordered by request id
|
|
|
|
Returns:
|
|
callback function
|
|
"""
|
|
|
|
def callback(request_id, response, exception):
|
|
event = events_by_req[int(request_id)]
|
|
key = select_event_key(event)
|
|
|
|
if exception is not None:
|
|
self.logger.error('failed to %s event with %s: %s, exception: %s',
|
|
action, key, event.get(key), str(exception))
|
|
else:
|
|
resp_key = select_event_key(response)
|
|
if resp_key is not None:
|
|
event = response
|
|
key = resp_key
|
|
self.logger.info('event %s ok, %s: %s',
|
|
action, key, event.get(key))
|
|
return callback
|
|
|
|
def list_events_from(self, start):
|
|
""" list events from calendar, where start date >= start
|
|
"""
|
|
fields = 'nextPageToken,items(id,iCalUID,updated)'
|
|
events = []
|
|
page_token = None
|
|
timeMin = utc.normalize(start.astimezone(utc)).replace(
|
|
tzinfo=None).isoformat() + 'Z'
|
|
while True:
|
|
response = self.service.events().list(calendarId=self.calendarId, pageToken=page_token,
|
|
singleEvents=True, timeMin=timeMin, fields=fields).execute()
|
|
if 'items' in response:
|
|
events.extend(response['items'])
|
|
page_token = response.get('nextPageToken')
|
|
if not page_token:
|
|
break
|
|
self.logger.info('%d events listed', len(events))
|
|
return events
|
|
|
|
def find_exists(self, events):
|
|
""" find existing events from list, by 'iCalUID' field
|
|
|
|
Arguments:
|
|
events {list} -- list of events
|
|
|
|
Returns:
|
|
tuple -- (events_exist, events_not_found)
|
|
events_exist - list of tuples: (new_event, exists_event)
|
|
"""
|
|
|
|
fields = 'items(id,iCalUID,updated)'
|
|
events_by_req = []
|
|
exists = []
|
|
not_found = []
|
|
|
|
def list_callback(request_id, response, exception):
|
|
found = False
|
|
event = events_by_req[int(request_id)]
|
|
if exception is None:
|
|
found = ([] != response['items'])
|
|
else:
|
|
self.logger.error('exception %s, while listing event with UID: %s', str(
|
|
exception), event['iCalUID'])
|
|
if found:
|
|
exists.append(
|
|
(event, response['items'][0]))
|
|
else:
|
|
not_found.append(events_by_req[int(request_id)])
|
|
|
|
batch = self.service.new_batch_http_request(callback=list_callback)
|
|
i = 0
|
|
for event in events:
|
|
events_by_req.append(event)
|
|
batch.add(self.service.events().list(calendarId=self.calendarId,
|
|
iCalUID=event['iCalUID'], showDeleted=True, fields=fields), request_id=str(i))
|
|
i += 1
|
|
batch.execute()
|
|
self.logger.info('%d events exists, %d not found',
|
|
len(exists), len(not_found))
|
|
return exists, not_found
|
|
|
|
def insert_events(self, events):
|
|
""" insert list of events
|
|
|
|
Arguments:
|
|
events - events list
|
|
"""
|
|
|
|
fields = 'id'
|
|
events_by_req = []
|
|
|
|
insert_callback = self._make_request_callback('insert', events_by_req)
|
|
batch = self.service.new_batch_http_request(callback=insert_callback)
|
|
i = 0
|
|
for event in events:
|
|
events_by_req.append(event)
|
|
batch.add(self.service.events().insert(
|
|
calendarId=self.calendarId, body=event, fields=fields), request_id=str(i))
|
|
i += 1
|
|
batch.execute()
|
|
|
|
def patch_events(self, event_tuples):
|
|
""" patch (update) events
|
|
|
|
Arguments:
|
|
event_tuples -- list of tuples: (new_event, exists_event)
|
|
"""
|
|
|
|
fields = 'id'
|
|
events_by_req = []
|
|
|
|
patch_callback = self._make_request_callback('patch', events_by_req)
|
|
batch = self.service.new_batch_http_request(callback=patch_callback)
|
|
i = 0
|
|
for event_new, event_old in event_tuples:
|
|
if 'id' not in event_old:
|
|
continue
|
|
events_by_req.append(event_new)
|
|
batch.add(self.service.events().patch(
|
|
calendarId=self.calendarId, eventId=event_old['id'], body=event_new), fields=fields, request_id=str(i))
|
|
i += 1
|
|
batch.execute()
|
|
|
|
def update_events(self, event_tuples):
|
|
""" update events
|
|
|
|
Arguments:
|
|
event_tuples -- list of tuples: (new_event, exists_event)
|
|
"""
|
|
|
|
fields = 'id'
|
|
events_by_req = []
|
|
|
|
update_callback = self._make_request_callback('update', events_by_req)
|
|
batch = self.service.new_batch_http_request(callback=update_callback)
|
|
i = 0
|
|
for event_new, event_old in event_tuples:
|
|
if 'id' not in event_old:
|
|
continue
|
|
events_by_req.append(event_new)
|
|
batch.add(self.service.events().update(
|
|
calendarId=self.calendarId, eventId=event_old['id'], body=event_new, fields=fields), request_id=str(i))
|
|
i += 1
|
|
batch.execute()
|
|
|
|
def delete_events(self, events):
|
|
""" delete events
|
|
|
|
Arguments:
|
|
events -- list of events
|
|
"""
|
|
|
|
events_by_req = []
|
|
|
|
delete_callback = self._make_request_callback('delete', events_by_req)
|
|
batch = self.service.new_batch_http_request(callback=delete_callback)
|
|
i = 0
|
|
for event in events:
|
|
events_by_req.append(event)
|
|
batch.add(self.service.events().delete(
|
|
calendarId=self.calendarId, eventId=event['id']), request_id=str(i))
|
|
i += 1
|
|
batch.execute()
|
|
|
|
def create(self, summary, timeZone=None):
|
|
"""create calendar
|
|
|
|
Arguments:
|
|
summary -- new calendar summary
|
|
|
|
Keyword Arguments:
|
|
timeZone -- new calendar timezone as string (optional)
|
|
|
|
Returns:
|
|
calendar Resource
|
|
"""
|
|
|
|
calendar = {'summary': summary}
|
|
if timeZone is not None:
|
|
calendar['timeZone'] = timeZone
|
|
|
|
created_calendar = self.service.calendars().insert(body=calendar).execute()
|
|
self.calendarId = created_calendar['id']
|
|
return created_calendar
|
|
|
|
def delete(self):
|
|
"""delete calendar
|
|
"""
|
|
|
|
self.service.calendars().delete(calendarId=self.calendarId).execute()
|
|
|
|
def make_public(self):
|
|
"""make calendar puplic
|
|
"""
|
|
|
|
rule_public = {
|
|
'scope': {
|
|
'type': 'default',
|
|
},
|
|
'role': 'reader'
|
|
}
|
|
return self.service.acl().insert(calendarId=self.calendarId, body=rule_public).execute()
|
|
|
|
def add_owner(self, email):
|
|
"""add calendar owner by email
|
|
|
|
Arguments:
|
|
email -- email to add
|
|
"""
|
|
|
|
rule_owner = {
|
|
'scope': {
|
|
'type': 'user',
|
|
'value': email,
|
|
},
|
|
'role': 'owner'
|
|
}
|
|
return self.service.acl().insert(calendarId=self.calendarId, body=rule_owner).execute()
|