wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/create.py

@@ -0,0 +1,75 @@
+from datetime import timedelta
+
+from celery import shared_task
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.authentication.models import User
+from wbcrm.models import Activity
+
+from ...typing_informations import GoogleEventType
+from ...utils import GoogleSyncUtils
+from .update import update_activity_participant
+
+
+@shared_task(queue="synchronization")
+def create_internal_activity_based_on_google_event(
+    event: GoogleEventType, user: User, service: Resource, parent_occurrence: Activity | None = None, is_instance=False
+):
+    """
+    A method for creating a "Workbench" activity based on a "Google" event. If the google event is a recurring event, this method will also create the corresponding workbench activities.
+
+    :param event:           A google event body.
+    :param user:            The current workbench user.
+    :param service:         Thee google Resource.
+    :param parent_occurrence: The parent activity. This is only used when the activity is part of a recurring chain. Per default it is None.
+    :param is_instance:     True, when the event is a google instance (A instance is an event that is part of a recurring chain)
+    """
+
+    external_id = event["id"]
+    if event.get("status") == "cancelled" or Activity.objects.filter(external_id=event["id"]).exists():
+        return
+
+    event_creator = event.get("organizer", {})
+    event_creator_mail = event_creator.get("email", "")
+    event_creator_displayed_name = event_creator.get("displayName", "")
+    creator = GoogleSyncUtils.get_or_create_person(event_creator_mail, event_creator_displayed_name)
+    event_start, event_end = GoogleSyncUtils.get_start_and_end(event)
+    if event_start == event_end:
+        event_end = event_end + timedelta(seconds=1)
+    period = TimestamptzRange(event_start, event_end)  # type: ignore
+    all_day: bool = True if event["start"].get("date") else False
+    metadata = {"google_backend": {"instance": event}} if is_instance else {"google_backend": {"event": event}}
+
+    act = Activity.objects.create(
+        external_id=external_id,
+        title=event.get("summary", "(No Subject)"),
+        assigned_to=creator,
+        creator=creator,
+        description=event.get("description", ""),
+        start=event_start,
+        end=event_end,
+        period=period,
+        all_day=all_day,
+        location=event.get("location"),
+        visibility=GoogleSyncUtils.convert_event_visibility_to_activity_visibility(event.get("visibility", "")),
+        metadata=metadata,
+        parent_occurrence=parent_occurrence,
+    )
+
+    update_activity_participant(event, act)
+
+    if event.get("recurrence") and not is_instance:
+        instances: dict = service.events().instances(calendarId=user.email, eventId=event["id"]).execute()
+        instance_items: list[GoogleEventType] = instances["items"]
+        global_preferences = global_preferences_registry.manager()
+        max_list_length: int = global_preferences["wbcrm__recurrence_maximum_count"]
+        instance_items = instance_items[:max_list_length]
+
+        for item in instance_items:
+            if item["start"] == act.metadata["google_backend"].get("event", {}).get("start"):
+                updated_metadata: dict = act.metadata
+                updated_metadata["google_backend"] |= {"instance": item}
+                Activity.objects.filter(id=act.id).update(metadata=updated_metadata)
+            else:
+                create_internal_activity_based_on_google_event(item, user, service, act, True)

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/delete.py

