I would like to get all events of a recurring event.
Therefore I set the option singleEvents to true.
Now, when I list all events, the response returns endless items (by using nextPageToken). Sure, I can set a MaxTime to have a maximum time limit.
However, I need the syncToken to get only updated events. Otherwise my server has a lot of synchronization tasks. :(
The server gets Push Notifications when something changed. When I create a recurring event, the server recieved the push notification and tries to get the updated events via the last syncToken (using list events).
How can I set a maximum time limit, so I can get the nextSyncToken without having endless nextPages.
My current call:
GET https://www.googleapis.com/calendar/v3/calendars/[CALENDAR]/events?singleEvents=true&syncToken=[SYNC-TOKEN]
When you use a sync token, GCal gives you all the updated events and the only way to limit the amount of events in each response is to use a pager. Set maxResults to limit the amount of results you get per page (max 2500) and then use pageToken until you get another nextSyncToken which means you are at the last page and there are no more events to sync. Each request will either have a nextSyncToken or nextPageToken but no both.
GCal creates 730 events for repeating events without some kind of limit, so 2 years worth of daily events or just under 61 years for a "first Friday of each month" type event. You can check this with the built in API and copying the results to somewhere you can search and count the instances of one of the keys. With defaults, 250 results per page with the 3rd page returning 230.
This isn't just how many are passed with events list and singleEvents true. You'll see in your GCal calendar that the events stop after this time and if you check back tomorrow there won't be another daily event that's been created.
Of course, there could be many long events since the last sync but since you're using push notifications this shouldn't affect you.
Lately I have been dealing with a similar scenario and came up with this solution:
-set singleEvents to false
-for recurring events retrieve instances individually with timeMin and timeMax
Now you can still use syncTokens and the instances() part of the API let's you break up the recurring events into single events with a query. You just have to make sure you do a full sync if you are nearing timeMax again.
Source: https://developers.google.com/google-apps/calendar/v3/reference/events/instances
Related
My question: how do I update "this and all future" instances in a recurring event which is limited by count so that the total number of events stays consistent?
What is the problem:
Trying to modify recurring event and I follow the below guide:
https://developers.google.com/calendar/recurringevents
Basically to update all future recurring events using a target event, the doc says one need to do two calls:
update existing event to make so it ends before the target event date
create a new recurring event with the same fields except of those need changes.
That works fine until there is an event that is limited by the number of occurrences.
Let's say there is a recurring event limited by 10 occurrences and target event is 5th event.
Now I need to split the original so that the first 4 events goes to the original one (so I update COUNT from 10 to 4) and then I create a new recurring event that holds the rest 6 events (so COUNT is 6 in this case)
My first observation is that this is not how the split events are displayed in google calendar - if I test that manually, the both events still show 10 occurrences but the second one doesn't produce any extra events (I'd expect 14 events from developer perspective, yet there are 10 as any user would expect). That implies there is a different approach here? Is it?
Also if I end up counting manually the number of events, there are still issues with cases like deleting one of the events first (let's say, the 4th event) - now how do I know that I need to show 6 instances in the new one and not 7?
Those thoughts make me think there is a better approach, but I can't find any other alternatives. Any advice on that?
UPDATE
It seems like google does it differently: for example after changing a title for "this and future" events in calendar view, it doesn't seem to produce two different recurring events since if you try to delete "all" events, that will remove all of them completely (rather than deleting only one chunk, either before or after the target event)
It seems like they are creating a bunch of exceptions or maybe "recurring exception" or something to do that. Can't find any examples on how to do that as of now thought.
Can't find any good solution for this after a few days of research and while I need to move forward I ended up with a sort of "compromise" between "good enough UX for my case" and "breaking best practice".
So I ended up updating each event individually which goes against google's warning as shown below but I limited the max count by 50. This is not necessary what others want to do, but this is good enough for the real world use case in my app.
Warning: Do not modify instances individually when you want to modify
the entire recurring event, or "this and following" instances. This
creates lots of exceptions that clutter the calendar, slowing down
access and sending a high number of change notifications to users.
And if user needs to schedule more than that, the user is asked to use "end date" instead.
Again, not ideal by any means so if anyone knows how to handle that correctly or knows how google handles that, you are very welcome to share it! (meh... and I need that for outlook too now...)
UPDATE: just got an idea: as an improvement, one can edit either "all future events" or alternatively the master event + "all previous events" depending on the index of the target event. In this case one can limit the number of requests by 2 (so in case of 50 events I'll need to do 25 requests maximum)
So if user wants to change the title from "Hello" to "Goodby" and if the user picked event number 5 in the series of 50 events to change all future events, we can change the master event to "Goodby" which will change the title of all events, and then update the first 4 events to the original "Hello".
Obligatory summary of comments and chat:
Updating events:
To update specific events in a recurring event you need to update the individual instance by specifying the event instance ID.
This is just the event ID concatenated with a datetime stamp (you can see this when making an Events: instances request for your eventID; if your event ID is xxxxxxxxxxxx then an instance ID would be something like xxxxxxxxxxxx__20200603T170000Z).
Unfortunately there's no direct update-instances endpoint so to update multiple instances in one request you'd need to use batching
The API doesn't have a dedicated method for updating recurring events regardless of the recurrence type, and I presume this is the reason the documentation says to edit the previous recurring event by cutting it down and inserting a new one, as per Google's warning:
Do not modify instances individually when you want to modify the entire recurring event, or "this and following" instances. This creates lots of exceptions that clutter the calendar, slowing down access and sending a high number of change notifications to users.
Batching:
Making a batch update on event instances does keep count consistency. If you edit instances in a batch and then use the 'this and all future events' option when deleting one of the instances of the recurring event they do all get deleted as they're still a part of the recurrance. There is no new event being created in either scenario, the event instances are being changed.
If you play around with Events: instances and use Events: update to change only some instances of an event, then you can see that they all stay part of the same recurrence chain and there is no count change.
For arbitrary large counts, even if you have a recurring event with 9999999 instances, each event still has an ID which you can retrieve from Events: instances. It's stored as a single event for event use, but the IDs of the instances are the identifiers which are different.
Honestly, it's not great that you have to edit each one manually; for large counts like 9999999 it's basically infeasible because you'll have to make a batch request for each set of 100 instances you want to change, but it's the only option available via the API at the moment.
Feature Request:
You can however let Google know that this is a feature that is important for the Calendar API and that you would like to request they implement it. Google's Issue Tracker is a place for developers to report issues and make feature requests for their development services, I'd urge you to make a feature request there, the Calendar API feature request form can be found here.
For example, let's say a conference room was booked for a 12-1pm meeting. At 9am that same morning, a user cancelled that meeting, freeing up the conference room. Is there any way to programmatically run a script which would indicate, if run at 10am, that the room had become available one hour ago?
If you retrieve the event that was cancelled via Events.get, you can get the updated time field as a response, which, in case the event got cancelled, equals the time the event was cancelled. Then, the script can calculate the difference between current time and the time it got cancelled.
You could also use Freebusy to make sure that no one created another event after the previous one got cancelled and that the resource is free for that time.
Update
If you want to know for how long a certain conference room has been free for a certain time, you can:
Get the list of events related to this resource via Events.list, including the ones that were cancelled (set showDeleted to true) to achieve that.
Check if there are any events whose scheduled time matches the time you want to look for (fields start and end).
If any of these events matches, you can calculate, for that event (and in case the event got cancelled and the resource is indeed free - event status is cancelled), the difference between current time and the time the event got cancelled (by checking the field updated).
I hope this is what you wanted.
I created an IFTTT recipe that logs the time I arrive and leave work every day, but it always records it in 1hr blocks.
I'm using iPhone's location to track when I arrive and leave. Everything seems to be working, but calendar events are showing as 1hr blocks rather than just a timestamp.
For example, if I arrive at 8:05am it will show as a block on my calendar from 8:05 to 9:05 rather than just showing for one minute. I'd rather it just say "I arrived at work at 8:05". Thanks in advance!
Am I right in assuming you used the default "Track your work hours in Google Calendar" applet made by Google ?
It uses the Quick add event action to add this event to your calendar. Instead, create your own version of the applet that uses the Create a detailed event action. This allows you to set the following parameters (specifically, it includes Start time and End time):
You can set the start time and end time to the same value, but it will, of course, still read as an event that runs from e.g. 9:05 to 9:05.
If you want to record just a single timestamp, you will need to use a different service to store your data. Perhaps record the data in a Google spreadsheet ?
Any queries, post a comment and I'll get back to you.
I have a question regarding "Add Calendar By URL" function in Google Calendar:
How often it is updated (most sources I've found says 24h per day). Does caladress.ics?noCache workaround still works?
How it is updated? If I have a large calendar (e.g 2008 - 2016) and add a single event, does Calendar reupload the whole calendar or check for diff? If check for diff, is there any limitations?
Is there any limit to how long events could be? E.g is it possible to set 5 year event?
1. How often it is updated (most sources I've found says 24h per day).Does caladress.ics?noCache workaround still works?
Based from the Google thread, updates may take a few hours for the new information to be parsed and viewable by your users.
Note: It might take up to 12 hours for changes to show in your Google Calendar.
You can use no-cache to indicate that the returned response cannot be used to satisfy a subsequent request to the same URL without first checking with the server if the response has changed. Here is the documentation and example.
2. How it is updated? If I have a large calendar (e.g 2008 - 2016) and add a single event, does Calendar reupload the whole calendar or check for diff? If check for diff,is there any limitations?
Calendar is updated based on how you will implement the "incremental synchronization" of calendar data. It can be Initial full sync or Incremental sync.
Initial full sync is performed once at the very beginning in order to fully synchronize the client’s state with the server’s state. You can optionally restrict the list request using request parameters if you only want to synchronize a specific subset of resources.
While Incremental sync allows you to retrieve all the resources that have been modified since the last sync request. You need to perform a list request with your most recent sync token specified in the syncToken field. Keep in mind that the result will always contain deleted entries, so that the clients get the chance to remove them from storage.
3. Is there any limit to how long events could be? E.g is it possible to set 5 year event?
For the limitation, the Google Calendar API has a courtesy limit of 1,000,000 queries per day. You can see the calendar usage limits here. It is possible to set an event as long as you haven't reached the limit for the number of events you can create.
Using Calendar API V3, I've noticed that the number of events returned is not consistent with the number of events that appear on a given Calendar. It appears this issue occurs for recurring events that users have moved to a different day, or deleted on a given day. Calendar doesn't seem to recognize this and still returns them. Both Events:get and Events:list show the nonexistent events.
Is there any workaround or means of identifying that an event returned by the API does not actually appear on the (web interface) calendar?
Thanks
I noticed that when you set singleEvents to true the problem doesn't occur. It depends on your use case whether this is an acceptable workaround.
Documentation on singleEvents:
Whether to expand recurring events into instances and only return single one-off events and instances of recurring events, but not the underlying recurring events themselves. Optional. The default is False.
https://developers.google.com/google-apps/calendar/v3/reference/events/list
You can .setShowDeleted 'false' in the request. Example Java:
Events events = calendarService.events().list(PRIMARY_CALENDAR_ID)
.setShowDeleted(false)
.setPageToken(nextPageToken).execute();
But note also that:
Cancelled instances of recurring events (but not the underlying
recurring event) will still be included if showDeleted and
singleEvents are both False.
For further reading see https://developers.google.com/google-apps/calendar/v3/reference/events/list