“I want to create a custom launcher for Firefox 2 and Firefox 3 with different profiles. Perhaps the real question is how do we create a custom version of a Mac application launcher, passing in the arguments we need?”

… without having to invoke it on the command line every time.

Mac OS X is assumed.

Firefoxen is an answer in code. It’s a script to automatically configure multiple installations of Firefox so that they open with different profiles. The script encapsulates what I needed to do to figure out how to solve this problem.

The steps are:

1. Modify each application’s Info.plist CFBundleExecutable to point to a shell script inside the application’s bundle
2. Create the appropriate shell script that runs ./firefox-bin -P profile-name in each bundle.
3. Reregister the application’s bundle with launchservices so that the changes are picked up. Normally they are cached.

Only the last of these took too longer to figure out. You can trigger an update of launchservices by renaming the application bundle (Firefox.app => Firefox3.app), but if you rename it back it seems to revert to the previous db entry. (Cached by application name?)

Unfortunately, you can’t combine 1 and 2 either. I tried multiple permutations on changing the CFBundleExecutable parameter in each bundle from the default firefox-bin to something like firefox-bin -P versioned-profile but I couldn’t make it work with any amount of quoting.

Git it here: http://github.com/yesteray/firefoxen/tree

Here’s a screen grab:

Running 4 versions of Firefox.

Here’s the really short story: when you call the insertEvent method, you pass the event that you are creating and optionally, the edit url of the calendar where you want the event to appear. So, to create an event on a secondary calendar, just pass the edit link of the calendar. (You can get the edit link of a calendar in python by calling GetEditLink().href on it.)

For the longer story, I’ll assume that you have installed Python, ElementTree and the Google Data Python Library, following Google’s instructions.

Run through the tests and the sample code. When I ran the calendarExample.py it failed with this stack trace:

Traceback (most recent call last):
  File "./samples/calendar/calendarExample.py", line 577, in <module>
    main()
  File "./samples/calendar/calendarExample.py", line 574, in main
    sample.Run(delete)
  File "./samples/calendar/calendarExample.py", line 498, in Run
    self._PrintAllEventsOnDefaultCalendar()
  File "./samples/calendar/calendarExample.py", line 99, in _PrintAllEventsOnDefaultCalendar
    print '\t\t\t%s' % (a_participant.attendee_status.value,)
AttributeError: 'NoneType' object has no attribute 'value'

Since all I wanted to do was to make this sample code run for the single case of adding an event to a secondary calendar, I commented out line 99, but the code should be checking that there is an attendee status before writing its value. After that change the sample code ran fine for me.

To insert a single event in a secondary calendar, I copied calendarExample.py to secondaryCalendarInsert.py. Then I commented out everything in the Run method except this line:

503

    see = self._InsertSingleEvent()

and made the following change,

266
267

new_event = self.cal_client.InsertEvent(event, 
  '/calendar/feeds/g5b79g3f2bi5hc1it41seuu41c@group.calendar.google.com/private/full')

This instructs the InsertEvent method to create the event in my secondary calendar by POSTing to the url of my “Secondary Calendar” (id g5b79g3f2bi5hc1it41seuu41c@group.calendar.google.com) instead of my primary calendar (id default). I found the calendar ID on the calendar settings page of the calendar, but as I said above, if you have accessed a calendar programatically, you can just call GetEditLink().href on it to get the proper link.

You can see that a “One Time Tennis with Beth” event was inserted beginning at the moment I did the insert and lasting for one hour, as described in the sample code.