@@ -0,0 +1,78 @@
+from django.db.models import QuerySet
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from wbcrm.models import Activity
+
+
+def cancel_or_delete_activity(activity: "Activity") -> None:
+    # Activity is cancelled rather than disable if global preference is True
+    if global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"]:
+        Activity.objects.filter(id=activity.id).update(status=Activity.Status.CANCELLED)
+    else:
+        activity.delete()
+
+
+def cancel_or_delete_activity_queryset(activity_qs: QuerySet["Activity"]) -> None:
+    # Activities are cancelled rather than delete if global preference is True
+    if global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"]:
+        activity_qs.update(status=Activity.Status.CANCELLED)
+    else:
+        activity_qs.delete()
+
+
+def delete_single_activity(activity: Activity):
+    """
+    Deletes the activity that has the corresponding external ID
+    """
+    Activity.objects.filter(id=activity.id).update(external_id=None)
+    cancel_or_delete_activity(activity)
+
+
+def delete_recurring_activity(activity: Activity, event: dict, user_mail: str, service: Resource):
+    """
+    Handles the deletion of recurring activities (either a single activity, a certain number of activities or all activities),
+    based on the changes done to the google event.
+
+    :param event:           The google event dict that was deleted.
+    :param activity:        The corresponding workbench activity.
+    :param user_mail:       The e-mail address of the current user.
+    :param service:         The google service to interact with googles resources.
+    """
+
+    parent_occurrence = activity.parent_occurrence if activity.parent_occurrence else activity
+    metadata_event = parent_occurrence.metadata["google_backend"].get(
+        "event", parent_occurrence.metadata["google_backend"].get("instance", {})
+    )
+    if event.get("recurringEventId"):
+        # Delete single event in event chain
+        if activity.status not in [Activity.Status.REVIEWED, Activity.Status.FINISHED]:
+            cancel_or_delete_activity(activity)
+
+    elif event.get("recurrence") != metadata_event.get("recurrence"):
+        # Delete all events after a certain event in the event chain
+
+        event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+        external_id_list: list = [instance["id"] for instance in event_instances["items"]]
+        activities_to_remove = Activity.objects.filter(
+            metadata__google_backend__instance__recurringEventId__startswith=event["id"],
+            status=Activity.Status.PLANNED,
+        ).exclude(metadata__google_backend__instance__id__in=external_id_list)
+        first_in_list = activities_to_remove.order_by("start").first()
+        metadata = parent_occurrence.metadata
+        metadata["google_backend"] |= {"event": event}
+        Activity.objects.filter(id=parent_occurrence.id).update(metadata=metadata)
+        if (
+            first_in_list
+            and first_in_list.id == parent_occurrence.id
+            and parent_occurrence.status not in [Activity.Status.REVIEWED, Activity.Status.FINISHED]
+        ):
+            cancel_or_delete_activity(parent_occurrence)
+        cancel_or_delete_activity_queryset(activities_to_remove)
+
+    else:
+        # Delete all events in event chain
+        activities_to_cancel = Activity.objects.filter(
+            parent_occurrence=parent_occurrence, status=Activity.Status.PLANNED
+        )
+        cancel_or_delete_activity_queryset(activities_to_cancel)
+        cancel_or_delete_activity(activity)

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/update.py

