google_api_wrapper/gapi/apis/calendar_api/calendar_api.py

import datetime
import os

from googleapiclient.errors import HttpError

import gapi
from gapi.apis.base_api import API
from .utils import to_dateTime

APPLICATION_NAME = "Google Calendar API Python"


class calendar_api(API):
    def __init__(
        self,
        app_name,
        client_secret_file=os.path.join(gapi.state_dir, "client_secret.json"),
        credentials_dir=gapi.state_dir,
        scopes=["https://www.googleapis.com/auth/calendar"],
        version="v3",
    ):
        super().__init__(
            "calendar", scopes, app_name, client_secret_file, credentials_dir, version
        )

        self.calendars = self.get_calendars()
        self.ids = dict(
            (calendar["summary"].lower(), calendar["id"])
            for calendar in self.calendars.values()
        )

    def create_event(self, calendar_id, body):

        try:
            calendar_id = self.ids[calendar_id]
        except KeyError:
            pass
        service = self.service
        event_service = service.events()
        event = event_service.insert(calendarId=calendar_id, body=body).execute()
        return event["id"]

    def update_event(self, calendar_id, event_id, body):
        try:
            calendar_id = self.ids[calendar_id]
        except KeyError:
            pass

        service = self.service
        event_service = service.events()
        try:
            event = event_service.get(
                calendarId=calendar_id, eventId=event_id
            ).execute()
        except HttpError as e:
            if e.resp.status == 404:
                return self.create_event(calendar_id, body)

        updated_event = (
            service.events()
            .update(calendarId=calendar_id, eventId=event["id"], body=body)
            .execute()
        )
        return updated_event["id"]

    def get_calendars(self):
        page_token = None
        cl = {}
        first = True
        while page_token or first:
            first = False
            calendar_list_service = self.service.calendarList()
            calendar_list = calendar_list_service.list(pageToken=page_token).execute()
            for calendar_entry in calendar_list["items"]:
                cl[calendar_entry["id"]] = calendar_entry
            page_token = calendar_list.get("nextPageToken")
        return cl

    def get_events(self, **params):
        """Return events with params"""
        cal_id = params.pop("cal_id")
        service = self.service
        try:
            cal_id = self.ids[cal_id]
        except KeyError:
            pass
        page_token = None
        first = True
        while page_token is not None or first:
            first = False
            event_service = service.events()
            events = event_service.list(
                calendarId=cal_id, pageToken=page_token, **params
            ).execute()
            for event in events["items"]:
                yield event
            page_token = events.get("nextPageToken")

    def get_events_in_range(
        self,
        cal_id,
        start_date: datetime.datetime = None,
        end_date: datetime.datetime = None,
    ):
        """Returns events in between the given time range"""
        if start_date is not None:
            start_date = start_date.isoformat()
        if end_date is not None:
            end_date = end_date.isoformat()

        yield from self.get_events(cal_id=cal_id, timeMin=start_date, timeMax=end_date)

    def get_event_by_id(self, cal_id, event_id):
        """Retrieves event from cal_id and event_id"""
        service = self.service
        event_service = service.events()
        return event_service.get(calendarId=cal_id, eventId=event_id).execute()

    def delete_event(self, cal_id, event_id):
        service = self.service
        event_service = service.events()
        return event_service.delete(calendarId=cal_id, eventId=event_id).execute()