Changeset View
Changeset View
Standalone View
Standalone View
pykolab/xml/event.py
Show All 33 Lines | def event_from_message(message): | ||||
event = None | event = None | ||||
if message.is_multipart(): | if message.is_multipart(): | ||||
for part in message.walk(): | for part in message.walk(): | ||||
if part.get_content_type() == "application/calendar+xml": | if part.get_content_type() == "application/calendar+xml": | ||||
payload = part.get_payload(decode=True) | payload = part.get_payload(decode=True) | ||||
event = event_from_string(payload) | event = event_from_string(payload) | ||||
# append attachment parts to Event object | # append attachment parts to Event object | ||||
elif event and part.has_key('Content-ID'): | elif event and 'Content-ID' in part: | ||||
event._attachment_parts.append(part) | event._attachment_parts.append(part) | ||||
return event | return event | ||||
class Event(object): | class Event(object): | ||||
type = 'event' | type = 'event' | ||||
thisandfuture = False | thisandfuture = False | ||||
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines | def add_recurrence_date(self, _datetime): | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
# If no timezone information is passed on, make it UTC | # If no timezone information is passed on, make it UTC | ||||
if _datetime.tzinfo is None: | if _datetime.tzinfo is None: | ||||
_datetime = _datetime.replace(tzinfo=pytz.utc) | _datetime = _datetime.replace(tzinfo=pytz.utc) | ||||
valid_datetime = True | valid_datetime = True | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Rdate needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime)) | raise InvalidEventDateError(_("Rdate needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime))) | ||||
self.event.addRecurrenceDate(xmlutils.to_cdatetime(_datetime, True)) | self.event.addRecurrenceDate(xmlutils.to_cdatetime(_datetime, True)) | ||||
def add_exception_date(self, _datetime): | def add_exception_date(self, _datetime): | ||||
valid_datetime = False | valid_datetime = False | ||||
if isinstance(_datetime, datetime.date): | if isinstance(_datetime, datetime.date): | ||||
valid_datetime = True | valid_datetime = True | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
# If no timezone information is passed on, make it UTC | # If no timezone information is passed on, make it UTC | ||||
if _datetime.tzinfo == None: | if _datetime.tzinfo == None: | ||||
_datetime = _datetime.replace(tzinfo=pytz.utc) | _datetime = _datetime.replace(tzinfo=pytz.utc) | ||||
valid_datetime = True | valid_datetime = True | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Exdate needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime)) | raise InvalidEventDateError(_("Exdate needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime))) | ||||
self.event.addExceptionDate(xmlutils.to_cdatetime(_datetime, True)) | self.event.addExceptionDate(xmlutils.to_cdatetime(_datetime, True)) | ||||
def add_exception(self, exception): | def add_exception(self, exception): | ||||
recurrence_id = exception.get_recurrence_id() | recurrence_id = exception.get_recurrence_id() | ||||
if recurrence_id is None: | if recurrence_id is None: | ||||
raise EventIntegrityError, "Recurrence exceptions require a Recurrence-ID property" | raise EventIntegrityError("Recurrence exceptions require a Recurrence-ID property") | ||||
# check if an exception with the given recurrence-id already exists | # check if an exception with the given recurrence-id already exists | ||||
append = True | append = True | ||||
vexceptions = self.event.exceptions() | vexceptions = self.event.exceptions() | ||||
for i, ex in enumerate(self._exceptions): | for i, ex in enumerate(self._exceptions): | ||||
if ex.get_recurrence_id() == recurrence_id and ex.thisandfuture == exception.thisandfuture: | if ex.get_recurrence_id() == recurrence_id and ex.thisandfuture == exception.thisandfuture: | ||||
# update the existing exception | # update the existing exception | ||||
vexceptions[i] = exception.event | vexceptions[i] = exception.event | ||||
Show All 11 Lines | def add_exception(self, exception): | ||||
vexceptions.append(exception.event) | vexceptions.append(exception.event) | ||||
self._exceptions.append(exception) | self._exceptions.append(exception) | ||||
self.event.setExceptions(vexceptions) | self.event.setExceptions(vexceptions) | ||||
def del_exception(self, exception): | def del_exception(self, exception): | ||||
recurrence_id = exception.get_recurrence_id() | recurrence_id = exception.get_recurrence_id() | ||||
if recurrence_id is None: | if recurrence_id is None: | ||||
raise EventIntegrityError, "Recurrence exceptions require a Recurrence-ID property" | raise EventIntegrityError("Recurrence exceptions require a Recurrence-ID property") | ||||
updated = False | updated = False | ||||
vexceptions = self.event.exceptions() | vexceptions = self.event.exceptions() | ||||
for i, ex in enumerate(self._exceptions): | for i, ex in enumerate(self._exceptions): | ||||
if ex.get_recurrence_id() == recurrence_id and ex.thisandfuture == exception.thisandfuture: | if ex.get_recurrence_id() == recurrence_id and ex.thisandfuture == exception.thisandfuture: | ||||
del vexceptions[i] | del vexceptions[i] | ||||
del self._exceptions[i] | del self._exceptions[i] | ||||
updated = True | updated = True | ||||
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines | def from_ical(self, ical, raw=None): | ||||
# VCALENDAR block was given, find the first VEVENT item | # VCALENDAR block was given, find the first VEVENT item | ||||
if isinstance(ical_event, icalendar.Calendar): | if isinstance(ical_event, icalendar.Calendar): | ||||
for c in ical_event.walk(): | for c in ical_event.walk(): | ||||
if c.name == 'VEVENT': | if c.name == 'VEVENT': | ||||
ical_event = c | ical_event = c | ||||
break | break | ||||
# use the libkolab calendaring bindings to load the full iCal data | # use the libkolab calendaring bindings to load the full iCal data | ||||
if ical_event.has_key('RRULE') or ical_event.has_key('ATTACH') \ | if 'RRULE' in ical_event or 'ATTACH' in ical_event \ | ||||
or [part for part in ical_event.walk() if part.name == 'VALARM']: | or [part for part in ical_event.walk() if part.name == 'VALARM']: | ||||
if raw is None or raw == "": | if raw is None or raw == "": | ||||
raw = ical if isinstance(ical, str) else ical.to_ical() | raw = ical if isinstance(ical, str) else ical.to_ical() | ||||
self._xml_from_ical(raw) | self._xml_from_ical(raw) | ||||
else: | else: | ||||
self.event = kolabformat.Event() | self.event = kolabformat.Event() | ||||
# TODO: Clause the timestamps for zulu suffix causing datetime.datetime | # TODO: Clause the timestamps for zulu suffix causing datetime.datetime | ||||
# to fail substitution. | # to fail substitution. | ||||
for attr in list(set(ical_event.required)): | for attr in list(set(ical_event.required)): | ||||
if ical_event.has_key(attr): | if attr in ical_event: | ||||
self.set_from_ical(attr.lower(), ical_event[attr]) | self.set_from_ical(attr.lower(), ical_event[attr]) | ||||
# NOTE: Make sure to list(set()) or duplicates may arise | # NOTE: Make sure to list(set()) or duplicates may arise | ||||
# NOTE: Keep the original order e.g. to read DTSTART before RECURRENCE-ID | # NOTE: Keep the original order e.g. to read DTSTART before RECURRENCE-ID | ||||
for attr in list(OrderedDict.fromkeys(ical_event.singletons)): | for attr in list(OrderedDict.fromkeys(ical_event.singletons)): | ||||
if ical_event.has_key(attr): | if attr in ical_event: | ||||
if isinstance(ical_event[attr], list): | if isinstance(ical_event[attr], list): | ||||
ical_event[attr] = ical_event[attr][0]; | ical_event[attr] = ical_event[attr][0]; | ||||
self.set_from_ical(attr.lower(), ical_event[attr]) | self.set_from_ical(attr.lower(), ical_event[attr]) | ||||
# NOTE: Make sure to list(set()) or duplicates may arise | # NOTE: Make sure to list(set()) or duplicates may arise | ||||
for attr in list(set(ical_event.multiple)): | for attr in list(set(ical_event.multiple)): | ||||
if ical_event.has_key(attr): | if attr in ical_event: | ||||
self.set_from_ical(attr.lower(), ical_event[attr]) | self.set_from_ical(attr.lower(), ical_event[attr]) | ||||
def _xml_from_ical(self, ical): | def _xml_from_ical(self, ical): | ||||
if not "BEGIN:VCALENDAR" in ical: | if not "BEGIN:VCALENDAR" in ical: | ||||
ical = "BEGIN:VCALENDAR\nVERSION:2.0\n" + ical + "\nEND:VCALENDAR" | ical = "BEGIN:VCALENDAR\nVERSION:2.0\n" + ical + "\nEND:VCALENDAR" | ||||
from kolab.calendaring import EventCal | from kolab.calendaring import EventCal | ||||
self.event = EventCal() | self.event = EventCal() | ||||
success = self.event.fromICal(ical) | success = self.event.fromICal(ical) | ||||
if success: | if success: | ||||
self._load_exceptions() | self._load_exceptions() | ||||
return success | return success | ||||
def get_attendee_participant_status(self, attendee): | def get_attendee_participant_status(self, attendee): | ||||
return attendee.get_participant_status() | return attendee.get_participant_status() | ||||
def get_attendee(self, attendee): | def get_attendee(self, attendee): | ||||
if isinstance(attendee, basestring): | if isinstance(attendee, basestring): | ||||
if attendee in [x.get_email() for x in self.get_attendees()]: | if attendee in [x.get_email() for x in self.get_attendees()]: | ||||
attendee = self.get_attendee_by_email(attendee) | attendee = self.get_attendee_by_email(attendee) | ||||
elif attendee in [x.get_name() for x in self.get_attendees()]: | elif attendee in [x.get_name() for x in self.get_attendees()]: | ||||
attendee = self.get_attendee_by_name(attendee) | attendee = self.get_attendee_by_name(attendee) | ||||
else: | else: | ||||
raise ValueError, _("No attendee with email or name %r") %(attendee) | raise ValueError(_("No attendee with email or name %r") %(attendee)) | ||||
return attendee | return attendee | ||||
elif isinstance(attendee, Attendee): | elif isinstance(attendee, Attendee): | ||||
return attendee | return attendee | ||||
else: | else: | ||||
raise ValueError, _("Invalid argument value attendee %r, must be basestring or Attendee") % (attendee) | raise ValueError(_("Invalid argument value attendee %r, must be basestring or Attendee") % (attendee)) | ||||
def find_attendee(self, attendee): | def find_attendee(self, attendee): | ||||
try: | try: | ||||
return self.get_attendee(attendee) | return self.get_attendee(attendee) | ||||
except: | except: | ||||
return None | return None | ||||
def get_attendee_by_email(self, email): | def get_attendee_by_email(self, email): | ||||
if email in [x.get_email() for x in self.get_attendees()]: | if email in [x.get_email() for x in self.get_attendees()]: | ||||
return [x for x in self.get_attendees() if x.get_email() == email][0] | return [x for x in self.get_attendees() if x.get_email() == email][0] | ||||
raise ValueError, _("No attendee with email %r") %(email) | raise ValueError(_("No attendee with email %r") %(email)) | ||||
def get_attendee_by_name(self, name): | def get_attendee_by_name(self, name): | ||||
if name in [x.get_name() for x in self.get_attendees()]: | if name in [x.get_name() for x in self.get_attendees()]: | ||||
return [x for x in self.get_attendees() if x.get_name() == name][0] | return [x for x in self.get_attendees() if x.get_name() == name][0] | ||||
raise ValueError, _("No attendee with name %r") %(name) | raise ValueError(_("No attendee with name %r") %(name)) | ||||
def get_attendees(self): | def get_attendees(self): | ||||
return self._attendees | return self._attendees | ||||
def get_categories(self): | def get_categories(self): | ||||
return [str(c) for c in self.event.categories()] | return [str(c) for c in self.event.categories()] | ||||
def get_classification(self): | def get_classification(self): | ||||
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines | def get_ical_attendee(self): | ||||
name = attendee.get_name() | name = attendee.get_name() | ||||
rsvp = attendee.get_rsvp() | rsvp = attendee.get_rsvp() | ||||
role = attendee.get_role() | role = attendee.get_role() | ||||
partstat = attendee.get_participant_status() | partstat = attendee.get_participant_status() | ||||
cutype = attendee.get_cutype() | cutype = attendee.get_cutype() | ||||
delegators = attendee.get_delegated_from() | delegators = attendee.get_delegated_from() | ||||
delegatees = attendee.get_delegated_to() | delegatees = attendee.get_delegated_to() | ||||
if rsvp in attendee.rsvp_map.keys(): | if rsvp in attendee.rsvp_map: | ||||
_rsvp = rsvp | _rsvp = rsvp | ||||
elif rsvp in attendee.rsvp_map.values(): | elif rsvp in attendee.rsvp_map.values(): | ||||
_rsvp = [k for k, v in attendee.rsvp_map.iteritems() if v == rsvp][0] | _rsvp = [k for k, v in attendee.rsvp_map.items() if v == rsvp][0] | ||||
else: | else: | ||||
_rsvp = None | _rsvp = None | ||||
if role in attendee.role_map.keys(): | if role in attendee.role_map: | ||||
_role = role | _role = role | ||||
elif role in attendee.role_map.values(): | elif role in attendee.role_map.values(): | ||||
_role = [k for k, v in attendee.role_map.iteritems() if v == role][0] | _role = [k for k, v in attendee.role_map.items() if v == role][0] | ||||
else: | else: | ||||
_role = None | _role = None | ||||
if partstat in attendee.participant_status_map.keys(): | if partstat in attendee.participant_status_map: | ||||
_partstat = partstat | _partstat = partstat | ||||
elif partstat in attendee.participant_status_map.values(): | elif partstat in attendee.participant_status_map.values(): | ||||
_partstat = [k for k, v in attendee.participant_status_map.iteritems() if v == partstat][0] | _partstat = [k for k, v in attendee.participant_status_map.items() if v == partstat][0] | ||||
else: | else: | ||||
_partstat = None | _partstat = None | ||||
if cutype in attendee.cutype_map.keys(): | if cutype in attendee.cutype_map: | ||||
_cutype = cutype | _cutype = cutype | ||||
elif cutype in attendee.cutype_map.values(): | elif cutype in attendee.cutype_map.values(): | ||||
_cutype = [k for k, v in attendee.cutype_map.iteritems() if v == cutype][0] | _cutype = [k for k, v in attendee.cutype_map.items() if v == cutype][0] | ||||
else: | else: | ||||
_cutype = None | _cutype = None | ||||
_attendee = icalendar.vCalAddress("MAILTO:%s" % email) | _attendee = icalendar.vCalAddress("MAILTO:%s" % email) | ||||
if not name == None and not name == "": | if not name == None and not name == "": | ||||
_attendee.params['CN'] = icalendar.vText(name) | _attendee.params['CN'] = icalendar.vText(name) | ||||
if not _rsvp == None: | if not _rsvp == None: | ||||
Show All 16 Lines | def get_ical_attendee(self): | ||||
attendees.append(_attendee) | attendees.append(_attendee) | ||||
return attendees | return attendees | ||||
def get_ical_attendee_participant_status(self, attendee): | def get_ical_attendee_participant_status(self, attendee): | ||||
attendee = self.get_attendee(attendee) | attendee = self.get_attendee(attendee) | ||||
if attendee.get_participant_status() in attendee.participant_status_map.keys(): | if attendee.get_participant_status() in attendee.participant_status_map: | ||||
return attendee.get_participant_status() | return attendee.get_participant_status() | ||||
elif attendee.get_participant_status() in attendee.participant_status_map.values(): | elif attendee.get_participant_status() in attendee.participant_status_map.values(): | ||||
return [k for k, v in attendee.participant_status_map.iteritems() if v == attendee.get_participant_status()][0] | return [k for k, v in attendee.participant_status_map.items() if v == attendee.get_participant_status()][0] | ||||
else: | else: | ||||
raise ValueError, _("Invalid participant status") | raise ValueError(_("Invalid participant status")) | ||||
def get_ical_created(self): | def get_ical_created(self): | ||||
return self.get_created() | return self.get_created() | ||||
def get_ical_dtend(self): | def get_ical_dtend(self): | ||||
dtend = self.get_end() | dtend = self.get_end() | ||||
# shift end by one day on all-day events | # shift end by one day on all-day events | ||||
if not hasattr(dtend, 'hour'): | if not hasattr(dtend, 'hour'): | ||||
Show All 22 Lines | def get_ical_organizer(self): | ||||
if not name == None and not name == "": | if not name == None and not name == "": | ||||
organizer.params["CN"] = icalendar.vText(name) | organizer.params["CN"] = icalendar.vText(name) | ||||
return organizer | return organizer | ||||
def get_ical_status(self): | def get_ical_status(self): | ||||
status = self.event.status() | status = self.event.status() | ||||
if status in self.status_map.keys(): | if status in self.status_map: | ||||
return status | return status | ||||
return self._translate_value(status, self.status_map) if status else None | return self._translate_value(status, self.status_map) if status else None | ||||
def get_ical_class(self): | def get_ical_class(self): | ||||
class_ = self.event.classification() | class_ = self.event.classification() | ||||
return self._translate_value(class_, self.classification_map) if class_ else None | return self._translate_value(class_, self.classification_map) if class_ else None | ||||
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines | def merge_attendee_data(self, _attendees, append=True): | ||||
break | break | ||||
if not found and append: | if not found and append: | ||||
self._attendees.append(attendee) | self._attendees.append(attendee) | ||||
self.event.setAttendees(self._attendees) | self.event.setAttendees(self._attendees) | ||||
def set_classification(self, classification): | def set_classification(self, classification): | ||||
if classification in self.classification_map.keys(): | if classification in self.classification_map: | ||||
self.event.setClassification(self.classification_map[classification]) | self.event.setClassification(self.classification_map[classification]) | ||||
elif classification in self.classification_map.values(): | elif classification in self.classification_map.values(): | ||||
self.event.setClassification(classification) | self.event.setClassification(classification) | ||||
else: | else: | ||||
raise ValueError, _("Invalid classification %r") % (classification) | raise ValueError(_("Invalid classification %r") % (classification)) | ||||
def set_created(self, _datetime=None): | def set_created(self, _datetime=None): | ||||
if _datetime is None or isinstance(_datetime, datetime.time): | if _datetime is None or isinstance(_datetime, datetime.time): | ||||
_datetime = datetime.datetime.utcnow() | _datetime = datetime.datetime.utcnow() | ||||
self.event.setCreated(xmlutils.to_cdatetime(_datetime, False, True)) | self.event.setCreated(xmlutils.to_cdatetime(_datetime, False, True)) | ||||
def set_description(self, description): | def set_description(self, description): | ||||
Show All 14 Lines | def set_end(self, _datetime): | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
# If no timezone information is passed on, make it UTC | # If no timezone information is passed on, make it UTC | ||||
if _datetime.tzinfo == None: | if _datetime.tzinfo == None: | ||||
_datetime = _datetime.replace(tzinfo=pytz.utc) | _datetime = _datetime.replace(tzinfo=pytz.utc) | ||||
valid_datetime = True | valid_datetime = True | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Event end needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime)) | raise InvalidEventDateError(_("Event end needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime))) | ||||
self.event.setEnd(xmlutils.to_cdatetime(_datetime, True)) | self.event.setEnd(xmlutils.to_cdatetime(_datetime, True)) | ||||
def set_exception_dates(self, _datetimes): | def set_exception_dates(self, _datetimes): | ||||
for _datetime in _datetimes: | for _datetime in _datetimes: | ||||
self.add_exception_date(_datetime) | self.add_exception_date(_datetime) | ||||
def set_recurrence_dates(self, _datetimes): | def set_recurrence_dates(self, _datetimes): | ||||
for _datetime in _datetimes: | for _datetime in _datetimes: | ||||
self.add_recurrence_date(_datetime) | self.add_recurrence_date(_datetime) | ||||
def add_custom_property(self, name, value): | def add_custom_property(self, name, value): | ||||
if not name.upper().startswith('X-'): | if not name.upper().startswith('X-'): | ||||
raise ValueError, _("Invalid custom property name %r") % (name) | raise ValueError(_("Invalid custom property name %r") % (name)) | ||||
props = self.event.customProperties() | props = self.event.customProperties() | ||||
props.append(kolabformat.CustomProperty(name.upper(), value)) | props.append(kolabformat.CustomProperty(name.upper(), value)) | ||||
self.event.setCustomProperties(props) | self.event.setCustomProperties(props) | ||||
def set_from_ical(self, attr, value): | def set_from_ical(self, attr, value): | ||||
attr = attr.replace('-', '') | attr = attr.replace('-', '') | ||||
ical_setter = 'set_ical_' + attr | ical_setter = 'set_ical_' + attr | ||||
Show All 23 Lines | def set_ical_attendee(self, _attendee): | ||||
for attendee in _attendee: | for attendee in _attendee: | ||||
address = str(attendee).split(':')[-1] | address = str(attendee).split(':')[-1] | ||||
if hasattr(attendee, 'params'): | if hasattr(attendee, 'params'): | ||||
params = attendee.params | params = attendee.params | ||||
else: | else: | ||||
params = {} | params = {} | ||||
if params.has_key('CN'): | if 'CN' in params: | ||||
name = ustr(params['CN']) | name = ustr(params['CN']) | ||||
else: | else: | ||||
name = None | name = None | ||||
if params.has_key('ROLE'): | if 'ROLE' in params: | ||||
role = params['ROLE'] | role = params['ROLE'] | ||||
else: | else: | ||||
role = None | role = None | ||||
if params.has_key('PARTSTAT'): | if 'PARTSTAT' in params: | ||||
partstat = params['PARTSTAT'] | partstat = params['PARTSTAT'] | ||||
else: | else: | ||||
partstat = None | partstat = None | ||||
if params.has_key('RSVP'): | if 'RSVP' in params: | ||||
rsvp = params['RSVP'] | rsvp = params['RSVP'] | ||||
else: | else: | ||||
rsvp = None | rsvp = None | ||||
if params.has_key('CUTYPE'): | if 'CUTYPE' in params: | ||||
cutype = params['CUTYPE'] | cutype = params['CUTYPE'] | ||||
else: | else: | ||||
cutype = kolabformat.CutypeIndividual | cutype = kolabformat.CutypeIndividual | ||||
att = self.add_attendee(address, name=name, rsvp=rsvp, role=role, participant_status=partstat, cutype=cutype, params=params) | att = self.add_attendee(address, name=name, rsvp=rsvp, role=role, participant_status=partstat, cutype=cutype, params=params) | ||||
def set_ical_dtend(self, dtend): | def set_ical_dtend(self, dtend): | ||||
# shift end by one day on all-day events | # shift end by one day on all-day events | ||||
Show All 22 Lines | def set_ical_organizer(self, organizer): | ||||
cn = None | cn = None | ||||
if hasattr(organizer, 'params'): | if hasattr(organizer, 'params'): | ||||
params = organizer.params | params = organizer.params | ||||
else: | else: | ||||
params = {} | params = {} | ||||
if params.has_key('CN'): | if 'CN' in params: | ||||
cn = ustr(params['CN']) | cn = ustr(params['CN']) | ||||
self.set_organizer(str(address), name=cn) | self.set_organizer(str(address), name=cn) | ||||
def set_ical_priority(self, priority): | def set_ical_priority(self, priority): | ||||
self.set_priority(priority) | self.set_priority(priority) | ||||
def set_ical_sequence(self, sequence): | def set_ical_sequence(self, sequence): | ||||
Show All 21 Lines | def set_ical_rdate(self, rdate): | ||||
rdates.append(datetime) | rdates.append(datetime) | ||||
self.set_recurrence_dates(rdates) | self.set_recurrence_dates(rdates) | ||||
def set_ical_recurrenceid(self, value, params): | def set_ical_recurrenceid(self, value, params): | ||||
try: | try: | ||||
self.thisandfuture = params.get('RANGE', '') == 'THISANDFUTURE' | self.thisandfuture = params.get('RANGE', '') == 'THISANDFUTURE' | ||||
self.set_recurrence_id(value, self.thisandfuture) | self.set_recurrence_id(value, self.thisandfuture) | ||||
except InvalidEventDateError, e: | except InvalidEventDateError: | ||||
pass | pass | ||||
def set_lastmodified(self, _datetime=None): | def set_lastmodified(self, _datetime=None): | ||||
valid_datetime = False | valid_datetime = False | ||||
if isinstance(_datetime, datetime.date): | if isinstance(_datetime, datetime.date): | ||||
valid_datetime = True | valid_datetime = True | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
valid_datetime = True | valid_datetime = True | ||||
if _datetime is None or isinstance(_datetime, datetime.time): | if _datetime is None or isinstance(_datetime, datetime.time): | ||||
valid_datetime = True | valid_datetime = True | ||||
_datetime = datetime.datetime.utcnow() | _datetime = datetime.datetime.utcnow() | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Event last-modified needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime)) | raise InvalidEventDateError(_("Event last-modified needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime))) | ||||
self.event.setLastModified(xmlutils.to_cdatetime(_datetime, False, True)) | self.event.setLastModified(xmlutils.to_cdatetime(_datetime, False, True)) | ||||
def set_location(self, location): | def set_location(self, location): | ||||
self.event.setLocation(ustr(location)) | self.event.setLocation(ustr(location)) | ||||
def set_organizer(self, email, name=None): | def set_organizer(self, email, name=None): | ||||
contactreference = ContactReference(email) | contactreference = ContactReference(email) | ||||
Show All 26 Lines | def set_start(self, _datetime): | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
# If no timezone information is passed on, make it UTC | # If no timezone information is passed on, make it UTC | ||||
if _datetime.tzinfo == None: | if _datetime.tzinfo == None: | ||||
_datetime = _datetime.replace(tzinfo=pytz.utc) | _datetime = _datetime.replace(tzinfo=pytz.utc) | ||||
valid_datetime = True | valid_datetime = True | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Event start needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime)) | raise InvalidEventDateError(_("Event start needs datetime.date or datetime.datetime instance, got %r") % (type(_datetime))) | ||||
self.event.setStart(xmlutils.to_cdatetime(_datetime, True)) | self.event.setStart(xmlutils.to_cdatetime(_datetime, True)) | ||||
def set_status(self, status): | def set_status(self, status): | ||||
if status in self.status_map.keys(): | if status in self.status_map: | ||||
self.event.setStatus(self.status_map[status]) | self.event.setStatus(self.status_map[status]) | ||||
elif status in self.status_map.values(): | elif status in self.status_map.values(): | ||||
self.event.setStatus(status) | self.event.setStatus(status) | ||||
elif not status == kolabformat.StatusUndefined: | elif not status == kolabformat.StatusUndefined: | ||||
raise InvalidEventStatusError, _("Invalid status set: %r") % (status) | raise InvalidEventStatusError(_("Invalid status set: %r") % (status)) | ||||
def set_summary(self, summary): | def set_summary(self, summary): | ||||
self.event.setSummary(summary) | self.event.setSummary(summary) | ||||
def set_uid(self, uid): | def set_uid(self, uid): | ||||
self.uid = uid | self.uid = uid | ||||
self.event.setUid(str(uid)) | self.event.setUid(str(uid)) | ||||
def set_recurrence_id(self, _datetime, _thisandfuture=None): | def set_recurrence_id(self, _datetime, _thisandfuture=None): | ||||
valid_datetime = False | valid_datetime = False | ||||
if isinstance(_datetime, datetime.date): | if isinstance(_datetime, datetime.date): | ||||
valid_datetime = True | valid_datetime = True | ||||
if isinstance(_datetime, datetime.datetime): | if isinstance(_datetime, datetime.datetime): | ||||
# If no timezone information is passed on, use the one from event start | # If no timezone information is passed on, use the one from event start | ||||
if _datetime.tzinfo == None: | if _datetime.tzinfo == None: | ||||
_start = self.get_start() | _start = self.get_start() | ||||
_datetime = _datetime.replace(tzinfo=_start.tzinfo) | _datetime = _datetime.replace(tzinfo=_start.tzinfo) | ||||
valid_datetime = True | valid_datetime = True | ||||
if not valid_datetime: | if not valid_datetime: | ||||
raise InvalidEventDateError, _("Event recurrence-id needs datetime.datetime instance") | raise InvalidEventDateError(_("Event recurrence-id needs datetime.datetime instance")) | ||||
if _thisandfuture is None: | if _thisandfuture is None: | ||||
_thisandfuture = self.thisandfuture | _thisandfuture = self.thisandfuture | ||||
self.event.setRecurrenceID(xmlutils.to_cdatetime(_datetime), _thisandfuture) | self.event.setRecurrenceID(xmlutils.to_cdatetime(_datetime), _thisandfuture) | ||||
def set_transparency(self, transp): | def set_transparency(self, transp): | ||||
return self.event.setTransparency(transp) | return self.event.setTransparency(transp) | ||||
def __str__(self): | def __str__(self): | ||||
event_xml = kolabformat.writeEvent(self.event) | event_xml = kolabformat.writeEvent(self.event) | ||||
error = kolabformat.error() | error = kolabformat.error() | ||||
if error == None or not error: | if error == None or not error: | ||||
return event_xml | return event_xml | ||||
else: | else: | ||||
raise EventIntegrityError, kolabformat.errorMessage() | raise EventIntegrityError(kolabformat.errorMessage()) | ||||
def to_dict(self): | def to_dict(self): | ||||
data = dict() | data = dict() | ||||
for p, getter in self.properties_map.iteritems(): | for p, getter in self.properties_map.items(): | ||||
val = None | val = None | ||||
if hasattr(self, getter): | if hasattr(self, getter): | ||||
val = getattr(self, getter)() | val = getattr(self, getter)() | ||||
elif hasattr(self.event, getter): | elif hasattr(self.event, getter): | ||||
val = getattr(self.event, getter)() | val = getattr(self.event, getter)() | ||||
if isinstance(val, kolabformat.cDateTime): | if isinstance(val, kolabformat.cDateTime): | ||||
val = xmlutils.from_cdatetime(val, True) | val = xmlutils.from_cdatetime(val, True) | ||||
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines | def _alarm_to_dict(self, alarm): | ||||
ret['trigger']['value'] = re.sub(r"T$", '', re.sub(r"0[WDHMS]", '', value)) | ret['trigger']['value'] = re.sub(r"T$", '', re.sub(r"0[WDHMS]", '', value)) | ||||
if alarm.type() == kolabformat.Alarm.EMailAlarm: | if alarm.type() == kolabformat.Alarm.EMailAlarm: | ||||
ret['attendee'] = [ContactReference(a).to_dict() for a in alarm.attendees()] | ret['attendee'] = [ContactReference(a).to_dict() for a in alarm.attendees()] | ||||
return ret | return ret | ||||
def _translate_value(self, val, map): | def _translate_value(self, val, map): | ||||
name_map = dict([(v, k) for (k, v) in map.iteritems()]) | name_map = dict([(v, k) for (k, v) in map.items()]) | ||||
return name_map[val] if name_map.has_key(val) else 'UNKNOWN' | return name_map[val] if val in name_map else 'UNKNOWN' | ||||
def to_message(self, creator=None): | def to_message(self, creator=None): | ||||
from email.MIMEMultipart import MIMEMultipart | from email.MIMEMultipart import MIMEMultipart | ||||
from email.MIMEBase import MIMEBase | from email.MIMEBase import MIMEBase | ||||
from email.MIMEText import MIMEText | from email.MIMEText import MIMEText | ||||
from email.Utils import COMMASPACE, formatdate | from email.Utils import COMMASPACE, formatdate | ||||
msg = MIMEMultipart() | msg = MIMEMultipart() | ||||
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines |