Python – Modifying events with the Google Calendar API

NOTE: The code featured here is also available as a video + overview post as part of this developers series from Google.

Introduction

In an earlier post, I introduced Python developers to adding events to users’ calendars using the Google Calendar API. However, while being able to insert events is “interesting,” it’s only half the picture. If you want to give your users a more complete experience, modifying those events is a must-have. In this post, you’ll learn how to modify existing events, and as a bonus, learn how to implement repeating events too.

In order to modify events, we need the full Calendar API scope:

• 'https://www.googleapis.com/auth/calendar'—read-write access to Calendar

Skipping the OAuth2 boilerplate, once you have valid authorization credentials, create a service endpoint to the Calendar API like this:

Now you can send the API requests using this endpoint.

Using the Google Calendar API

Our sample script requires an existing Google Calendar event, so either create one programmatically with events().insert() & save its ID as we showed you in that earlier post, or use events().list() or events().get() to get the ID of an existing event.

While you can use an offset from GMT/UTC, such as the GMT_OFF variable from the event insert post, today’s code sample “upgrades” to a more general IANA timezone solution. For Pacific Time, it’s "America/Los_Angeles". The reason for this change is to allow events that survive across Daylight Savings Time shifts. IOW, a dinner at 7PM/1900 stays at 7PM as we cross fall and spring boundaries. This is especially important for events that repeat throughout the year. Yes, we are discussing recurrence in this post too, so it’s particularly relevant.

Modifying calendar events

In the other post, the EVENT body constitutes an “event record” containing the information necessary to create a calendar entry—it consists of the event name, start & end times, and invitees. That record is an API resource which you created/accessed with the Calendar API via events().insert(). (What do you think the “R” in “URL” stands for anyway?!?) The Calendar API adheres to RESTful semantics in that the HTTP verbs match the actions you perform against a resource.

In today’s scenario, let’s assume that dinner from the other post didn’t work out, but that you want to reschedule it. Furthermore, not only do you want to make that dinner happen again, but because you’re good friends, you’ve made a commitment to do dinner every other month for the rest of the year, then see where things stand. Now that we know what we want, we have a choice.

There are two ways to modifying existing events in Calendar:

1. events().patch() (HTTP PATCH)—”patch” 1 or more fields in resource
2. events().update() (HTTP PUT)—replace/rewrite entire resource

Do you just update that resource with events().patch() or do you replace the entire resource with events().update()? To answer that question, ask yourself, “How many fields am I updating?” In our case, we only want to change the date and make this event repeat, so PATCH is a better solution. If instead, you also wanted to rename the event or switch dinner to another set of friends, you’d then be changing all the fields, so PUT would be a better solution in that case.

Using PATCH means you’re just providing the deltas between the original & updated event, so the EVENT body this time reflects just those changes:

Repeating events

Something you haven’t seen before is how to do repeating events. To do this, you need to define what’s known as a recurrence rule (“RRULE”), which answers the question of how often an event repeats. It looks somewhat cryptic but follows the RFC 5545 Internet standard which you can basically decode like this:

• FREQ=MONTHLY—event to occur on a monthly basis…
• INTERVAL=2—… but every two months (every other month)
• UNTIL=20171231—… until this date

There are many ways events can repeat, so I suggest you look at all the examples at the RFC link above.

Finishing touches

Finally, provide the EVENT_ID and call events().patch():

Keep in mind that in real life, your users may be accessing your app from their desktop or mobile devices, so you need to ensure you don’t override an earlier change. In this regard, developers should use the If-Match header along with an ETag value to validate unique requests. For more information, check out the conditional modification page in the official docs.

The one remaining thing is to confirm on-screen that the calendar event was updated successfully. We do that by checking the return value—it should be an Event object with all the existing details as well as the modified fields:

That’s pretty much the entire script save for the OAuth2 boilerplate code we’ve explored previously. The script is posted below in its entirety, and if you add a valid event ID and run it, depending on the date/times you use, you’ll see something like this:

It also works with Python 3 with one slight nit/difference being the “b” prefix on from the event name due to converting from Unicode to bytes:
*** b'Dinner with friends' event…

Conclusion

Now you know how to modify events as well as make them repeat. To complete the example, below is the entire script for your convenience which runs on both Python 2 and Python 3 (unmodified!):

SCOPES = ‘https://www.googleapis.com/auth/calendar’
store = file.Storage(‘storage.json’)
creds = store.get()
if not creds or creds.invalid:
flow = client.flow_from_clientsecrets(‘client_secret.json’, SCOPES)
creds = tools.run_flow(flow, store)
CAL = build(‘calendar’, ‘v3’, http=creds.authorize(Http()))

TIMEZONE = ‘America/Los_Angeles’
EVENT = {
‘start’: {‘dateTime’: ‘2017-07-01T19:00:00’, ‘timeZone’: TIMEZONE},
‘end’: {‘dateTime’: ‘2017-07-01T22:00:00’, ‘timeZone’: TIMEZONE},
‘recurrence’: [‘RRULE:FREQ=MONTHLY;INTERVAL=2;UNTIL=20171231′]
}
EVENT_ID = YOUR_EVENT_ID_STR_HERE
e = GCAL.events().patch(calendarId=’primary’, eventId=EVENT_ID,
sendNotifications=True, body=EVENT).execute()

print(”’
*** %r event (ID: %s) modified:
Start: %s
End: %s
Recurring (rule): %s
”’ % (e[‘summary’].encode(‘utf-8’), e[‘id’], e[‘start’][‘dateTime’],
e[‘end’][‘dateTime’], e[‘recurrence’][0]))

You can now customize this code for your own needs, for a mobile frontend, a server-side backend, or to access other Google APIs. If you want to learn more about using the Google Calendar API, check out the following resources:

• Creating great experiences with email markup—video
• Creating events with the Calendar API—video & blog post
• Official Calendar API Python quickstart—list the next 10 events in your calendar
• Official Calendar API documentation—everything you need to know and more!
• Email markup documentation for Google Calendar

via; https://realpython.com

New York apostille, apostille documents.. https://www.kalogroup.com.au/