@@ -0,0 +1,155 @@
+from datetime import timedelta
+
+from django.utils import timezone
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.directory.models import Person
+from wbcrm.models import Activity, ActivityParticipant
+
+from ...typing_informations import GoogleEventType
+from ...utils import GoogleSyncUtils
+
+
+def update_activity_participant(event: GoogleEventType, activity: Activity):
+    """
+    Used to update the participants in a workbench activity.
+
+    :param event:   The Google event dict with the participant informations.
+    :param activity:The corresponding activity.
+    """
+
+    can_sync_external_participants: bool = global_preferences_registry.manager()[
+        "wbactivity_sync__sync_external_participants"
+    ]
+    event_participants = GoogleSyncUtils.get_or_create_participants(event, activity.creator)
+
+    def update_or_add_participants():
+        for event_participant in event_participants:
+            if person := Person.objects.filter(id=event_participant["person_id"]).first():
+                activity.participants.add(person.id)
+                ActivityParticipant.objects.filter(activity=activity, participant=person).update(
+                    participation_status=event_participant["status"]
+                )
+
+    if can_sync_external_participants or not activity.creator.is_internal:  # type: ignore
+        update_or_add_participants()
+    else:
+        internal_activity_participants_set = set(
+            activity.participants.filter(id__in=Person.objects.filter_only_internal())
+        )
+        event_participants_set = set(Person.objects.filter(id__in=[x["person_id"] for x in event_participants]))
+        missing_activity_participants = internal_activity_participants_set - event_participants_set
+        update_or_add_participants()
+        if missing_activity_participants:
+            ActivityParticipant.objects.filter(
+                participant__in=missing_activity_participants, activity=activity
+            ).update(participation_status=ActivityParticipant.ParticipationStatus.CANCELLED)
+
+
+def update_single_activity(event: GoogleEventType, activity: Activity, change_status=False):
+    """
+    Updates a single workbench activity based on changes done in a google event.
+
+    :param event:           The google event dict that was updated.
+    :param activity:        The corresponding workbench activity.
+    :param change_status:   Information wheter the status of the event was updated or not.
+    """
+    if activity.external_id is None:
+        return
+    if activity.status == Activity.Status.REVIEWED or activity.status == Activity.Status.FINISHED:
+        metadata = activity.metadata
+        metadata["google_backend"] |= {"event": event} if not event.get("recurringEventId") else {"instance": event}
+        Activity.objects.filter(id=activity.id).update(
+            external_id=event["id"] if "_" in activity.external_id else activity.external_id,
+            metadata=metadata,
+        )
+        return
+    event_organizer = event.get("organizer", {})
+    event_organizer_mail = event_organizer.get("email", "")
+    event_organizer_displayed_name = event_organizer.get("displayName", "")
+    organizer = GoogleSyncUtils.get_or_create_person(event_organizer_mail, event_organizer_displayed_name)
+    event_start, event_end = GoogleSyncUtils.get_start_and_end(event)
+    if event_start == event_end:
+        event_end = event_end + timedelta(seconds=1)
+    period = TimestamptzRange(event_start, event_end)  # type: ignore
+    all_day: bool = True if event["start"].get("date") else False
+
+    metadata = activity.metadata
+    metadata["google_backend"] |= {"event": event} if not event.get("recurringEventId") else {"instance": event}
+    Activity.objects.filter(id=activity.id).update(
+        title=event.get("summary", "(No Subject)"),
+        assigned_to=organizer,
+        description=event.get("description", ""),
+        start=event_start,
+        status=Activity.Status.PLANNED if change_status else activity.status,
+        end=event_end,
+        period=period,
+        all_day=all_day,
+        location=event.get("location"),
+        visibility=GoogleSyncUtils.convert_event_visibility_to_activity_visibility(event.get("visibility")),
+        metadata=metadata,
+        external_id=event["id"] if "_" in activity.external_id else activity.external_id,
+    )
+    update_activity_participant(event, activity)
+
+
+def update_all_activities(activity: Activity, event: GoogleEventType, user_mail: str, service: Resource):
+    """
+    Updates all workbench activities in a recurrence chain based on changes done in a google event.
+
+    :param event:       The google event dict that was updated.
+    :param activity:    The corresponding workbench activity.
+    :param user_mail:   The e-mail address of the current user.
+    :param service:     The google service to interact with googles resources.
+    """
+
+    activity_instance = activity.metadata["google_backend"].get(
+        "instance", activity.metadata["google_backend"].get("event", {})
+    )
+    event_start, event_end = event["start"], event["end"]
+    activity_start, activity_end = activity_instance.get("start"), activity_instance.get("end")
+    event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+    instance_items = event_instances["items"]
+    connected_activities = Activity.objects.filter(parent_occurrence=activity)
+    connected_activities |= Activity.objects.filter(metadata__google_backend__instance__recurringEventId=event["id"])
+    connected_activities |= Activity.objects.filter(id=activity.id)
+    if event_start != activity_start or event_end != activity_end:
+        # If the start/end time of the google event chain changes, google will also change the id of the event instances. That is why we need to handle this case seperatly
+        connected_activities = connected_activities.order_by("external_id")
+        activity_list = list(connected_activities)
+        instance_items.sort(key=lambda x: x["start"].get("date", x["start"]["dateTime"]))
+        for instance in instance_items:
+            if len(activity_list) == 0:
+                break
+            activity_instance = activity_list.pop(0)
+            update_single_activity(instance, activity_instance)
+            activity_instance.refresh_from_db()
+    else:
+        for instance in instance_items:
+            if activity_child := connected_activities.filter(external_id=instance["id"]).first() or (
+                activity_child := Activity.objects.filter(
+                    metadata__google_backend__instance__id=instance["id"]
+                ).first()
+            ):
+                update_single_activity(instance, activity_child)
+
+
+def update_activities_from_new_parent(event: dict, parent_occurrence: Activity, user_mail: str, service: Resource):
+    """
+    This methods updates child activities whose parent activity was altered.
+
+    :param event:           The google event dict that was updated.
+    :param parent_occurrence: The corresponding workbench parent activity.
+    :param user_mail:       The e-mail address of the current user.
+    :param service:         The google service to interact with googles resources.
+
+    """
+    now = timezone.now()
+    canceled_child_activities = Activity.objects.filter(
+        parent_occurrence=parent_occurrence, period__startswith__gt=now
+    )
+    event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+    for instance in event_instances["items"]:
+        if activity := canceled_child_activities.filter(external_id=instance["id"]).first():
+            update_single_activity(instance, activity, True)

