#!/usr/bin/python # # Copyright (C) 2006 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. """Contains extensions to ElementWrapper objects used with Google Calendar.""" __author__ = 'api.vli (Vivian Li), api.rboyd (Ryan Boyd)' try: from xml.etree import cElementTree as ElementTree except ImportError: try: import cElementTree as ElementTree except ImportError: try: from xml.etree import ElementTree except ImportError: from elementtree import ElementTree import atom import gdata # XML namespaces which are often used in Google Calendar entities. GCAL_NAMESPACE = 'http://schemas.google.com/gCal/2005' GCAL_TEMPLATE = '{http://schemas.google.com/gCal/2005}%s' WEB_CONTENT_LINK_REL = '%s/%s' % (GCAL_NAMESPACE, 'webContent') GACL_NAMESPACE = gdata.GACL_NAMESPACE GACL_TEMPLATE = gdata.GACL_TEMPLATE class ValueAttributeContainer(atom.AtomBase): """A parent class for all Calendar classes which have a value attribute. Children include Color, AccessLevel, Hidden """ _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value=None, extension_elements=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class Color(ValueAttributeContainer): """The Google Calendar color element""" _tag = 'color' _namespace = GCAL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class AccessLevel(ValueAttributeContainer): """The Google Calendar accesslevel element""" _tag = 'accesslevel' _namespace = GCAL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class Hidden(ValueAttributeContainer): """The Google Calendar hidden element""" _tag = 'hidden' _namespace = GCAL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class Selected(ValueAttributeContainer): """The Google Calendar selected element""" _tag = 'selected' _namespace = GCAL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class Timezone(ValueAttributeContainer): """The Google Calendar timezone element""" _tag = 'timezone' _namespace = GCAL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class Where(atom.AtomBase): """The Google Calendar Where element""" _tag = 'where' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['valueString'] = 'value_string' def __init__(self, value_string=None, extension_elements=None, extension_attributes=None, text=None): self.value_string = value_string self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class CalendarListEntry(gdata.GDataEntry, gdata.LinkFinder): """A Google Calendar meta Entry flavor of an Atom Entry """ _tag = gdata.GDataEntry._tag _namespace = gdata.GDataEntry._namespace _children = gdata.GDataEntry._children.copy() _attributes = gdata.GDataEntry._attributes.copy() _children['{%s}color' % GCAL_NAMESPACE] = ('color', Color) _children['{%s}accesslevel' % GCAL_NAMESPACE] = ('access_level', AccessLevel) _children['{%s}hidden' % GCAL_NAMESPACE] = ('hidden', Hidden) _children['{%s}selected' % GCAL_NAMESPACE] = ('selected', Selected) _children['{%s}timezone' % GCAL_NAMESPACE] = ('timezone', Timezone) _children['{%s}where' % gdata.GDATA_NAMESPACE] = ('where', Where) def __init__(self, author=None, category=None, content=None, atom_id=None, link=None, published=None, title=None, updated=None, color=None, access_level=None, hidden=None, timezone=None, selected=None, where=None, extension_elements=None, extension_attributes=None, text=None): gdata.GDataEntry.__init__(self, author=author, category=category, content=content, atom_id=atom_id, link=link, published=published, title=title, updated=updated, text=None) self.color = color self.access_level = access_level self.hidden = hidden self.selected = selected self.timezone = timezone self.where = where class CalendarListFeed(gdata.GDataFeed, gdata.LinkFinder): """A Google Calendar meta feed flavor of an Atom Feed""" _tag = gdata.GDataFeed._tag _namespace = gdata.GDataFeed._namespace _children = gdata.GDataFeed._children.copy() _attributes = gdata.GDataFeed._attributes.copy() _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [CalendarListEntry]) class Scope(atom.AtomBase): """The Google ACL scope element""" _tag = 'scope' _namespace = GACL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' _attributes['type'] = 'type' def __init__(self, extension_elements=None, value=None, scope_type=None, extension_attributes=None, text=None): self.value = value self.type = scope_type self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class Role(ValueAttributeContainer): """The Google Calendar timezone element""" _tag = 'role' _namespace = GACL_NAMESPACE _children = ValueAttributeContainer._children.copy() _attributes = ValueAttributeContainer._attributes.copy() class CalendarAclEntry(gdata.GDataEntry, gdata.LinkFinder): """A Google Calendar ACL Entry flavor of an Atom Entry """ _tag = gdata.GDataEntry._tag _namespace = gdata.GDataEntry._namespace _children = gdata.GDataEntry._children.copy() _attributes = gdata.GDataEntry._attributes.copy() _children['{%s}scope' % GACL_NAMESPACE] = ('scope', Scope) _children['{%s}role' % GACL_NAMESPACE] = ('role', Role) def __init__(self, author=None, category=None, content=None, atom_id=None, link=None, published=None, title=None, updated=None, scope=None, role=None, extension_elements=None, extension_attributes=None, text=None): gdata.GDataEntry.__init__(self, author=author, category=category, content=content, atom_id=atom_id, link=link, published=published, title=title, updated=updated, text=None) self.scope = scope self.role = role class CalendarAclFeed(gdata.GDataFeed, gdata.LinkFinder): """A Google Calendar ACL feed flavor of an Atom Feed""" _tag = gdata.GDataFeed._tag _namespace = gdata.GDataFeed._namespace _children = gdata.GDataFeed._children.copy() _attributes = gdata.GDataFeed._attributes.copy() _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [CalendarAclEntry]) class CalendarEventCommentEntry(gdata.GDataEntry, gdata.LinkFinder): """A Google Calendar event comments entry flavor of an Atom Entry""" _tag = gdata.GDataEntry._tag _namespace = gdata.GDataEntry._namespace _children = gdata.GDataEntry._children.copy() _attributes = gdata.GDataEntry._attributes.copy() class CalendarEventCommentFeed(gdata.GDataFeed, gdata.LinkFinder): """A Google Calendar event comments feed flavor of an Atom Feed""" _tag = gdata.GDataFeed._tag _namespace = gdata.GDataFeed._namespace _children = gdata.GDataFeed._children.copy() _attributes = gdata.GDataFeed._attributes.copy() _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [CalendarEventCommentEntry]) class ExtendedProperty(gdata.ExtendedProperty): """A transparent subclass of gdata.ExtendedProperty added to this module for backwards compatibility.""" class Reminder(atom.AtomBase): """The Google Calendar reminder element""" _tag = 'reminder' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['absoluteTime'] = 'absolute_time' _attributes['days'] = 'days' _attributes['hours'] = 'hours' _attributes['minutes'] = 'minutes' _attributes['method'] = 'method' def __init__(self, absolute_time=None, days=None, hours=None, minutes=None, method=None, extension_elements=None, extension_attributes=None, text=None): self.absolute_time = absolute_time if days is not None: self.days = str(days) else: self.days = None if hours is not None: self.hours = str(hours) else: self.hours = None if minutes is not None: self.minutes = str(minutes) else: self.minutes = None self.method = method self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class When(atom.AtomBase): """The Google Calendar When element""" _tag = 'when' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _children['{%s}reminder' % gdata.GDATA_NAMESPACE] = ('reminder', [Reminder]) _attributes['startTime'] = 'start_time' _attributes['endTime'] = 'end_time' def __init__(self, start_time=None, end_time=None, reminder=None, extension_elements=None, extension_attributes=None, text=None): self.start_time = start_time self.end_time = end_time self.reminder = reminder or [] self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class Recurrence(atom.AtomBase): """The Google Calendar Recurrence element""" _tag = 'recurrence' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() class UriEnumElement(atom.AtomBase): _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() def __init__(self, tag, enum_map, attrib_name='value', extension_elements=None, extension_attributes=None, text=None): self.tag=tag self.enum_map=enum_map self.attrib_name=attrib_name self.value=None self.text=text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} def findKey(self, value): res=[item[0] for item in self.enum_map.items() if item[1] == value] if res is None or len(res) == 0: return None return res[0] def _ConvertElementAttributeToMember(self, attribute, value): # Special logic to use the enum_map to set the value of the object's value member. if attribute == self.attrib_name and value != '': self.value = self.enum_map[value] return # Find the attribute in this class's list of attributes. if self.__class__._attributes.has_key(attribute): # Find the member of this class which corresponds to the XML attribute # (lookup in current_class._attributes) and set this member to the # desired value (using self.__dict__). setattr(self, self.__class__._attributes[attribute], value) else: # The current class doesn't map this attribute, so try to parent class. atom.ExtensionContainer._ConvertElementAttributeToMember(self, attribute, value) def _AddMembersToElementTree(self, tree): # Convert the members of this class which are XML child nodes. # This uses the class's _children dictionary to find the members which # should become XML child nodes. member_node_names = [values[0] for tag, values in self.__class__._children.iteritems()] for member_name in member_node_names: member = getattr(self, member_name) if member is None: pass elif isinstance(member, list): for instance in member: instance._BecomeChildElement(tree) else: member._BecomeChildElement(tree) # Special logic to set the desired XML attribute. key = self.findKey(self.value) if key is not None: tree.attrib[self.attrib_name]=key # Convert the members of this class which are XML attributes. for xml_attribute, member_name in self.__class__._attributes.iteritems(): member = getattr(self, member_name) if member is not None: tree.attrib[xml_attribute] = member # Lastly, call the parent's _AddMembersToElementTree to get any # extension elements. atom.ExtensionContainer._AddMembersToElementTree(self, tree) class AttendeeStatus(UriEnumElement): """The Google Calendar attendeeStatus element""" _tag = 'attendeeStatus' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() attendee_enum = { 'http://schemas.google.com/g/2005#event.accepted' : 'ACCEPTED', 'http://schemas.google.com/g/2005#event.declined' : 'DECLINED', 'http://schemas.google.com/g/2005#event.invited' : 'INVITED', 'http://schemas.google.com/g/2005#event.tentative' : 'TENTATIVE'} def __init__(self, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, 'attendeeStatus', AttendeeStatus.attendee_enum, extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) class AttendeeType(UriEnumElement): """The Google Calendar attendeeType element""" _tag = 'attendeeType' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() attendee_type_enum = { 'http://schemas.google.com/g/2005#event.optional' : 'OPTIONAL', 'http://schemas.google.com/g/2005#event.required' : 'REQUIRED' } def __init__(self, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, 'attendeeType', AttendeeType.attendee_type_enum, extension_elements=extension_elements, extension_attributes=extension_attributes,text=text) class Visibility(UriEnumElement): """The Google Calendar Visibility element""" _tag = 'visibility' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() visibility_enum = { 'http://schemas.google.com/g/2005#event.confidential' : 'CONFIDENTIAL', 'http://schemas.google.com/g/2005#event.default' : 'DEFAULT', 'http://schemas.google.com/g/2005#event.private' : 'PRIVATE', 'http://schemas.google.com/g/2005#event.public' : 'PUBLIC' } def __init__(self, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, 'visibility', Visibility.visibility_enum, extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) class Transparency(UriEnumElement): """The Google Calendar Transparency element""" _tag = 'transparency' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() transparency_enum = { 'http://schemas.google.com/g/2005#event.opaque' : 'OPAQUE', 'http://schemas.google.com/g/2005#event.transparent' : 'TRANSPARENT' } def __init__(self, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, tag='transparency', enum_map=Transparency.transparency_enum, extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) class Comments(atom.AtomBase): """The Google Calendar comments element""" _tag = 'comments' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _children['{%s}feedLink' % gdata.GDATA_NAMESPACE] = ('feed_link', gdata.FeedLink) _attributes['rel'] = 'rel' def __init__(self, rel=None, feed_link=None, extension_elements=None, extension_attributes=None, text=None): self.rel = rel self.feed_link = feed_link self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class EventStatus(UriEnumElement): """The Google Calendar eventStatus element""" _tag = 'eventStatus' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() status_enum = { 'http://schemas.google.com/g/2005#event.canceled' : 'CANCELED', 'http://schemas.google.com/g/2005#event.confirmed' : 'CONFIRMED', 'http://schemas.google.com/g/2005#event.tentative' : 'TENTATIVE'} def __init__(self, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, tag='eventStatus', enum_map=EventStatus.status_enum, extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) class Who(UriEnumElement): """The Google Calendar Who element""" _tag = 'who' _namespace = gdata.GDATA_NAMESPACE _children = UriEnumElement._children.copy() _attributes = UriEnumElement._attributes.copy() _children['{%s}attendeeStatus' % gdata.GDATA_NAMESPACE] = ( 'attendee_status', AttendeeStatus) _children['{%s}attendeeType' % gdata.GDATA_NAMESPACE] = ('attendee_type', AttendeeType) _attributes['valueString'] = 'name' _attributes['email'] = 'email' relEnum = { 'http://schemas.google.com/g/2005#event.attendee' : 'ATTENDEE', 'http://schemas.google.com/g/2005#event.organizer' : 'ORGANIZER', 'http://schemas.google.com/g/2005#event.performer' : 'PERFORMER', 'http://schemas.google.com/g/2005#event.speaker' : 'SPEAKER', 'http://schemas.google.com/g/2005#message.bcc' : 'BCC', 'http://schemas.google.com/g/2005#message.cc' : 'CC', 'http://schemas.google.com/g/2005#message.from' : 'FROM', 'http://schemas.google.com/g/2005#message.reply-to' : 'REPLY_TO', 'http://schemas.google.com/g/2005#message.to' : 'TO' } def __init__(self, name=None, email=None, attendee_status=None, attendee_type=None, rel=None, extension_elements=None, extension_attributes=None, text=None): UriEnumElement.__init__(self, 'who', Who.relEnum, attrib_name='rel', extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) self.name = name self.email = email self.attendee_status = attendee_status self.attendee_type = attendee_type self.rel = rel class OriginalEvent(atom.AtomBase): """The Google Calendar OriginalEvent element""" _tag = 'originalEvent' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() # TODO: The when tag used to map to a EntryLink, make sure it should really be a When. _children['{%s}when' % gdata.GDATA_NAMESPACE] = ('when', When) _attributes['id'] = 'id' _attributes['href'] = 'href' def __init__(self, id=None, href=None, when=None, extension_elements=None, extension_attributes=None, text=None): self.id = id self.href = href self.when = when self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} def GetCalendarEventEntryClass(): return CalendarEventEntry # This class is not completely defined here, because of a circular reference # in which CalendarEventEntryLink and CalendarEventEntry refer to one another. class CalendarEventEntryLink(gdata.EntryLink): """An entryLink which contains a calendar event entry Within an event's recurranceExceptions, an entry link points to a calendar event entry. This class exists to capture the calendar specific extensions in the entry. """ _tag = 'entryLink' _namespace = gdata.GDATA_NAMESPACE _children = gdata.EntryLink._children.copy() _attributes = gdata.EntryLink._attributes.copy() # The CalendarEventEntryLink should like CalendarEventEntry as a child but # that class hasn't been defined yet, so we will wait until after defining # CalendarEventEntry to list it in _children. class RecurrenceException(atom.AtomBase): """The Google Calendar RecurrenceException element""" _tag = 'recurrenceException' _namespace = gdata.GDATA_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _children['{%s}entryLink' % gdata.GDATA_NAMESPACE] = ('entry_link', CalendarEventEntryLink) _children['{%s}originalEvent' % gdata.GDATA_NAMESPACE] = ('original_event', OriginalEvent) _attributes['specialized'] = 'specialized' def __init__(self, specialized=None, entry_link=None, original_event=None, extension_elements=None, extension_attributes=None, text=None): self.specialized = specialized self.entry_link = entry_link self.original_event = original_event self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class SendEventNotifications(atom.AtomBase): """The Google Calendar sendEventNotifications element""" _tag = 'sendEventNotifications' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, extension_elements=None, value=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class QuickAdd(atom.AtomBase): """The Google Calendar quickadd element""" _tag = 'quickadd' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, extension_elements=None, value=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} def _TransferToElementTree(self, element_tree): if self.value: element_tree.attrib['value'] = self.value element_tree.tag = GCAL_TEMPLATE % 'quickadd' atom.AtomBase._TransferToElementTree(self, element_tree) return element_tree def _TakeAttributeFromElementTree(self, attribute, element_tree): if attribute == 'value': self.value = element_tree.attrib[attribute] del element_tree.attrib[attribute] else: atom.AtomBase._TakeAttributeFromElementTree(self, attribute, element_tree) class SyncEvent(atom.AtomBase): _tag = 'syncEvent' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value='false', extension_elements=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class UID(atom.AtomBase): _tag = 'uid' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value=None, extension_elements=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class Sequence(atom.AtomBase): _tag = 'sequence' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value=None, extension_elements=None, extension_attributes=None, text=None): self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class WebContentGadgetPref(atom.AtomBase): _tag = 'webContentGadgetPref' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _attributes['name'] = 'name' _attributes['value'] = 'value' """The Google Calendar Web Content Gadget Preferences element""" def __init__(self, name=None, value=None, extension_elements=None, extension_attributes=None, text=None): self.name = name self.value = value self.text = text self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class WebContent(atom.AtomBase): _tag = 'webContent' _namespace = GCAL_NAMESPACE _children = atom.AtomBase._children.copy() _attributes = atom.AtomBase._attributes.copy() _children['{%s}webContentGadgetPref' % GCAL_NAMESPACE] = ('gadget_pref', [WebContentGadgetPref]) _attributes['url'] = 'url' _attributes['width'] = 'width' _attributes['height'] = 'height' def __init__(self, url=None, width=None, height=None, text=None, gadget_pref=None, extension_elements=None, extension_attributes=None): self.url = url self.width = width self.height = height self.text = text self.gadget_pref = gadget_pref or [] self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} class WebContentLink(atom.Link): _tag = 'link' _namespace = atom.ATOM_NAMESPACE _children = atom.Link._children.copy() _attributes = atom.Link._attributes.copy() _children['{%s}webContent' % GCAL_NAMESPACE] = ('web_content', WebContent) def __init__(self, title=None, href=None, link_type=None, web_content=None): atom.Link.__init__(self, rel=WEB_CONTENT_LINK_REL, title=title, href=href, link_type=link_type) self.web_content = web_content class GuestsCanInviteOthers(atom.AtomBase): """Indicates whether event attendees may invite others to the event. This element may only be changed by the organizer of the event. If not included as part of the event entry, this element will default to true during a POST request, and will inherit its previous value during a PUT request. """ _tag = 'guestsCanInviteOthers' _namespace = GCAL_NAMESPACE _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value='true', *args, **kwargs): atom.AtomBase.__init__(self, *args, **kwargs) self.value = value class GuestsCanSeeGuests(atom.AtomBase): """Indicates whether attendees can see other people invited to the event. The organizer always sees all attendees. Guests always see themselves. This property affects what attendees see in the event's guest list via both the Calendar UI and API feeds. This element may only be changed by the organizer of the event. If not included as part of the event entry, this element will default to true during a POST request, and will inherit its previous value during a PUT request. """ _tag = 'guestsCanSeeGuests' _namespace = GCAL_NAMESPACE _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value='true', *args, **kwargs): atom.AtomBase.__init__(self, *args, **kwargs) self.value = value class GuestsCanModify(atom.AtomBase): """Indicates whether event attendees may modify the original event. If yes, changes are visible to organizer and other attendees. Otherwise, any changes made by attendees will be restricted to that attendee's calendar. This element may only be changed by the organizer of the event, and may be set to 'true' only if both gCal:guestsCanInviteOthers and gCal:guestsCanSeeGuests are set to true in the same PUT/POST request. Otherwise, request fails with HTTP error code 400 (Bad Request). If not included as part of the event entry, this element will default to false during a POST request, and will inherit its previous value during a PUT request.""" _tag = 'guestsCanModify' _namespace = GCAL_NAMESPACE _attributes = atom.AtomBase._attributes.copy() _attributes['value'] = 'value' def __init__(self, value='false', *args, **kwargs): atom.AtomBase.__init__(self, *args, **kwargs) self.value = value class CalendarEventEntry(gdata.BatchEntry): """A Google Calendar flavor of an Atom Entry """ _tag = gdata.BatchEntry._tag _namespace = gdata.BatchEntry._namespace _children = gdata.BatchEntry._children.copy() _attributes = gdata.BatchEntry._attributes.copy() # This class also contains WebContentLinks but converting those members # is handled in a special version of _ConvertElementTreeToMember. _children['{%s}where' % gdata.GDATA_NAMESPACE] = ('where', [Where]) _children['{%s}when' % gdata.GDATA_NAMESPACE] = ('when', [When]) _children['{%s}who' % gdata.GDATA_NAMESPACE] = ('who', [Who]) _children['{%s}extendedProperty' % gdata.GDATA_NAMESPACE] = ( 'extended_property', [ExtendedProperty]) _children['{%s}visibility' % gdata.GDATA_NAMESPACE] = ('visibility', Visibility) _children['{%s}transparency' % gdata.GDATA_NAMESPACE] = ('transparency', Transparency) _children['{%s}eventStatus' % gdata.GDATA_NAMESPACE] = ('event_status', EventStatus) _children['{%s}recurrence' % gdata.GDATA_NAMESPACE] = ('recurrence', Recurrence) _children['{%s}recurrenceException' % gdata.GDATA_NAMESPACE] = ( 'recurrence_exception', [RecurrenceException]) _children['{%s}sendEventNotifications' % GCAL_NAMESPACE] = ( 'send_event_notifications', SendEventNotifications) _children['{%s}quickadd' % GCAL_NAMESPACE] = ('quick_add', QuickAdd) _children['{%s}comments' % gdata.GDATA_NAMESPACE] = ('comments', Comments) _children['{%s}originalEvent' % gdata.GDATA_NAMESPACE] = ('original_event', OriginalEvent) _children['{%s}sequence' % GCAL_NAMESPACE] = ('sequence', Sequence) _children['{%s}reminder' % gdata.GDATA_NAMESPACE] = ('reminder', [Reminder]) _children['{%s}syncEvent' % GCAL_NAMESPACE] = ('sync_event', SyncEvent) _children['{%s}uid' % GCAL_NAMESPACE] = ('uid', UID) _children['{%s}guestsCanInviteOthers' % GCAL_NAMESPACE] = ( 'guests_can_invite_others', GuestsCanInviteOthers) _children['{%s}guestsCanModify' % GCAL_NAMESPACE] = ( 'guests_can_modify', GuestsCanModify) _children['{%s}guestsCanSeeGuests' % GCAL_NAMESPACE] = ( 'guests_can_see_guests', GuestsCanSeeGuests) def __init__(self, author=None, category=None, content=None, atom_id=None, link=None, published=None, title=None, updated=None, transparency=None, comments=None, event_status=None, send_event_notifications=None, visibility=None, recurrence=None, recurrence_exception=None, where=None, when=None, who=None, quick_add=None, extended_property=None, original_event=None, batch_operation=None, batch_id=None, batch_status=None, sequence=None, reminder=None, sync_event=None, uid=None, guests_can_invite_others=None, guests_can_modify=None, guests_can_see_guests=None, extension_elements=None, extension_attributes=None, text=None): gdata.BatchEntry.__init__(self, author=author, category=category, content=content, atom_id=atom_id, link=link, published=published, batch_operation=batch_operation, batch_id=batch_id, batch_status=batch_status, title=title, updated=updated) self.transparency = transparency self.comments = comments self.event_status = event_status self.send_event_notifications = send_event_notifications self.visibility = visibility self.recurrence = recurrence self.recurrence_exception = recurrence_exception or [] self.where = where or [] self.when = when or [] self.who = who or [] self.quick_add = quick_add self.extended_property = extended_property or [] self.original_event = original_event self.sequence = sequence self.reminder = reminder or [] self.sync_event = sync_event self.uid = uid self.text = text self.guests_can_invite_others = guests_can_invite_others self.guests_can_modify = guests_can_modify self.guests_can_see_guests = guests_can_see_guests self.extension_elements = extension_elements or [] self.extension_attributes = extension_attributes or {} # We needed to add special logic to _ConvertElementTreeToMember because we # want to make links with a rel of WEB_CONTENT_LINK_REL into a # WebContentLink def _ConvertElementTreeToMember(self, child_tree): # Special logic to handle Web Content links if (child_tree.tag == '{%s}link' % atom.ATOM_NAMESPACE and child_tree.attrib['rel'] == WEB_CONTENT_LINK_REL): if self.link is None: self.link = [] self.link.append(atom._CreateClassFromElementTree(WebContentLink, child_tree)) return # Find the element's tag in this class's list of child members if self.__class__._children.has_key(child_tree.tag): member_name = self.__class__._children[child_tree.tag][0] member_class = self.__class__._children[child_tree.tag][1] # If the class member is supposed to contain a list, make sure the # matching member is set to a list, then append the new member # instance to the list. if isinstance(member_class, list): if getattr(self, member_name) is None: setattr(self, member_name, []) getattr(self, member_name).append(atom._CreateClassFromElementTree( member_class[0], child_tree)) else: setattr(self, member_name, atom._CreateClassFromElementTree(member_class, child_tree)) else: atom.ExtensionContainer._ConvertElementTreeToMember(self, child_tree) def GetWebContentLink(self): """Finds the first link with rel set to WEB_CONTENT_REL Returns: A gdata.calendar.WebContentLink or none if none of the links had rel equal to WEB_CONTENT_REL """ for a_link in self.link: if a_link.rel == WEB_CONTENT_LINK_REL: return a_link return None def CalendarEventEntryFromString(xml_string): return atom.CreateClassFromXMLString(CalendarEventEntry, xml_string) def CalendarEventCommentEntryFromString(xml_string): return atom.CreateClassFromXMLString(CalendarEventCommentEntry, xml_string) CalendarEventEntryLink._children = {'{%s}entry' % atom.ATOM_NAMESPACE: ('entry', CalendarEventEntry)} def CalendarEventEntryLinkFromString(xml_string): return atom.CreateClassFromXMLString(CalendarEventEntryLink, xml_string) class CalendarEventFeed(gdata.BatchFeed, gdata.LinkFinder): """A Google Calendar event feed flavor of an Atom Feed""" _tag = gdata.BatchFeed._tag _namespace = gdata.BatchFeed._namespace _children = gdata.BatchFeed._children.copy() _attributes = gdata.BatchFeed._attributes.copy() _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [CalendarEventEntry]) _children['{%s}timezone' % GCAL_NAMESPACE] = ('timezone', Timezone) def __init__(self, author=None, category=None, contributor=None, generator=None, icon=None, atom_id=None, link=None, logo=None, rights=None, subtitle=None, title=None, updated=None, entry=None, total_results=None, start_index=None, items_per_page=None, interrupted=None, timezone=None, extension_elements=None, extension_attributes=None, text=None): gdata.BatchFeed.__init__(self, author=author, category=category, contributor=contributor, generator=generator, icon=icon, atom_id=atom_id, link=link, logo=logo, rights=rights, subtitle=subtitle, title=title, updated=updated, entry=entry, total_results=total_results, start_index=start_index, items_per_page=items_per_page, interrupted=interrupted, extension_elements=extension_elements, extension_attributes=extension_attributes, text=text) self.timezone = timezone def CalendarListEntryFromString(xml_string): return atom.CreateClassFromXMLString(CalendarListEntry, xml_string) def CalendarAclEntryFromString(xml_string): return atom.CreateClassFromXMLString(CalendarAclEntry, xml_string) def CalendarListFeedFromString(xml_string): return atom.CreateClassFromXMLString(CalendarListFeed, xml_string) def CalendarAclFeedFromString(xml_string): return atom.CreateClassFromXMLString(CalendarAclFeed, xml_string) def CalendarEventFeedFromString(xml_string): return atom.CreateClassFromXMLString(CalendarEventFeed, xml_string) def CalendarEventCommentFeedFromString(xml_string): return atom.CreateClassFromXMLString(CalendarEventCommentFeed, xml_string)