[Update 2008-11-14: You can't see this if you are using Safari. In general embedded calendar's show in Safari, but there is something about this particular calendar that causes it not to display. Google does a number of separate calls and redirects to obtain the correct data for this calendar and it looks like one of the calls returns data that doesn't correspond to the mime-types. The point that I was trying to communicate with this illustration was that the event did in fact appear and that it was on the secondary calendar.]

On Sep 9, 2008, at 9:05 AM, nadine wrote:
Dear Ray,

I do hope you don’t mind my email you… I am desperate!!!

I work for a gentleman who in turn works for 6 different companies. Because his calendar entries need to be colour coded I have obviously set up a calendar representing each different company which shows a different colour. This works fine between he and I.

However, he would like to share his calendar with a number of colleagues. Do I firstly have to ask each of his colleagues to open a Google account and then do I send an invite to them? However, I think this invites them only to his one calendar and not to all the associated company calendars?

If you are able to advise, I’d be most grateful. I have trawled the net for approx three hours without success.

Thanks,
Nadine

Hi Nadine,

It depends on what you mean by share.

If your employer wants to share 6 different calendars with another person, and that person will have access to add and delete events, or add other persons to those who can view those calendars, he will need to send 6 separate invitations to that person.

If he wants to do exactly the same for a number of other people, then he still only has to send 6 invitations, but include all of the other people.

There are a couple of easier alternatives, though, if the others don’t need to make changes to the company calendars.

You can see one example at my blog, http://67central.com/bc/calendar/. On that page I have displayed 5 different calendars, that anyone can see. These are embedded calendars using the Google Calendar Embed tool to present 5 calendars, all in different colors on a single web page. If you have your own web server or web page, you could add code to a page and your employers colleagues could view it. They could also add the events to their personal calendars.

One small fly in the ointment of that approach is that the content will be visible to anyone which may be a concern, depending on what is on the calendar.

Finally, you can just send the colleagues the private urls for the 6 calendars. On the settings page of each Google calendar, there are 3 links for the “Private Address.” These are links to the XML, HTML, and iCal formatted versions of the calendar. If you send the colleagues the 6 HMTL private links for each color coded company, then the colleagues can view the calendars in their web browser. If you send them the XML links they will be able to subscribe to those calendars in Google and finally if you send them the iCal links, the colleagues will be able to add those calendars to many different types of calendaring software.

I hope that helps,

Ray

In this series of posts, I am going to attempt to provide an answer for using every language that has a client library. I discuss the “official” client libraries for Python, Php, .NET, Java and Javascript as well as the slightly less official Objective-C library and some of the attempts to create Ruby library for interacting with Google Calendar and GData. If there are other client libraries, just let me know in the comments and I’ll add instructions here, or link to them elsewhere as I have time, interest and understanding.

I start with describing how to POST XML to a calendar url. This is “The Protocol”. You should read this information about the protocol, even if you plan to use a client library. Each client library is using this protocol under the covers, so understanding what is happening will help you better use your client library. In addition, I’ll only explain some terms in this section, so you’ll need to read it to understand what I am talking about.

All information in these posts comes from the Google Developer’s Guides, the Client Library Documentation, the source code for the client library and my own exploration and testing. I’ll provide links to these resources in the text as appropriate. For simplicity’s sake, I only cover creating single-occurrence events for users that have properly authenticated using client login. These cases should be sufficient for illustrating how to add to secondary calendars, but 1) I’m not aware of any differences in creating single-occurrence versus quickadd or recurrent events on secondary calendars in any of the client libraries and 2) I haven’t used AuthSub.

I have personally tested all of the code that I present here, unless otherwise noted. That means that I was able to create an event on a calendar using that code. In all cases, I am adding events to my Secondary Calendar which is public, so have a look. I’ll be trying to add an event that occurs at the time when the relevant article is posted.

Here is a table of contents of the language-specific treatments. I’ll update the links as I complete the sections.

Python - Complete September 29, 2008
Php
.NET
Java
Javascript
Objective C
Ruby

The Protocol

To create an event on any Google Calendar you POST the appropriate XML to the calendar’s url. The easiest way to obtain the appropriate XML is to start with an existing event. The easiest way to obtain the calendar’s url, well, that’s a really the rub.

Here’s what Google says about finding the appropriate url:

To post an entry, send the following HTTP request to Calendar, using a special “default” URL (and an Authorization header; see the section on authentication above). Calendar automatically redirects the default URL to the URL of the read/write private feed of the calendar belonging to the authenticated user. (Note that you don’t have to use the default URL to send a POST request to Calendar; you can specify the user ID instead of “default” if you prefer. For more information, see the Calendar feed types reference.)

