DEV Community: Gautam Sawhney

Integrating with Google Calendar in a Rails app - The Right Way

Gautam Sawhney — Tue, 26 May 2020 11:19:35 +0000

Part 1 of this series - How NOT to integrate Google Calendar with your product

Prerequisite

1) If using rails then use the gem google-api-client
2) I am considering here that you already have the access_token of the user. I will write a different blog to explain how to get that.

1) Do full initial synch of events

It has the following steps -

Fetch a new access_token if the token has expired.
Create the service authorization object which will be used for fetching the events.

Ref code for service authorization

def create_service_auth
  #create service auth
  @service = Google::Apis::CalendarV3::CalendarService.new
  @service.authorization = token.google_secret.to_authorization
  return unless token.expired?

  new_access_token = @service.authorization.refresh! #refresh access_token
end

Fetching all calendar events(past, present and future).
- The full sync is the original request for all the resources of the collection you want to synchronize.
- In the response to the list operation, you will find a field called nextSyncToken representing a sync token. You'll need to store the value of nextSyncToken. If the result set is too large and the response gets paginated, then the nextSyncToken field is present only on the very last page.
- Depending on what your use case is, it will be better to perform this job as a background task.
- Events: list API is used for this. The gem provides an easier method called list_events

Ref code for syncing events

  def get_events
    @events_arr = []
    @events_list = @service.list_events('primary', single_events: true, max_results: 500)
    @sync_token = @events_list.next_sync_token
    @page_token = @events_list.next_page_token
    @events_arr << @events_list.items
    while @sync_token.blank?
      @events_list = @service.list_events('primary', single_events: true, max_results: 500, page_token: @page_token)
      @sync_token = @events_list.next_sync_token
      @page_token = @events_list.next_page_token
      @events_arr << @events_list.items
    end
  end

2) Create a webhook to receive push notifications

After a full sync of events, the next step is to setup a Webhook so that google can inform us of the changes that we subscribe for.
For every user that links their calendar to the app, we will create a subscription so that we can be informed whenever there is a change in their calendar.

It has the following steps -

Fetch a new access_token if the token has expired.
Create the service authorisation object which will be used for fetching the events, exactly same as shown above.
Set up a Channel - It creates a channel with google and specifies the callback URL or the web-hook URL.
Watch events - After the web-hook is set up, we need to specify what events we want to watch and also need to specify from which calendar.

def setup_channel
  @channel = Google::Apis::CalendarV3::Channel.new(address: callback_url, id: channel_id, type: "web_hook")
end

callback_url - It can't be localhost, it has to be a valid https url. For testing purposes you can use ngrok.
channel_id - This is a UUID - SecureRandom.uuid

  def watch_events
    time_min = DateTime.now.rfc3339
    @webhook = @service.watch_event('primary', @channel, single_events: true, time_min: time_min)
  end

primary - refers to the primary calendar of the user.
single_events - Setting it to true also gives all events belonging to 1 single recurring event.

Now, whenever there will be any change in the primary calendar of the user google will hit the registered web-hook for the user.

In the request Google will pass X-Goog-Resource-ID and X-Goog-Channel-ID. We would have to hit the list_events API again to fetch the changed events data for that user.

Only difference will be that instead of passing the page token like we did earlier, we would pass the sync_token.

  def get_events
    @events_list = @service.list_events('primary', single_events: true, max_results: 2500, sync_token: sync_token)
  end

3) Saving X-Goog-Resource-ID & X-Goog-Channel-ID

When we created the web-hook google will return us with a resource_id, resource_uri, id(that we created). We need to save all this data so that we can get to know for which user the events have changed.
Also the channel expires in around 1 week so we need to keep creating new web-hooks before it expires.

4) Deleting the events with status `cancelled`

This is the flow that took me some time to understand. So what happens when a user changes the time of their event or has the user changed a single event or all the events in a recurring event. What google does is that

if the user changes a single event, then google keeps the calendar_id as same.
if the user changes a recurring event and selects all or following events as option then the calendar_id changes for all the events. Hence, in this case we need to delete the old events and add new events in our system. So, this is a check that you will have to add when saving the calendar events in your system.

That's it - It's quite messy if you are trying to figure it out from scratch and I hope this article will help you all.

If you face any issue, connect with me on twitter and I will be more than happy to help.

Beautiful Pointers

Gautam Sawhney — Fri, 08 May 2020 13:51:55 +0000

