| #!/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) |