This is the source of all the confusion on the issue of creating events on secondary calendars.
As mentioned further on after this quote, the “default” URL is
http://www.google.com/calendar/feeds/default/private/full
If you specify the user ID, this would be http://www.google.com/calendar/feeds/user@gmail.com/private/full, you get another URL for the user’s primary calendar. You can POST to this url and create events.

The question is, what is the user ID for a secondary calendar? If the calendar belongs to your friend, then http://www.google.com/calendar/feeds/friend@gmail.com/private/full works. Suppose that I have created a personal calendar and a work calendar. The user ID for my personal (primary) calendar is my gmail address. What is the user ID for my work calender? My gmail address? No, that is the user ID for my personal calendar.

The problem is that Google doesn’t use the term user ID consistently and what they really mean here is what they call calendar ID in other contexts.

To get the calendar ID, there are a couple of methods.

Google suggests that you parse the calendar ID from the calendar’s edit link in the allcalendars feed. Here is the entire entry for my secondary calendar from the all calendar’s feed.

<entry>
  <id>
  http://www.google.com/calendar/feeds/default/allcalendars/full/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com</id>
  <published>2008-09-01T05:24:24.673Z</published>
  <updated>2008-09-01T04:13:31.000Z</updated>
  <title type='text'>Secondary Calendar</title>
  <summary type='text'>This calendar is for testing and
  illustrating the creation of events using the Google Calendar
  Data API on a secondary calendar.</summary>
  <content type='application/atom+xml'
  src='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full' />
  <link rel='alternate' type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full' />
  <link rel='http://schemas.google.com/acl/2007#accessControlList'
  type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/acl/full' />
  <link rel='self' type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/default/allcalendars/full/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com' />
  <link rel='edit' type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/default/allcalendars/full/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com' />
  <author>
    <name>Secondary Calendar</name>
  </author>
  <gCal:timezone value='America/Los_Angeles' />
  <gCal:timesCleaned value='0' />
  <gCal:hidden value='false' />
  <gCal:color value='#5229A3' />
  <gCal:selected value='true' />
  <gCal:accesslevel value='owner' />
  <gd:where valueString='' />
</entry>

So, Google is suggesting that you take the element <link rel='edit' ... .> element , parse out the href, extract the calendar ID, “2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com”, and substitute it into “http://www.google.com/calendar/feeds/default//full”. That works, but isn’t the most intuitive series of steps.

A more direct way is to just use the src attribute of the content. Since the content of the calendar is empty, Atom specifies that the src attribute must be present, and contain a link to the content. That’s a long way of saying, “This is the link that we want!” To read the content of a calendar, GET the url indicated by the src attribute link of the content. To create an event, POST appropriately formed XML to the src attribute link of the calendar. This is REST 101.

Note that the link in the src attribute of the content is exactly the same as the alternate link. This might be useful information as we work through the various client libraries.

The easiest method is to look it up manually through the UI. In the UI, under the Calendar Details tab of Calendar Settings, there is a section for Calendar Address and included in that section is a parenthetical notation of the Calendar ID.

Note that this is called Calendar ID whether the calendar is the user’s primary calendar (in which case the calendar ID is also the user ID) or a secondary calendar, in which case it is some other user’s email address, or a long string that looks like an e-mail address for an obscure user in the group.calendar.google.com domain, like 2v78cr597kh4kduf3db9t4p1es@group.calendar.google.com. That by the way is the calendar ID in my Secondary Calendar. You can see how Google has used the calendar ID as the src parameter in the link to that calendar, http://www.google.com/calendar/embed?src=2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com.

So now the hard part is over. We have the correct url. Here’s the XML that we’ll send as the data in our post request, cribbed from the Developer’s Guide and modified for our purposes. Follow that link for more details about how additional elements will be added on creation.