wbcrm/synchronization/activity/backends/google/request_utils/internal_to_external/update.py

@@ -0,0 +1,181 @@
+import re
+import warnings
+from uuid import uuid4
+
+from dateutil.rrule import rrule, rrulestr
+from googleapiclient.discovery import Resource
+from wbcrm.models import Activity
+
+from ...utils import GoogleSyncUtils
+
+
+def update_single_event(creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict):
+    """
+    Updates a single Google-Event.
+
+    After the external event has been updated, the metadata field of the internal activity is also updated with the information of the external event.
+
+    Note: Do not use for recurring events.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+
+    updated_external_event = (
+        google_service.events()
+        .update(calendarId=creator_mail, eventId=internal_activity.external_id, body=updates)
+        .execute()
+    )
+    metadata = internal_activity.metadata | {"google_backend": {"event": updated_external_event}}
+    Activity.objects.filter(id=internal_activity.id).update(metadata=metadata)
+
+
+def update_single_recurring_event(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates a single recurring Google-Event.
+
+    After the external event has been updated, the metadata field of the internal activity is also updated with the information of the external event.
+
+    Note: Do not use for not recurring events.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+    is_parent = Activity.objects.filter(parent_occurrence=internal_activity).exists()
+    external_id = (
+        internal_activity.metadata["google_backend"]["instance"].get("id")
+        if is_parent
+        else internal_activity.external_id
+    )
+    updated_event = google_service.events().patch(calendarId=creator_mail, eventId=external_id, body=updates).execute()
+    metadata = internal_activity.metadata
+    metadata["google_backend"] |= {"instance": updated_event}
+    Activity.objects.filter(id=internal_activity.id).update(metadata=metadata)
+
+
+def update_all_recurring_events_from_parent(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates all Google-Event-Instances belonging to the same recurring event chain.
+
+    After the external event instances have been updated, the metadata fields of the internal activities is also updated with the information of the corresponding external event instance.
+
+    Note: Do not use when creating a new parent activity from an existing child.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench parent activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+    updated_event = (
+        google_service.events()
+        .patch(calendarId=creator_mail, eventId=internal_activity.external_id, body=updates)
+        .execute()
+    )
+    metadata = internal_activity.metadata | {"google_backend": {"event": updated_event}}
+    instances = google_service.events().instances(calendarId=creator_mail, eventId=updated_event["id"]).execute()
+    google_event_items = instances["items"]
+    GoogleSyncUtils.add_instance_metadata(internal_activity, google_event_items, metadata)
+
+
+def update_all_recurring_events_from_new_parent(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates all Google-Event-Instances belonging to the same parent event.
+
+    After the external event instances have been updated, the metadata fields of the internal activities is also updated with the information of the corresponding external event instance.
+
+    Note: Do not use when updating from the original event chain parent.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench parent activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+
+    # If the old parent does not exist anymore, we cannot update the child.
+    if not (
+        current_parent_occurrence := Activity.objects.filter(
+            id=internal_activity.metadata.get("old_parent_id")
+        ).first()
+    ):
+        return warnings.warn(
+            "Could not update the recurring events on google, because the old parent activity was already deleted.",
+            stacklevel=2,
+        )
+
+    # Get the current parent event from google
+    current_google_parent_event: dict = (
+        google_service.events().get(calendarId=creator_mail, eventId=current_parent_occurrence.external_id).execute()
+    )
+
+    # Get the current recurrence rules. We need to modify them for both the current parent event and the new parent event.
+    current_parent_rrule_str: str = "\n".join(current_google_parent_event["recurrence"])
+
+    # We need to adjust the rrules to mimic the current status on the workbench. So we replace any until or count value with the current number of child activities.
+    current_parent_child_count = Activity.objects.filter(parent_occurrence=current_parent_occurrence).count()
+    new_parent_child_count = Activity.objects.filter(parent_occurrence=internal_activity).count()
+    current_parent_new_rrule: rrule = rrulestr(current_parent_rrule_str).replace(  # type: ignore
+        count=current_parent_child_count + 1, until=None
+    )
+    new_parent_rrule: rrule = rrulestr(current_parent_rrule_str).replace(count=new_parent_child_count + 1, until=None)  # type: ignore
+
+    # Converting the rrule back to str. Since the .__str__() method adds a DTSTART value, we need to remove this by using regex.
+    current_parent_new_rrule_str: str = re.sub("[DTSTART].*[\n]", "", current_parent_new_rrule.__str__()).split("T0")[
+        0
+    ]
+    new_parent_rrule_str: str = re.sub("[DTSTART].*[\n]", "", new_parent_rrule.__str__()).split("T0")[0]
+
+    # Updating the current parent with the new rrules. This will remove all the child events on google that are not in the scope of the changed rrules anymore.
+    current_google_parent_event |= {"recurrence": [current_parent_new_rrule_str]}
+    updated_current_parent_event: dict = (
+        google_service.events()
+        .update(calendarId=creator_mail, eventId=current_google_parent_event["id"], body=current_google_parent_event)
+        .execute()
+    )
+
+    # Updating the corresponding metadata
+    current_parent_metadata = current_parent_occurrence.metadata | {
+        "google_backend": {"event": updated_current_parent_event}
+    }
+    Activity.objects.filter(id=current_parent_occurrence.id).update(metadata=current_parent_metadata)
+    current_instances = (
+        google_service.events()
+        .instances(calendarId=creator_mail, eventId=updated_current_parent_event["id"])
+        .execute()
+    )
+    current_instances_google_event_items = current_instances["items"]
+    current_parent_occurrence.refresh_from_db()
+    GoogleSyncUtils.add_instance_metadata(
+        current_parent_occurrence, current_instances_google_event_items, current_parent_metadata
+    )
+
+    # Updating the new parent with the created rrules. This will create the child events in google which are in the scope of the newly created rrules.
+
+    internal_activity_query = Activity.objects.filter(id=internal_activity.id)
+    external_id = uuid4().hex
+    updates |= {"recurrence": [new_parent_rrule_str], "id": external_id}
+    internal_activity_query.update(external_id=external_id)
+    new_parent_event: dict = google_service.events().insert(calendarId=creator_mail, body=updates).execute()
+
+    # Updating the corresponding metadata
+    metadata = internal_activity.metadata | {"google_backend": {"event": new_parent_event}, "old_parent_id": None}
+    internal_activity_query.update(metadata=metadata)
+    new_instances = (
+        google_service.events().instances(calendarId=creator_mail, eventId=new_parent_event["id"]).execute()
+    )
+    new_google_event_items = new_instances["items"]
+    internal_activity.refresh_from_db()
+    GoogleSyncUtils.add_instance_metadata(internal_activity, new_google_event_items, metadata, True)

wbcrm/synchronization/activity/backends/google/tasks.py

@@ -0,0 +1,21 @@
+from datetime import datetime, timedelta
+
+from celery import shared_task
+from wbcore.contrib.authentication.models import User
+
+
+@shared_task(queue="synchronization")
+def google_webhook_resubscription() -> None:
+    """
+    A task to renew the google webhook subscriptions. The expiration date will be increased by 8 days.
+    Only the subscriptions of users who still have a valid subscription will be renewed.
+    """
+
+    from .google import GoogleCalendarBackend
+
+    user: User
+    for user in User.objects.filter(metadata__google_backend__watch__isnull=False):
+        GoogleCalendarBackend.stop_web_hook(user)
+        user.refresh_from_db()
+        new_timestamp_ms = round((datetime.now() + timedelta(days=8)).timestamp() * 1000)
+        GoogleCalendarBackend.set_web_hook(user, new_timestamp_ms)

wbcrm/synchronization/activity/backends/google/tests/conftest.py

@@ -0,0 +1 @@
+from wbcrm.tests.conftest import *

wbcrm/synchronization/activity/backends/google/tests/test_data.py

@@ -0,0 +1,81 @@
+import calendar
+import datetime as dt
+
+week_ahead = dt.date.today() + dt.timedelta(days=7)
+week_before = dt.date.today() - dt.timedelta(days=7)
+week_ahead_timestamp = calendar.timegm(week_ahead.timetuple()) * 1000
+week_before_timestamp = calendar.timegm(week_before.timetuple()) * 1000
+credentials = '{"url": "https://fake_url.io", "type": "service_account", "project_id": "fake_project_id", "private_key_id": "fake_private_key_id", "private_key": "fake_private_key", "client_email": "client_mail@serviceaccount.com", "client_id": "fake_client_id", "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://oauth2.googleapis.com/token", "auth_provider_x509_cert_url": "https://fake_auth_url", "client_x509_cert_url": "https://fake_cert_url"}'
+
+person_metadata = {"google_backend": {"watch": {"expiration": str(week_ahead_timestamp)}}}
+person_metadata_expired = {"google_backend": {"watch": {"expiration": str(week_before_timestamp)}, "expired": True}}
+
+event = {
+    "attendees": [
+        {"displayName": "Foo", "email": "Foo@Foo.com", "responseStatus": "accepted"},
+        {"displayName": "Bar", "email": "Bar@Bar.com", "responseStatus": "declined"},
+        {"displayName": "Foo Bar", "email": "Foo@Bar.com", "responseStatus": "tentative"},
+        {"email": "Bar@Foo.com", "responseStatus": "tentative"},
+    ]
+}
+
+event_data = {
+    "id": "test",
+    "items": [],
+    "start": {"date": "2022-12-06", "dateTime": "2022-12-06T17:25:00+0200", "timeZone": "UTC"},
+    "end": {"date": "2022-12-06", "dateTime": "2022-12-06T18:25:00+0200", "timeZone": "UTC"},
+}
+event_list = [
+    {"id": "1", "metaTest": "Parent", "originalStartTime": {"dateTime": "Fake Date Time"}},
+    {"id": "2", "metaTest": "Child A", "originalStartTime": {"dateTime": "Fake Date Time A"}},
+    {"id": "3", "metaTest": "Child B", "originalStartTime": {"dateTime": "Fake Date Time B"}},
+    {"id": "4", "metaTest": "Child C", "originalStartTime": {"dateTime": "Fake Date Time C"}},
+]
+
+
+class EventService:
+    def insert(self, calendarId, body):
+        return ExecuteService(calendarId, body)
+
+    def instances(self, calendarId, eventId):
+        return ExecuteService(calendarId, eventId)
+
+    def delete(self, calendarId, eventId):
+        return ExecuteService(calendarId, eventId)
+
+    def update(self, calendarId, eventId, body=event):
+        return ExecuteService(calendarId, eventId)
+
+    def patch(self, calendarId, eventId, body=event):
+        return ExecuteService(calendarId, eventId)
+
+    def get(self, calendarId, eventId, body=event):
+        return ExecuteService(calendarId, eventId)
+
+    def list(self, calendarId, pageToken, syncToken):
+        return ExecuteService(calendarId, pageToken)
+
+    def watch(self, calendarId, body=event):
+        return ExecuteService(calendarId, event)
+
+
+class ChannelsService:
+    def stop(self, body):
+        return ExecuteService("", body)
+
+
+class ExecuteService:
+    def __init__(self, calendarId, body):
+        self.calendarId = calendarId
+        self.body = body
+
+    def execute(self):
+        return event_data
+
+
+class ServiceData:
+    def events(self):
+        return EventService
+
+    def channels(self):
+        return ChannelsService