Basics

Pointers are an amazing. C allows the programmer to reference the location of objects and the contents of those location using pointers. A pointer is like any other data type in C. The value of a pointer is a memory location, similar to how the value of an integer is a number. Let's see an example

int money = 10
pntr_money = &money

pntr_money - is an integer pointer which would hold the address of money which is &money.
*pntr_money - points to the value in the variable money which is 10.

More details

Consider pntr_money is a pointer to an integer as shown above. Then pntr_money + 1 is a pointer to an integer immediately following the integer *pntr_money in memory, and pntr_money - 1 is the pointer to an integer immediately preceding *pntr_money.

Let us consider a machine which uses byte addressing, an integer requires 4 bytes and the value of pntr_money is 100(that is, pntr_money points to the integer *pntr_money at location 100).

pntr_money = 100
pntr_money - 1 = 96
pntr_money + 1 = 104
pntr_money + 2 = 108

*(pntr_money - 1) = Contents of the 4 bytes 96, 97, 98 and 99 interpreted as an integer.
*(pntr_money + 1) = Contents of the 4 bytes 104, 105, 106 and 107.

Another thing to remember is the difference between *pntr_money + 1 and *(pntr_money + 1)

*pntr_money + 1 - This will increase the value in pntr_money by 1

*(pntr_money + 1) - This will point to the value at the address which is (pntr_money + 1)

Example

Pointers play a prominent rule in passing parameters to functions. Most parameters passed to a function are by value but if we wish to modify the value of the passed parameter we must pass the address of the parameter which is what pointers help with.

Here is an example to understand better -

Line 2 prints 5.
Line 3 invokes funct and the value passed is the pointer value &x.This is the address of x.
The parameter of funct is py of type int *.
Line 7 increments the integer at location py, however the value of py which is &x remains the same. Thus py points to the integer x so that when *py is incremented, x is incremented.
Line 8 prints 6.
Line 4 also prints 6.

Hence, Pointers are the mechanism used in C to allow a called function to modify variables in a calling function.

Caret(^) symbol in Ruby & Ruby on Rails

Gautam Sawhney — Wed, 18 Mar 2020 10:26:32 +0000

^ symbol has multiple uses in ROR.

1- As a bitwise XOR Operator

For each bit in the binary representation of the operands, a bitwise XOR will get a 1 bit if one of the corresponding bits in the operands is 1, but not both, otherwise, the XOR will get a 0 bit. Here's an example:

5     = 101
6     = 110
5 ^ 6 = 011 = 3

2- In Rails validation error message

When you want to override the error message without the attribute name, simply prepend the message with ^ like

validates_numericality_of :identity_id, :message => "^Person field definition id must be an integer"

you get

Person field definition id must be an integer

instead of

Identity Id Person field definition id must be an integer

How NOT to integrate Google Calendar with your product

Gautam Sawhney — Tue, 17 Mar 2020 08:25:34 +0000

Google calendar has decent documentation for most of its products and supports most of the libraries, even then, it's confusing enough to take the wrong approach while integrating with google calendar.

When I set out to build calendar integration for one of my products, I had never thought that it would end up becoming so complicated to do things which I had initially thought to be simple.

Product Requirements

During Signup/Login ask for permission to view/edit/create the events in their primary google calendar.
Fetch the calendar events(both recurring and 1 time) and show them to the users so that they can add more details to it(specific to the product).
Keep in sync with any new events that are created.
Sync existing events between the product and the calendar.
Updating the correct recurring events in google calendar for any updates done to them in my product.

Remember that, my product required 2-way sync of events.

The Incorrect Approach

During my research, most of the blog posts I read pointed to using the Calendar Events List API and my brain started to work in that direction. I took the following approach which is inefficient and unscalable -

Integrated the Calendar Events List API which got me the event information for all the upcoming events.
Saved the ones which matched as per the algorithm of the product
If the user performed any update to these events then update the calendar events accordingly(changes to date/time/description)
Write a Cron job which runs every 30 minutes to check if any new events were added/existing events changed(biggest blunder) for all the users in the database.

The Correct Approach

Soon, I realised that this was not the most efficient and scalable way to achieve the results I wanted.
I dug deeper into the google documentation to realize that there is a synch API which helps in incremental synch of data and works as a webhook. This is what made complete sense and would fit my requirements perfectly.
I am going to talk about this approach in a new series. Stay Tuned