<entry xmlns='http://www.w3.org/2005/Atom'
    xmlns:gd='http://schemas.google.com/g/2005'>
  <category scheme='http://schemas.google.com/g/2005#kind'
    term='http://schemas.google.com/g/2005#event'></category>
  <title type='text'>POSTed XML</title>
  <content type='text'>I was POSTed using hand-crafted XML via the Protocol!</content>
  <gd:transparency
    value='http://schemas.google.com/g/2005#event.opaque'>
  </gd:transparency>
  <gd:eventStatus
    value='http://schemas.google.com/g/2005#event.confirmed'>
  </gd:eventStatus>
  <gd:when startTime='2008-09-01'
    endTime='2008-09-02'></gd:when>
</entry>

Wrap this up in a script that I have that does authentication and handles the redirects and POST that <entry> to

https://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es@group.calendar.google.com/private/full

.

Below is Google’s response. More importantly, see the resulting event here. Enjoy.

<?xml version='1.0' encoding='utf-8'?>
<entry xmlns='http://www.w3.org/2005/Atom'
xmlns:batch='http://schemas.google.com/gdata/batch'
xmlns:gCal='http://schemas.google.com/gCal/2005'
xmlns:gd='http://schemas.google.com/g/2005'>
  <id>
  http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full/5q38q19h2s756um8902b9f7mrs</id>
  <published>2008-09-01T11:32:34.000Z</published>
  <updated>2008-09-01T11:32:35.000Z</updated>
  <category scheme='http://schemas.google.com/g/2005#kind'
  term='http://schemas.google.com/g/2005#event' />
  <title type='text'>POSTed XML</title>
  <content type='text'>I was POSTed using hand-crafted XML via the
  Protocol!</content>
  <link rel='alternate' type='text/html'
  href='http://www.google.com/calendar/event?eid=NXEzOHExOWgyczc1NnVtODkwMmI5ZjdtcnMgMnY3OGNyNTk3a2g0a2R1ZjNkYjl0NHAxZXNAZw'
  title='alternate' />
  <link rel='self' type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full/5q38q19h2s756um8902b9f7mrs' />
  <link rel='edit' type='application/atom+xml'
  href='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full/5q38q19h2s756um8902b9f7mrs/63355951955' />
  <author>
    <name>Calendar Maven</name>
    <email>calendar.maven@gmail.com</email>
  </author>
  <gd:comments>
    <gd:feedLink href='http://www.google.com/calendar/feeds/2v78cr597kh4kduf3db9t4p1es%40group.calendar.google.com/private/full/5q38q19h2s756um8902b9f7mrs/comments' />
  </gd:comments>
  <gd:eventStatus value='http://schemas.google.com/g/2005#event.confirmed' />
  <gd:visibility value='http://schemas.google.com/g/2005#event.default' />
  <gd:transparency value='http://schemas.google.com/g/2005#event.opaque' />
  <gCal:uid value='5q38q19h2s756um8902b9f7mrs@google.com' />
  <gCal:sequence value='0' />
  <gd:when startTime='2008-09-01' endTime='2008-09-02' />
  <gd:who rel='http://schemas.google.com/g/2005#event.organizer'
  valueString='Secondary Calendar'
  email='2v78cr597kh4kduf3db9t4p1es@group.calendar.google.com' />
  <gd:where />
</entry>

link rel='alternate' type='application/atom+xml'
link rel='alternate' type='text/calendar'
link rel='alternate' type='text/html'
link rel='edit' type='application/atom+xml'
link rel='http://schemas.google.com/acl/2007#accessControlList'
link rel='http://schemas.google.com/g/2005#batch'
link rel='http://schemas.google.com/acl/2007#controlledObject'
link rel='http://schemas.google.com/g/2005#feed'
link rel='http://schemas.google.com/g/2005#post'
link rel='next' type='application/atom+xml'
link rel='previous' type='application/atom+xml'
link rel='self' type='application/atom+xml'

Notes

Alternate links point to an alternate representation of the same resource. There are three types represented in Google Calendar feeds; the type specifies that nature of the alternate representation. The application/atom+xml type alternate links are all contained inside <entry> elements and point to the individual entry. The text/html type links are to html representations of the calendar or event. The text/calendar are links to ics format calendar files.

The edit links are used to update or delete calendars or events. The post links are used to create calendars or events. The edit links are defined in the Atom Publishing Protocol. Post links are Google’s own invention.

