#!/opt/local/bin/python2.7
#
# Copyright (C) 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


__author__ = 'api.rboyd@gmail.com (Ryan Boyd)'


try:
  from xml.etree import ElementTree
except ImportError:
  from elementtree import ElementTree
import gdata.calendar.data
import gdata.calendar.client
import gdata.acl.data
import atom
import getopt
import sys
import string
import time


class CalendarExample:

  def __init__(self, email, password):
    """Creates a CalendarService and provides ClientLogin auth details to it.
    The email and password are required arguments for ClientLogin.  The
    CalendarService automatically sets the service to be 'cl', as is
    appropriate for calendar.  The 'source' defined below is an arbitrary
    string, but should be used to reference your name or the name of your
    organization, the app name and version, with '-' between each of the three
    values.  The account_type is specified to authenticate either
    Google Accounts or Google Apps accounts.  See gdata.service or
    http://code.google.com/apis/accounts/AuthForInstalledApps.html for more
    info on ClientLogin.  NOTE: ClientLogin should only be used for installed
    applications and not for multi-user web applications."""

    self.cal_client = gdata.calendar.client.CalendarClient(source='Google-Calendar_Python_Sample-1.0')
    self.cal_client.ClientLogin(email, password, self.cal_client.source);

  def _PrintUserCalendars(self):
    """Retrieves the list of calendars to which the authenticated user either
    owns or subscribes to.  This is the same list as is represented in the
    Google Calendar GUI.  Although we are only printing the title of the
    calendar in this case, other information, including the color of the
    calendar, the timezone, and more.  See CalendarListEntry for more details
    on available attributes."""

    feed = self.cal_client.GetAllCalendarsFeed()
    print 'Printing allcalendars: %s' % feed.title.text
    for i, a_calendar in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, a_calendar.title.text,)

  def _PrintOwnCalendars(self):
    """Retrieves the list of calendars to which the authenticated user
    owns --
    Although we are only printing the title of the
    calendar in this case, other information, including the color of the
    calendar, the timezone, and more.  See CalendarListEntry for more details
    on available attributes."""

    feed = self.cal_client.GetOwnCalendarsFeed()
    print 'Printing owncalendars: %s' % feed.title.text
    for i, a_calendar in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, a_calendar.title.text,)

  def _PrintAllEventsOnDefaultCalendar(self):
    """Retrieves all events on the primary calendar for the authenticated user.
    In reality, the server limits the result set intially returned.  You can
    use the max_results query parameter to allow the server to send additional
    results back (see query parameter use in DateRangeQuery for more info).
    Additionally, you can page through the results returned by using the
    feed.GetNextLink().href value to get the location of the next set of
    results."""

    feed = self.cal_client.GetCalendarEventFeed()
    print 'Events on Primary Calendar: %s' % (feed.title.text,)
    for i, an_event in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, an_event.title.text,)
      for p, a_participant in zip(xrange(len(an_event.who)), an_event.who):
        print '\t\t%s. %s' % (p, a_participant.email,)
        print '\t\t\t%s' % (a_participant.value,)
        if a_participant.attendee_status:
          print '\t\t\t%s' % (a_participant.attendee_status.value,)

  def _FullTextQuery(self, text_query='Tennis'):
    """Retrieves events from the calendar which match the specified full-text
    query.  The full-text query searches the title and content of an event,
    but it does not search the value of extended properties at the time of
    this writing.  It uses the default (primary) calendar of the authenticated
    user and uses the private visibility/full projection feed.  Please see:
    http://code.google.com/apis/calendar/reference.html#Feeds
    for more information on the feed types.  Note: as we're not specifying
    any query parameters other than the full-text query, recurring events
    returned will not have gd:when elements in the response.  Please see
    the Google Calendar API query paramters reference for more info:
    http://code.google.com/apis/calendar/reference.html#Parameters"""

    print 'Full text query for events on Primary Calendar: \'%s\'' % (
        text_query,)
    query = gdata.calendar.client.CalendarEventQuery(text_query=text_query)
    feed = self.cal_client.GetCalendarEventFeed(q=query)
    for i, an_event in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, an_event.title.text,)
      print '\t\t%s. %s' % (i, an_event.content.text,)
      for a_when in an_event.when:
        print '\t\tStart time: %s' % (a_when.start,)
        print '\t\tEnd time:   %s' % (a_when.end,)

  def _DateRangeQuery(self, start_date='2007-01-01', end_date='2007-07-01'):
    """Retrieves events from the server which occur during the specified date
    range.  This uses the CalendarEventQuery class to generate the URL which is
    used to retrieve the feed.  For more information on valid query parameters,
    see: http://code.google.com/apis/calendar/reference.html#Parameters"""

    print 'Date range query for events on Primary Calendar: %s to %s' % (
        start_date, end_date,)
    query = gdata.calendar.client.CalendarEventQuery(start_min=start_date, start_max=end_date)
    feed = self.cal_client.GetCalendarEventFeed(q=query)
    for i, an_event in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, an_event.title.text,)
      for a_when in an_event.when:
        print '\t\tStart time: %s' % (a_when.start,)
        print '\t\tEnd time:   %s' % (a_when.end,)

  def _InsertCalendar(self, title='Little League Schedule',
      description='This calendar contains practice and game times',
      time_zone='America/Los_Angeles', hidden=False, location='Oakland',
      color='#2952A3'):
    """Creates a new calendar using the specified data."""
    print 'Creating new calendar with title "%s"' % title
    calendar = gdata.calendar.data.CalendarEntry()
    calendar.title = atom.data.Title(text=title)
    calendar.summary = atom.data.Summary(text=description)
    calendar.where.append(gdata.calendar.data.CalendarWhere(value=location))
    calendar.color = gdata.calendar.data.ColorProperty(value=color)
    calendar.timezone = gdata.calendar.data.TimeZoneProperty(value=time_zone)

    if hidden:
      calendar.hidden = gdata.calendar.data.HiddenProperty(value='true')
    else:
      calendar.hidden = gdata.calendar.data.HiddenProperty(value='false')

    new_calendar = self.cal_client.InsertCalendar(new_calendar=calendar)
    return new_calendar

  def _UpdateCalendar(self, calendar, title='New Title', color=None):
    """Updates the title and, optionally, the color of the supplied calendar"""
    print 'Updating the calendar titled "%s" with the title "%s"' % (
        calendar.title.text, title)
    calendar.title = atom.data.Title(text=title)
    if color is not None:
      calendar.color = gdata.calendar.data.ColorProperty(value=color)

    updated_calendar = self.cal_client.Update(calendar)
    return updated_calendar

  def _DeleteAllCalendars(self):
    """Deletes all calendars.  Note: the primary calendar cannot be deleted"""
    feed = self.cal_client.GetOwnCalendarsFeed()
    for entry in feed.entry:
      print 'Deleting calendar: %s' % entry.title.text
      try:
        self.cal_client.Delete(entry.GetEditLink().href)
      except gdata.client.RequestError, msg:
        if msg.body.startswith('Cannot remove primary calendar'):
            print '\t%s' % msg.body
        else:
            print '\tUnexpected Error: %s' % msg.body

  def _InsertSubscription(self,
      id='python.gcal.test%40gmail.com'):
    """Subscribes to the calendar with the specified ID."""
    print 'Subscribing to the calendar with ID: %s' % id
    calendar = gdata.calendar.data.CalendarEntry()
    calendar.id = atom.data.Id(text=id)
    returned_calendar = self.cal_client.InsertCalendarSubscription(calendar)
    return returned_calendar

  def _UpdateCalendarSubscription(self,
      id='python.gcal.test%40gmail.com',
      color=None, hidden=None, selected=None):
    """Updates the subscription to the calendar with the specified ID."""
    print 'Updating the calendar subscription with ID: %s' % id
    calendar_url = (
      'http://www.google.com/calendar/feeds/default/allcalendars/full/%s' % id)
    calendar_entry = self.cal_client.GetCalendarEntry(calendar_url)

    if color is not None:
      calendar_entry.color = gdata.calendar.data.ColorProperty(value=color)
    if hidden is not None:
      if hidden:
        calendar_entry.hidden = gdata.calendar.data.HiddenProperty(value='true')
      else:
        calendar_entry.hidden = gdata.calendar.data.HiddenProperty(value='false')
    if selected is not None:
      if selected:
        calendar_entry.selected = gdata.calendar.data.SelectedProperty(value='true')
      else:
        calendar_entry.selected = gdata.calendar.data.SelectedProperty(value='false')

    updated_calendar = self.cal_client.Update(calendar_entry)
    return updated_calendar

  def _DeleteCalendarSubscription(self,
      id='python.gcal.test%40gmail.com'):
    """Deletes the subscription to the calendar with the specified ID."""
    print 'Deleting the calendar subscription with ID: %s' % id
    calendar_url = (
      'http://www.google.com/calendar/feeds/default/allcalendars/full/%s' % id)
    calendar_entry = self.cal_client.GetCalendarEntry(calendar_url)
    self.cal_client.Delete(calendar_entry.GetEditLink().href)

  def _InsertEvent(self, title='Tennis with Beth',
      content='Meet for a quick lesson', where='On the courts',
      start_time=None, end_time=None, recurrence_data=None):
    """Inserts a basic event using either start_time/end_time definitions
    or gd:recurrence RFC2445 icalendar syntax.  Specifying both types of
    dates is not valid.  Note how some members of the CalendarEventEntry
    class use arrays and others do not.  Members which are allowed to occur
    more than once in the calendar or GData "kinds" specifications are stored
    as arrays.  Even for these elements, Google Calendar may limit the number
    stored to 1.  The general motto to use when working with the Calendar data
    API is that functionality not available through the GUI will not be
    available through the API.  Please see the GData Event "kind" document:
    http://code.google.com/apis/gdata/elements.html#gdEventKind
    for more information"""

    event = gdata.calendar.data.CalendarEventEntry()
    event.title = atom.data.Title(text=title)
    event.content = atom.data.Content(text=content)
    event.where.append(gdata.data.Where(value=where))

    if recurrence_data is not None:
      # Set a recurring event
      event.recurrence = gdata.data.Recurrence(text=recurrence_data)
    else:
      if start_time is None:
        # Use current time for the start_time and have the event last 1 hour
        start_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime())
        end_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z',
            time.gmtime(time.time() + 3600))
      event.when.append(gdata.data.When(start=start_time,
          end=end_time))

    new_event = self.cal_client.InsertEvent(event)

    return new_event

  def _InsertSingleEvent(self, title='One-time Tennis with Beth',
      content='Meet for a quick lesson', where='On the courts',
      start_time=None, end_time=None):
    """Uses the _InsertEvent helper method to insert a single event which
    does not have any recurrence syntax specified."""

    new_event = self._InsertEvent(title, content, where, start_time, end_time,
        recurrence_data=None)

    print 'New single event inserted: %s' % (new_event.id.text,)
    print '\tEvent edit URL: %s' % (new_event.GetEditLink().href,)
    print '\tEvent HTML URL: %s' % (new_event.GetHtmlLink().href,)

    return new_event

  def _InsertRecurringEvent(self, title='Weekly Tennis with Beth',
      content='Meet for a quick lesson', where='On the courts',
      recurrence_data=None):
    """Uses the _InsertEvent helper method to insert a recurring event which
    has only RFC2445 icalendar recurrence syntax specified.  Note the use of
    carriage return/newline pairs at the end of each line in the syntax.  Even
    when specifying times (as opposed to only dates), VTIMEZONE syntax is not
    required if you use a standard Java timezone ID.  Please see the docs for
    more information on gd:recurrence syntax:
    http://code.google.com/apis/gdata/elements.html#gdRecurrence
    """

    if recurrence_data is None:
      recurrence_data = ('DTSTART;VALUE=DATE:20070501\r\n'
        + 'DTEND;VALUE=DATE:20070502\r\n'
        + 'RRULE:FREQ=WEEKLY;BYDAY=Tu;UNTIL=20070904\r\n')

    new_event = self._InsertEvent(title, content, where,
        recurrence_data=recurrence_data, start_time=None, end_time=None)

    print 'New recurring event inserted: %s' % (new_event.id.text,)
    print '\tEvent edit URL: %s' % (new_event.GetEditLink().href,)
    print '\tEvent HTML URL: %s' % (new_event.GetHtmlLink().href,)

    return new_event

  def _InsertQuickAddEvent(self,
      content="Tennis with John today 3pm-3:30pm"):
    """Creates an event with the quick_add property set to true so the content
    is processed as quick add content instead of as an event description."""
    event = gdata.calendar.data.CalendarEventEntry()
    event.content = atom.data.Content(text=content)
    event.quick_add = gdata.calendar.data.QuickAddProperty(value='true')

    new_event = self.cal_client.InsertEvent(event)
    return new_event

  def _InsertSimpleWebContentEvent(self):
    """Creates a WebContent object and embeds it in a WebContentLink.
    The WebContentLink is appended to the existing list of links in the event
    entry.  Finally, the calendar client inserts the event."""

    # Create a WebContent object
    url = 'http://www.google.com/logos/worldcup06.gif'
    web_content = gdata.calendar.data.WebContent(url=url, width='276', height='120')

    # Create a WebContentLink object that contains the WebContent object
    title = 'World Cup'
    href = 'http://www.google.com/calendar/images/google-holiday.gif'
    type = 'image/gif'
    web_content_link = gdata.calendar.data.WebContentLink(title=title, href=href,
        link_type=type, web_content=web_content)

    # Create an event that contains this web content
    event = gdata.calendar.data.CalendarEventEntry()
    event.link.append(web_content_link)

    print 'Inserting Simple Web Content Event'
    new_event = self.cal_client.InsertEvent(event)
    return new_event

  def _InsertWebContentGadgetEvent(self):
    """Creates a WebContent object and embeds it in a WebContentLink.
    The WebContentLink is appended to the existing list of links in the event
    entry.  Finally, the calendar client inserts the event.  Web content
    gadget events display Calendar Gadgets inside Google Calendar."""

    # Create a WebContent object
    url = 'http://google.com/ig/modules/datetime.xml'
    web_content = gdata.calendar.data.WebContent(url=url, width='300', height='136')
    web_content.web_content_gadget_pref.append(
        gdata.calendar.data.WebContentGadgetPref(name='color', value='green'))

    # Create a WebContentLink object that contains the WebContent object
    title = 'Date and Time Gadget'
    href = 'http://gdata.ops.demo.googlepages.com/birthdayicon.gif'
    type = 'application/x-google-gadgets+xml'
    web_content_link = gdata.calendar.data.WebContentLink(title=title, href=href,
        link_type=type, web_content=web_content)

    # Create an event that contains this web content
    event = gdata.calendar.data.CalendarEventEntry()
    event.link.append(web_content_link)

    print 'Inserting Web Content Gadget Event'
    new_event = self.cal_client.InsertEvent(event)
    return new_event

  def _UpdateTitle(self, event, new_title='Updated event title'):
    """Updates the title of the specified event with the specified new_title.
    Note that the UpdateEvent method (like InsertEvent) returns the
    CalendarEventEntry object based upon the data returned from the server
    after the event is inserted.  This represents the 'official' state of
    the event on the server.  The 'edit' link returned in this event can
    be used for future updates.  Due to the use of the 'optimistic concurrency'
    method of version control, most GData services do not allow you to send
    multiple update requests using the same edit URL.  Please see the docs:
    http://code.google.com/apis/gdata/reference.html#Optimistic-concurrency
    """

    previous_title = event.title.text
    event.title.text = new_title
    print 'Updating title of event from:\'%s\' to:\'%s\'' % (
        previous_title, event.title.text,)
    return self.cal_client.Update(event)

  def _AddReminder(self, event, minutes=10):
    """Adds a reminder to the event.  This uses the default reminder settings
    for the user to determine what type of notifications are sent (email, sms,
    popup, etc.) and sets the reminder for 'minutes' number of minutes before
    the event.  Note: you can only use values for minutes as specified in the
    Calendar GUI."""

    for a_when in event.when:
      if len(a_when.reminder) > 0:
        a_when.reminder[0].minutes = minutes
      else:
        a_when.reminder.append(gdata.data.Reminder(minutes=str(minutes)))

    print 'Adding %d minute reminder to event' % (minutes,)
    return self.cal_client.Update(event)

  def _AddExtendedProperty(self, event,
      name='http://www.example.com/schemas/2005#mycal.id', value='1234'):
    """Adds an arbitrary name/value pair to the event.  This value is only
    exposed through the API.  Extended properties can be used to store extra
    information needed by your application.  The recommended format is used as
    the default arguments above.  The use of the URL format is to specify a
    namespace prefix to avoid collisions between different applications."""

    event.extended_property.append(
        gdata.calendar.data.CalendarExtendedProperty(name=name, value=value))
    print 'Adding extended property to event: \'%s\'=\'%s\'' % (name, value,)
    return self.cal_client.Update(event)

  def _DeleteEvent(self, event):
    """Given an event object returned for the calendar server, this method
    deletes the event.  The edit link present in the event is the URL used
    in the HTTP DELETE request."""

    self.cal_client.Delete(event.GetEditLink().href)

  def _PrintAclFeed(self):
    """Sends a HTTP GET to the default ACL URL
    (http://www.google.com/calendar/feeds/default/acl/full) and displays the
    feed returned in the response."""

    feed = self.cal_client.GetCalendarAclFeed()
    print feed.title.text
    for i, a_rule in zip(xrange(len(feed.entry)), feed.entry):
      print '\t%s. %s' % (i, a_rule.title.text,)
      print '\t\t Role: %s' % (a_rule.role.value,)
      print '\t\t Scope %s - %s' % (a_rule.scope.type, a_rule.scope.value)

  def _CreateAclRule(self, username):
    """Creates a ACL rule that grants the given user permission to view
    free/busy information on the default calendar.  Note: It is not necessary
    to specify a title for the ACL entry.  The server will set this to be the
    value of the role specified (in this case "freebusy")."""

    print 'Creating Acl rule for user: %s' % username
    rule = gdata.calendar.data.CalendarAclEntry()
    rule.scope = gdata.acl.data.AclScope(value=username, type="user")
    roleValue = "http://schemas.google.com/gCal/2005#%s" % ("freebusy")
    rule.role = gdata.acl.data.AclRole(value=roleValue)
    aclUrl = "https://www.google.com/calendar/feeds/default/acl/full"
    returned_rule = self.cal_client.InsertAclEntry(rule, aclUrl)

  def _RetrieveAclRule(self, username):
    """Builds the aclEntryUri or the entry created in the previous example.
    The sends a HTTP GET message and displays the entry returned in the
    response."""

    aclEntryUri = "http://www.google.com/calendar/feeds/"
    aclEntryUri += "default/acl/full/user:%s" % (username)
    entry = self.cal_client.GetCalendarAclEntry(aclEntryUri)
    print '\t%s' % (entry.title.text,)
    print '\t\t Role: %s' % (entry.role.value,)
    print '\t\t Scope %s - %s' % (entry.scope.type, entry.scope.value)
    return entry

  def _UpdateAclRule(self, entry):
    """Modifies the value of the role in the given entry and POSTs the updated
    entry.  Note that while the role of an ACL entry can be updated, the
    scope can not be modified."""

    print 'Update Acl rule: %s' % (entry.GetEditLink().href)
    roleValue = "http://schemas.google.com/gCal/2005#%s" % ("read")
    entry.role = gdata.acl.data.AclRole(value=roleValue)
    returned_rule = self.cal_client.Update(entry)

  def _DeleteAclRule(self, entry):
    """Given an ACL entry returned for the calendar server, this method
    deletes the entry.  The edit link present in the entry is the URL used
    in the HTTP DELETE request."""

    self.cal_client.Delete(entry.GetEditLink().href)

  def _batchRequest(self, updateEntry, deleteEntry):
    """Execute a batch request to create, update and delete an entry."""

    print 'Executing batch request to insert, update and delete entries.'
    # feed that holds all the batch rquest entries
    request_feed = gdata.calendar.data.CalendarEventFeed()

    # creating an event entry to insert
    insertEntry = gdata.calendar.data.CalendarEventEntry()
    insertEntry.title = atom.data.Title(text='Python: batch insert')
    insertEntry.content = atom.data.Content(text='my content')
    start_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime())
    end_time = time.strftime('%Y-%m-%dT%H:%M:%S.000Z',
                             time.gmtime(time.time() + 3600))
    insertEntry.when.append(gdata.calendar.data.When(start=start_time,
                                                     end=end_time))
    insertEntry.batch_id = gdata.data.BatchId(text='insert-request')

    # add the insert entry to the batch feed
    request_feed.AddInsert(entry=insertEntry)

    if updateEntry:
      updateEntry.batch_id = gdata.data.BatchId(text='update-request')
      updateEntry.title = atom.data.Title(text='Python: batch update')
      # add the update entry to the batch feed
      request_feed.AddUpdate(entry=updateEntry)

    if deleteEntry:
      deleteEntry.batch_id = gdata.data.BatchId(text='delete-request')
      # add the delete entry to the batch feed
      request_feed.AddDelete(entry=deleteEntry)

    # submit the batch request to the server
    response_feed = self.cal_client.ExecuteBatch(request_feed, gdata.calendar.client.DEFAULT_BATCH_URL)

    # iterate the response feed to get the operation status
    for entry in response_feed.entry:
      print '\tbatch id: %s' % (entry.batch_id.text,)
      print '\tstatus: %s' % (entry.batch_status.code,)
      print '\treason: %s' % (entry.batch_status.reason,)
      if entry.batch_id.text == 'insert-request':
        insertEntry = entry
      elif entry.batch_id.text == 'update-request':
        updateEntry = entry

    return (insertEntry, updateEntry)

  def Run(self, delete='false'):
    """Runs each of the example methods defined above.  Note how the result
    of the _InsertSingleEvent call is used for updating the title and the
    result of updating the title is used for inserting the reminder and
    again with the insertion of the extended property.  This is due to the
    Calendar's use of GData's optimistic concurrency versioning control system:
    http://code.google.com/apis/gdata/reference.html#Optimistic-concurrency
    """

    # Getting feeds and query results
    self._PrintUserCalendars()
    self._PrintOwnCalendars()
    self._PrintAllEventsOnDefaultCalendar()
    self._FullTextQuery()
    self._DateRangeQuery()

    # Inserting and updating events
    see = self._InsertSingleEvent()
    see_u_title = self._UpdateTitle(see, 'New title for single event')
    see_u_reminder = self._AddReminder(see_u_title, minutes=30)
    see_u_ext_prop = self._AddExtendedProperty(see_u_reminder,
        name='propname', value='propvalue')
    ree = self._InsertRecurringEvent()
    simple_web_content_event = self._InsertSimpleWebContentEvent()
    web_content_gadget_event = self._InsertWebContentGadgetEvent()
    quick_add_event = self._InsertQuickAddEvent()

    # Access Control List examples
    self._PrintAclFeed()
    self._CreateAclRule("user@gmail.com")
    entry = self._RetrieveAclRule("user@gmail.com")
    self._UpdateAclRule(entry)
    self._DeleteAclRule(entry)

    # Creating, updating and deleting calendars
    inserted_calendar = self._InsertCalendar()
    updated_calendar = self._UpdateCalendar(calendar=inserted_calendar)

    # Insert Subscription
    inserted_subscription = self._InsertSubscription()
    updated_subscription = self._UpdateCalendarSubscription(selected=False)

    # Execute a batch request
    (quick_add_event, see_u_ext_prop) = self._batchRequest(see_u_ext_prop,
                                                           quick_add_event)

    # Delete entries if delete argument='true'
    if delete == 'true':
      print 'Deleting created events'
      self.cal_client.Delete(see_u_ext_prop)
      self.cal_client.Delete(ree)
      self.cal_client.Delete(simple_web_content_event)
      self.cal_client.Delete(web_content_gadget_event)
      self.cal_client.Delete(quick_add_event)
      print 'Deleting subscriptions'
      self._DeleteCalendarSubscription()
      print 'Deleting all calendars'
      self._DeleteAllCalendars()


def main():
  """Runs the CalendarExample application with the provided username and
  and password values.  Authentication credentials are required.
  NOTE: It is recommended that you run this sample using a test account."""

  # parse command line options
  try:
    opts, args = getopt.getopt(sys.argv[1:], "", ["user=", "pw=", "delete="])
  except getopt.error, msg:
    print ('python calendarExample.py --user [username] --pw [password] ' +
        '--delete [true|false] ')
    sys.exit(2)

  user = ''
  pw = ''
  delete = 'false'

  # Process options
  for o, a in opts:
    if o == "--user":
      user = a
    elif o == "--pw":
      pw = a
    elif o == "--delete":
      delete = a

  if user == '' or pw == '':
    print ('python calendarExample.py --user [username] --pw [password] ' +
        '--delete [true|false] ')
    sys.exit(2)

  sample = CalendarExample(user, pw)
  sample.Run(delete)

if __name__ == '__main__':
  main()