Batch links identify the uri for posting batch request. I have no experience with batch requests, but according to the documentation insert, update, delete, or query operations are permitted.

Feed links in all observed cases are exactly the same as the id of the feed. The self links are related to the feed links and id, but also contain the (possibly implicit) url parameters that were used to retrieve the feed.

AccessControlList links identify the location of the access control list (acl) for the feed. ControlledObject links identify the feed that the acl pertains to.

Next and previous specify Atom Publishing Protocol partial collections. Next and previous are paged feeds.

Just like in the previous example, Calendar may return an HTTP 302 redirect; if so, then the redirect URL has a new parameter, gsessionid, appended to it. If you received the redirect, then send the same POST request again, with the same Authorization header and the same content, but with the gsessionid parameter appended. The response may also include a S cookie, which you should store and send this cookie with future requests as appropriate. Please see the knowledge base for more information on handling sessions with the Calendar data API. Please note: if a session ID indicated in a cookie header conflicts
with the session ID passed as a gsessionid URL parameter, you will get caught in a redirect loop.

The introductory clause obscures important information. Having read the previous example, I thought that there wasn’t much to be gained by reading this paragraph in detail. Just do the same thing as before, “So after you’ve sent the GET request, you have to read the HTTP headers of the response to find the URL with the session ID appended; then you need to send another GET request with that new URL.”

Really, I didn’t think too much. The gsessionid is a persistent session id. You can send it with any future request and if you do, and the session id matches the auth token your request will be accepted without redirect. Moreover you can grab the S cookie and stick it in your headers and not need to worry about it.This is documented here.

Here’s an example in action:

# get_feed is from a project I'm working on
irb:01:0> require 'get_feed'                         
=> true
# it provides an authorization method that also sets @headers and creates @http object
irb:02:0> get_auth('me@gmail.com','top_secret')      
=> {"Authorization"=>"GoogleLogin auth=DQAAAIQAAABECsmTToeu0o97DoPQ8v9lXDkqFYQY4tOC4QmkItA9jb1J2GfEql69SifsFF7TJJ6_lbAST3iuc-aZQUIvY3qDfPj4pNpo9_XAsCEphd9jRdqeqengYDnpTOEJJedw9jRV738b4x-EluyDKDPBw0f46fFDto0o8zkgY_bUChKK0T6j8A5PgedYRRJzQJm_oSY", "Content-Type"=>"application/atom+xml", "Service"=>"67central.com--get-feed-0.0.1"}
irb:03:0> @headers                                   
=> {"Authorization"=>"GoogleLogin auth=DQAAAIQAAABECsmTToeu0o97DoPQ8v9lXDkqFYQY4tOC4QmkItA9jb1J2GfEql69SifsFF7TJJ6_lbAST3iuc-aZQUIvY3qDfPj4pNpo9_XAsCEphd9jRdqeqengYDnpTOEJJedw9jRV738b4x-EluyDKDPBw0f46fFDto0o8zkgY_bUChKK0T6j8A5PgedYRRJzQJm_oSY", "Content-Type"=>"application/atom+xml", "Service"=>"67central.com--get-feed-0.0.1"}
# User's default calendar and own calendars feeds
irb:04:0> default =  '/calendar/feeds/default'          
=> "/calendar/feeds/default"
irb:05:0> all = '/calendar/feeds/default/owncalendars/full'
=> "/calendar/feeds/default/owncalendars/full"
# Request for feeds are redirected           
irb:06:0> @http.get(default,@headers)       
=> #<Net::HTTPFound 302 Moved Temporarily readbody=true>
irb:07:0> response = @http.get(all,@headers)       
=> #<Net::HTTPFound 302 Moved Temporarily readbody=true>
# All calendars feed to this location, note the gsessionid
irb:08:0> response['Location']                       
=> "https://www.google.com:443/calendar/feeds/default/owncalendars/full?gsessionid=uVGhyT0F60BtaKPNVsOeig"
# Also returns this cookie       
irb:09:0> response['set-cookie']                     
=> "S=calendar=uVGhyT0F60BtaKPNVsOeig;Expires=Fri, 08-May-2009 20:54:31 GMT"
irb:10:0> s_cookie =  response["set-cookie"].split(';').first                                                  
=> "S=calendar=uVGhyT0F60BtaKPNVsOeig"
irb:11:0> all_redirect = "/calendar/feeds/default/owncalendars/full?gsessionid=uVGhyT0F60BtaKPNVsOeig"        
=> "/calendar/feeds/default/owncalendars/full?gsessionid=uVGhyT0F60BtaKPNVsOeig"
# With the gsessionid, request succeeds    
irb:12:0> response = @http.get(all_redirect,@headers)
=> #<Net::HTTPOK 200 OK readbody=true>
irb:13:0> default_with_redirect = default + "?gsessionid=uVGhyT0F60BtaKPNVsOeig"                                        
=> "/calendar/feeds/default?gsessionid=uVGhyT0F60BtaKPNVsOeig"
# So does this one                         
irb:14:0> response = @http.get(default_with_redirect,@headers)
=> #<Net::HTTPOK 200 OK readbody=true>
# Set the cookie                        
irb:15:0> @headers['Cookie'] = s_cookie                
=> "S=calendar=uVGhyT0F60BtaKPNVsOeig"
# And both request succeed without gsessionid                     
irb:16:0> response = @http.get(all,@headers)         
=> #<Net::HTTPOK 200 OK readbody=true>
irb:17:0> response = @http.get(default,@headers)         
=> #<Net::HTTPOK 200 OK readbody=true>

I hope that is useful to some one. There is a claim in the documentation (I’ve temporarily lost it) that the API libraries will handle these session ids and cookies automatically. Good to know.

Hi all,

for (CalendarEventEntry event : calEventList) { 
    for (Link link : event.getLinks()) { 
        System.out.println(link.getHref()); 
} 

above code fragment prints three types of links, what these are meant for?
What these links signify in the feed.
–
Regards,
Vijay

This is a question that I had been meaning to address, but I was planning to get to it after I addressed all the different urls that are used in the GCalendar API. Actually this question is easier and more straight-forward to answer, so it makes sense to answer this first. I’ll defer the larger questions of GCalendar event feeds and generic Atom feeds for a later post.

Here’s a complete entry feed (as formated with tidy -xml -indent):

<?xml version='1.0' encoding='utf-8'?>
<entry xmlns='http://www.w3.org/2005/Atom'
xmlns:batch='http://schemas.google.com/gdata/batch'
xmlns:gCal='http://schemas.google.com/gCal/2005'
xmlns:gd='http://schemas.google.com/g/2005'>
  <id>  http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk</id>
  <published>2008-04-21T22:36:07.000Z</published>
  <updated>2008-04-21T22:36:07.000Z</updated>
  <category scheme='http://schemas.google.com/g/2005#kind'
  term='http://schemas.google.com/g/2005#event' />
  <title type='text'>Tennis with Beth</title>
  <content type='text'>Meet for a quick lesson.</content>
  <link rel='alternate' type='text/html'
  href='http://www.google.com/calendar/event?eid=ZzBwZHNqbDE4ZW05dGNkYXU2YmFxZ2F0a2sgdGQzczMyZTZrMWliN3BrZ2liaTd2NmprdGdAZw'
  title='alternate' />
  <link rel='self' type='application/atom+xml'
 href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk' />
  <link rel='edit' type='application/atom+xml'  href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk/63344500567' />
  <author>
    <name>Ray Baxter</name>
    <email>me@gmail.com</email>
  </author>
  <gd:comments>
    <gd:feedLink href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk/comments' />
  </gd:comments>
  <gd:eventStatus value='http://schemas.google.com/g/2005#event.confirmed' />
  <gd:visibility value='http://schemas.google.com/g/2005#event.default' />
  <gd:transparency value='http://schemas.google.com/g/2005#event.opaque' />
  <gCal:uid value='g0pdsjl18em9tcdau6baqgatkk@google.com' />
  <gCal:sequence value='0' />
  <gd:when startTime='2008-04-17T08:00:00.000-07:00'
  endTime='2008-04-17T10:00:00.000-07:00' />
  <gd:who rel='http://schemas.google.com/g/2005#event.organizer'
  valueString=''
  email='td3s32e6k1ib7pkgibi7v6jktg@group.calendar.google.com' />
  <gd:where valueString='Rolling Lawn Courts' />
</entry>

Coming to Vijay’s question, there are three <link> elements in this feed. They are:

<link rel='alternate' type='text/html' href='http://www.google.com/calendar/event?eid=ZzBwZHNqbDE4ZW05dGNkYXU2YmFxZ2F0a2sgdGQzczMyZTZrMWliN3BrZ2liaTd2NmprdGdAZw' title='alternate' />
<link rel='self' type='application/atom+xml' href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk' />
<link rel='edit' type='application/atom+xml' href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk/63344500567' />

The links are named for their relations, i.e. the values of their rel attributes.

The first link is the alternate link, so called because it is an alternative version of the content of this event. In this case the alternate version in html format as you can see by the type='text/html' attribute. Because this calendar is public, you can click on that link and see the event in your browser. Try it.

The second link is a self link. That is the the xml feed for this event, and can repull the event from this feed (in the event that Google’s servers are working, which they don’t appear to be currently.) Notice that the http attribute of the self link is exactly the same URL as the <id>.

<id>
http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk</id>
<link rel='self' type='application/atom+xml'
 href='http://www.google.com/calendar/feeds/td3s32e6k1ib7pkgibi7v6jktg%40group.calendar.google.com/private/full/g0pdsjl18em9tcdau6baqgatkk' />

The self link may not have been the location from you pulled the event. You might have pulled an entire calendar of events (which would have it’s own, distinct, self link) or you might have made a query for events matching some pattern and retrieved a number of events for that feed (which would ought have it’s own self link, but I haven’t verified).

Finally there is the edit link. This is the URL that you use to make changes to the event. Sending a DELETE request to this URL will delete the event. Sending a PUT request will replace event’s data with the data that you send.

For reference, the self and alternate link relations are specified as part of the Atom Syndication Format (RFC4287) and the edit relation is specified as part of the Atom Publication Protocol (RFC5023). A convenient table of all the Atom link relations is here. That table will come in handy as we examine the other link relations in GCalendar feeds.

Basically Purple Include is a mechanism for including the content of other web pages (local or remote) in the body of your page. Here are a couple of examples. Here is a paragraph from a post of mine about Jane Jacob’s work:

Here are two bullet points from the forgotten wisdom of Donald Rumsfeld:

There are three elements of Purple Include.

1. Markup that you add your page. Depending on what you are trying to do, you add a p, blockquote, q, pre, div, or span element with an href attribute.
   The first blockquote above came from this:

   <blockquote href="http://www.warmroom.com/yesterdays/2006/11/12/network-effects-of-the-opposite-kind/#xpath(//p[6])"></blockquote>

   The xpath expression, #xpath(//p[6]), identifies the relevant paragraph on the referenced page that will be included into you page.

2. A javascript that you add to your page.

   <script src="http://codinginparadise.org/projects/purple-include/purple-include.js"></script>

   As you can see, Brad is hosting this script on his site, for rapid development and improvements.

   On load, this java script pulls the marked up elements from your page and makes a call to a service that Brad is running to fetch the content to be included on your page. The script inserts this content into the inner html of the element.

   The content is of the class .included and .includeok. I have styled .included in the dark gray that you see instead of the normal silver that I am using for blockquotes, so you can see the change in color as the content is inserted.

3. Brad is running the service that the javascript calls. This service is doing the xpath queries on the content of the referenced page to get the returned content.

This is an interesting design. When I read about it, the first thing that I thought about was caching of the content. In my examples, I referenced my own pages, as Brad referenced his in his examples. I am sure that if you can read these pages, then Brad’s service can read the referenced pages. I’m probably not going to change the pages that I referenced, but I could.

This could be either a good thing, or a bad thing depending on your purposes. The bad is that the exact elements on a page are subject to change. The sixth paragraph of my Jacob’s post could become the seventh or the fifth if I changed blog templates, or fixed a typo in the post. When including content from another site, all bets are off. Also, the remote server could be off line or inaccessible. Brad could add a cache to his service so that any given xpath element of a referenced url from a specific referrer would return the cached result. There would need to be some way to clear the cache, but see below.

On the other hand, this could be just what you want. This is a way to add dynamic content directly to your page, and you don’t need to worry about updating. For many purposes, having a remote server off line isn’t that big a deal and you are likely to be dealing with more fixed markup than I see on my blog pages. A properly scoped xpath query could pull out exactly what you want from most sites.

A couple of other little things that I came across while playing with this.

You can’t include the same exact url (including xpath parameters) twice. The script uses a hash to map from urls to elements. The server returns the content, the url, and an error and looks up the element in the hash by url. Here is the first of Rumsfeld’s pithy sayings from above:

And here it is again:

Only the second appears; the first is just the roller gif. (You can also see that the styling is different.) This is a bug, or at least an unanticipated use case. You can work around by referring to a non-existent query parameter, so urls

href="http://www.warmroom.com/yesterdays/2006/11/08/rumsfelds-rules/?1#xpath(//div[@class='entry']//li[1])"

and

href="http://www.warmroom.com/yesterdays/2006/11/08/rumsfelds-rules/?2#xpath(//div[@class='entry']//li[2])"

Produce

and

respectively.

Finally, the href attribute isn’t valid with any of p, blockquote, q, pre, div, or span in either html 4 or xhtml. This page is invalid.

The line indicates the current time on a daily calendar.

One interesting link that I found in the comments was this post from Denka, who points out the Google’s Calendar implementation is hobbled by patents. In particular, the display of an event is limited in both Google’s online calendar, or in the xml feed from that calendar, if single events are requested. (singleevents=true is a query parameter in the GData API that expands recurrent events to single events.)

For instance, I created a calendar with a single event that recurs every day, beginning on June 9th, 2007. Using the web interface to the calendar, the last day that this recurring event appears is June 7th, 2008. There are exactly 365 recurrences of the event (2008 is a leap year). You can see the calendar here, although it will be interesting to see what happens after June 9th passes.

I see the same behavior in the xml feed for the calendar. Note that that feed url has the appended query parameters singleevents=true and max-results=400. Also note that Google has used two different styles for creating parameters from compound phrases.

I manually pulled the results from that feed 6 times to figure out what the restrictions were. Here are the resulting file sizes using wget:

-rw-r--r--   1 ray  wheel   36418 Jun  5 01:06 basic?singleevents=true
-rw-r--r--   1 ray  wheel  419435 Jun  5 01:06 basic?singleevents=true&max-results=300
-rw-r--r--   1 ray  wheel  507095 Jun  5 01:06 basic?singleevents=true&max-results=364
-rw-r--r--   1 ray  wheel  508280 Jun  5 01:06 basic?singleevents=true&max-results=365
-rw-r--r--   1 ray  wheel  508280 Jun  5 01:06 basic?singleevents=true&max-results=366
-rw-r--r--   1 ray  wheel  508280 Jun  5 01:06 basic?singleevents=true&max-results=400

Once you have 365 instances of the recurring event in the feed, you don’t get any more data no matter how many you request.

Interestingly, the ics feed doesn’t have this problem and neither would the xml feed if I weren’t using the singleevents parameter. You get a single event with a start, and no end. The xml feed actually contains the VEVENT recurrence data.

Denka says that Microsoft has sewn up the patents in this area so Google had to treat recurrent events this way.

[Update: 2007-07-02] After June 9th passed, nothing changed. Both the feed and the web have only the same 365 events. There are no events after June 7, 2008. You can see this very clearly if you add the start-min parameter to the query string, as in this link which returns no results. Interestingly the date stamp on the returned file is June 5, the last day that I modified the calendar.

-rw-r--r--   1 ray  wheel  1530 Jun  5 01:41 basic?singleevents=true&start-min=2008-06-08