#!/usr/bin/env python  """ A Web interface to a user's calendar.  Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  # Edit this path to refer to the location of the imiptools libraries, if # necessary.  LIBRARY_PATH = "/var/lib/imip-agent"  from datetime import date, datetime, timedelta import babel.dates import cgi, os, sys  sys.path.append(LIBRARY_PATH)  from imiptools.content import Handler from imiptools.data import get_address, get_uri, make_freebusy, Object, to_part, \                            uri_dict, uri_item, uri_items, uri_values from imiptools.dates import format_datetime, format_time, get_date, get_datetime, \                             get_datetime_item, get_default_timezone, \                             get_end_of_day, get_start_of_day, get_start_of_next_day, \                             get_timestamp, ends_on_same_day, to_timezone from imiptools.mail import Messenger from imiptools.period import add_day_start_points, add_empty_days, add_slots, \                              convert_periods, get_freebusy_details, \                              get_scale, have_conflict, get_slots, get_spans, \                              partition_by_day, remove_from_freebusy, update_freebusy, \                              _update_freebusy from imiptools.profile import Preferences import imip_store import markup  getenv = os.environ.get setenv = os.environ.__setitem__  class CGIEnvironment:      "A CGI-compatible environment."      def __init__(self, charset=None):         self.charset = charset         self.args = None         self.method = None         self.path = None         self.path_info = None         self.user = None      def get_args(self):         if self.args is None:             if self.get_method() != "POST":                 setenv("QUERY_STRING", "")             args = cgi.parse(keep_blank_values=True)              if not self.charset:                 self.args = args             else:                 self.args = {}                 for key, values in args.items():                     self.args[key] = [unicode(value, self.charset) for value in values]          return self.args      def get_method(self):         if self.method is None:             self.method = getenv("REQUEST_METHOD") or "GET"         return self.method      def get_path(self):         if self.path is None:             self.path = getenv("SCRIPT_NAME") or ""         return self.path      def get_path_info(self):         if self.path_info is None:             self.path_info = getenv("PATH_INFO") or ""         return self.path_info      def get_user(self):         if self.user is None:             self.user = getenv("REMOTE_USER") or ""         return self.user      def get_output(self):         return sys.stdout      def get_url(self):         path = self.get_path()         path_info = self.get_path_info()         return "%s%s" % (path.rstrip("/"), path_info)      def new_url(self, path_info):         path = self.get_path()         return "%s/%s" % (path.rstrip("/"), path_info.lstrip("/"))  class Common:      "Common handler and manager methods."      def __init__(self, user):         self.user = user         self.preferences = None      def get_preferences(self):         if not self.preferences:             self.preferences = Preferences(self.user)         return self.preferences      def get_tzid(self):         prefs = self.get_preferences()         return prefs.get("TZID") or get_default_timezone()  class ManagerHandler(Handler, Common):      """     A content handler for use by the manager, as opposed to operating within the     mail processing pipeline.     """      def __init__(self, obj, user, messenger):         Handler.__init__(self, messenger=messenger)         Common.__init__(self, user)          self.set_object(obj)      # Communication methods.      def send_message(self, method, sender, for_organiser):          """         Create a full calendar object employing the given 'method', and send it         to the appropriate recipients, also sending a copy to the 'sender'. The         'for_organiser' value indicates whether the organiser is sending this         message.         """          parts = [self.obj.to_part(method)]          # As organiser, send an invitation to attendees, excluding oneself if         # also attending. The updated event will be saved by the outgoing         # handler.          organiser = get_uri(self.obj.get_value("ORGANIZER"))         attendees = uri_values(self.obj.get_values("ATTENDEE"))          if for_organiser:             recipients = [get_address(attendee) for attendee in attendees if attendee != self.user]         else:             recipients = [get_address(organiser)]          # Bundle free/busy information if appropriate.          preferences = Preferences(self.user)          if preferences.get("freebusy_sharing") == "share" and \            preferences.get("freebusy_bundling") == "always":              # Invent a unique identifier.              utcnow = get_timestamp()             uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))              freebusy = self.store.get_freebusy(self.user)              # Replace the non-updated free/busy details for this event with             # newer details (since the outgoing handler updates this user's             # free/busy details).              tzid = self.get_tzid()              _update_freebusy(freebusy, self.obj.get_periods_for_freebusy(tzid),                 self.obj.get_value("TRANSP") or "OPAQUE", self.obj.get_value("UID"))              user_attr = self.messenger and self.messenger.sender != get_address(self.user) and \                 {"SENT-BY" : get_uri(self.messenger.sender)} or {}              parts.append(to_part("PUBLISH", [                 make_freebusy(freebusy, uid, self.user, user_attr)                 ]))          message = self.messenger.make_outgoing_message(parts, recipients, outgoing_bcc=sender)         self.messenger.sendmail(recipients, message.as_string(), outgoing_bcc=sender)      # Action methods.      def process_received_request(self, update=False):          """         Process the current request for the given 'user'. Return whether any         action was taken.          If 'update' is given, the sequence number will be incremented in order         to override any previous response.         """          # Reply only on behalf of this user.          for attendee, attendee_attr in uri_items(self.obj.get_items("ATTENDEE")):              if attendee == self.user:                 if attendee_attr.has_key("RSVP"):                     del attendee_attr["RSVP"]                 if self.messenger and self.messenger.sender != get_address(attendee):                     attendee_attr["SENT-BY"] = get_uri(self.messenger.sender)                 self.obj["ATTENDEE"] = [(attendee, attendee_attr)]                  self.update_dtstamp()                 self.set_sequence(update)                  self.send_message("REPLY", get_address(attendee), for_organiser=False)                  return True          return False      def process_created_request(self, method, update=False, removed=None, added=None):          """         Process the current request for the given 'user', sending a created         request of the given 'method' to attendees. Return whether any action         was taken.          If 'update' is given, the sequence number will be incremented in order         to override any previous message.          If 'removed' is specified, a list of participants to be removed is         provided.          If 'added' is specified, a list of participants to be added is provided.         """          organiser, organiser_attr = uri_item(self.obj.get_item("ORGANIZER"))          if self.messenger and self.messenger.sender != get_address(organiser):             organiser_attr["SENT-BY"] = get_uri(self.messenger.sender)          to_cancel = []          if added or removed:             attendees = uri_items(self.obj.get_items("ATTENDEE") or [])              if removed:                 remaining = []                  for attendee, attendee_attr in attendees:                     if attendee in removed:                         to_cancel.append((attendee, attendee_attr))                     else:                         remaining.append((attendee, attendee_attr))                  attendees = remaining              if added:                 for attendee in added:                     attendees.append((attendee, {"PARTSTAT" : "NEEDS-ACTION", "RSVP" : "TRUE"}))              self.obj["ATTENDEE"] = attendees          self.update_dtstamp()         self.set_sequence(update)          self.send_message(method, get_address(organiser), for_organiser=True)          # When cancelling, replace the attendees with those for whom the event         # is now cancelled.          if to_cancel:             self.obj["ATTENDEE"] = to_cancel             self.send_message("CANCEL", get_address(organiser), for_organiser=True)              # Just in case more work is done with this event, the attendees are             # now restored.              self.obj["ATTENDEE"] = remaining          return True  class Manager(Common):      "A simple manager application."      def __init__(self, messenger=None):         self.messenger = messenger or Messenger()         self.encoding = "utf-8"         self.env = CGIEnvironment(self.encoding)          user = self.env.get_user()         Common.__init__(self, user and get_uri(user) or None)          self.locale = None         self.requests = None          self.out = self.env.get_output()         self.page = markup.page()          self.store = imip_store.FileStore()         self.objects = {}          try:             self.publisher = imip_store.FilePublisher()         except OSError:             self.publisher = None      def _get_uid(self, path_info):         return path_info.lstrip("/").split("/", 1)[0]      def _get_object(self, uid):         if self.objects.has_key(uid):             return self.objects[uid]          fragment = uid and self.store.get_event(self.user, uid) or None         obj = self.objects[uid] = fragment and Object(fragment)         return obj      def _get_requests(self):         if self.requests is None:             cancellations = self.store.get_cancellations(self.user)             requests = set(self.store.get_requests(self.user))             self.requests = requests.difference(cancellations)         return self.requests      def _get_request_summary(self):         summary = []         for uid in self._get_requests():             obj = self._get_object(uid)             if obj:                 for start, end in obj.get_periods_for_freebusy(self.get_tzid()):                     summary.append((start, end, uid))         return summary      # Preference methods.      def get_user_locale(self):         if not self.locale:             self.locale = self.get_preferences().get("LANG", "C")         return self.locale      # Prettyprinting of dates and times.      def format_date(self, dt, format):         return self._format_datetime(babel.dates.format_date, dt, format)      def format_time(self, dt, format):         return self._format_datetime(babel.dates.format_time, dt, format)      def format_datetime(self, dt, format):         return self._format_datetime(             isinstance(dt, datetime) and babel.dates.format_datetime or babel.dates.format_date,             dt, format)      def _format_datetime(self, fn, dt, format):         return fn(dt, format=format, locale=self.get_user_locale())      # Data management methods.      def remove_request(self, uid):         return self.store.dequeue_request(self.user, uid)      def remove_event(self, uid):         return self.store.remove_event(self.user, uid)      def update_freebusy(self, uid, obj):         tzid = self.get_tzid()         freebusy = self.store.get_freebusy(self.user)         update_freebusy(freebusy, self.user, obj.get_periods_for_freebusy(tzid),             obj.get_value("TRANSP"), uid, self.store)      def remove_from_freebusy(self, uid):         freebusy = self.store.get_freebusy(self.user)         remove_from_freebusy(freebusy, self.user, uid, self.store)      # Presentation methods.      def new_page(self, title):         self.page.init(title=title, charset=self.encoding, css=self.env.new_url("styles.css"))      def status(self, code, message):         self.header("Status", "%s %s" % (code, message))      def header(self, header, value):         print >>self.out, "%s: %s" % (header, value)      def no_user(self):         self.status(403, "Forbidden")         self.new_page(title="Forbidden")         self.page.p("You are not logged in and thus cannot access scheduling requests.")      def no_page(self):         self.status(404, "Not Found")         self.new_page(title="Not Found")         self.page.p("No page is provided at the given address.")      def redirect(self, url):         self.status(302, "Redirect")         self.header("Location", url)         self.new_page(title="Redirect")         self.page.p("Redirecting to: %s" % url)      # Request logic methods.      def handle_newevent(self):          """         Handle any new event operation, creating a new event and redirecting to         the event page for further activity.         """          # Handle a submitted form.          args = self.env.get_args()          if not args.has_key("newevent"):             return          # Create a new event using the available information.          slots = args.get("slot", [])         participants = args.get("participants", [])          if not slots:             return          # Obtain the user's timezone.          tzid = self.get_tzid()          # Coalesce the selected slots.          slots.sort()         coalesced = []         last = None          for slot in slots:             start, end = slot.split("-")             start = get_datetime(start, {"TZID" : tzid})             end = end and get_datetime(end, {"TZID" : tzid}) or get_start_of_next_day(start, tzid)              if last:                 last_start, last_end = last                  # Merge adjacent dates and datetimes.                  if start == last_end or get_start_of_day(last_end, tzid) == get_start_of_day(start, tzid):                     last = last_start, end                     continue                  # Handle datetimes within dates.                 # Datetime periods are within single days and are therefore                 # discarded.                  elif get_start_of_day(start, tzid) == get_start_of_day(last_start, tzid):                     continue                  # Add separate dates and datetimes.                  else:                     coalesced.append(last)              last = start, end          if last:             coalesced.append(last)          # Invent a unique identifier.          utcnow = get_timestamp()         uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))          # Define a single occurrence if only one coalesced slot exists.         # Otherwise, many occurrences are defined.          for i, (start, end) in enumerate(coalesced):             this_uid = "%s-%s" % (uid, i)              start_value, start_attr = get_datetime_item(start, tzid)             end_value, end_attr = get_datetime_item(end, tzid)              # Create a calendar object and store it as a request.              record = []             rwrite = record.append              rwrite(("UID", {}, this_uid))             rwrite(("SUMMARY", {}, "New event at %s" % utcnow))             rwrite(("DTSTAMP", {}, utcnow))             rwrite(("DTSTART", start_attr, start_value))             rwrite(("DTEND", end_attr, end_value))             rwrite(("ORGANIZER", {}, self.user))              for participant in participants:                 if not participant:                     continue                 participant = get_uri(participant)                 rwrite(("ATTENDEE", {"RSVP" : "TRUE", "PARTSTAT" : "NEEDS-ACTION"}, participant))              obj = ("VEVENT", {}, record)              self.store.set_event(self.user, this_uid, obj)             self.store.queue_request(self.user, this_uid)          # Redirect to the object (or the first of the objects), where instead of         # attendee controls, there will be organiser controls.          self.redirect(self.env.new_url("%s-0" % uid))      def handle_request(self, uid, obj):          """         Handle actions involving the given 'uid' and 'obj' object, returning an         error if one occurred, or None if the request was successfully handled.         """          # Handle a submitted form.          args = self.env.get_args()          # Get the possible actions.          reply = args.has_key("reply")         discard = args.has_key("discard")         invite = args.has_key("invite")         cancel = args.has_key("cancel")         save = args.has_key("save")          have_action = reply or discard or invite or cancel or save          if not have_action:             return ["action"]          # Update the object.          if args.has_key("summary"):             obj["SUMMARY"] = [(args["summary"][0], {})]          organisers = uri_dict(obj.get_value_map("ORGANIZER"))         attendees = uri_dict(obj.get_value_map("ATTENDEE"))          if args.has_key("partstat"):             for d in attendees, organisers:                 if d.has_key(self.user):                     d[self.user]["PARTSTAT"] = args["partstat"][0]                     if d[self.user].has_key("RSVP"):                         del d[self.user]["RSVP"]          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          # Obtain the user's timezone and process datetime values.          update = False          if is_organiser:             dtend_enabled = args.get("dtend-control", [None])[0] == "enable"             dttimes_enabled = args.get("dttimes-control", [None])[0] == "enable"              t = self.handle_date_controls("dtstart", dttimes_enabled)             if t:                 dtstart, attr = t                 update = self.set_datetime_in_object(dtstart, attr.get("TZID"), "DTSTART", obj) or update             else:                 return ["dtstart"]              # Handle specified end datetimes.              if dtend_enabled:                 t = self.handle_date_controls("dtend", dttimes_enabled)                 if t:                     dtend, attr = t                      # Convert end dates to iCalendar "next day" dates.                      if not isinstance(dtend, datetime):                         dtend += timedelta(1)                     update = self.set_datetime_in_object(dtend, attr.get("TZID"), "DTEND", obj) or update                 else:                     return ["dtend"]              # Otherwise, treat the end date as the start date. Datetimes are             # handled by making the event occupy the rest of the day.              else:                 dtend = dtstart + timedelta(1)                 if isinstance(dtstart, datetime):                     dtend = get_start_of_day(dtend, attr["TZID"])                 update = self.set_datetime_in_object(dtend, attr.get("TZID"), "DTEND", obj) or update              if dtstart >= dtend:                 return ["dtstart", "dtend"]          # Obtain any participants to be added or removed.          removed = args.get("remove")         added = args.get("added")          # Process any action.          handled = True          if reply or invite or cancel:              handler = ManagerHandler(obj, self.user, self.messenger)              # Process the object and remove it from the list of requests.              if reply and handler.process_received_request(update) or \                is_organiser and (invite or cancel) and \                handler.process_created_request(invite and "REQUEST" or "CANCEL", update, removed, added):                  self.remove_request(uid)          # Save single user events.          elif save:             self.store.set_event(self.user, uid, obj.to_node())             self.update_freebusy(uid, obj)             self.remove_request(uid)          # Remove the request and the object.          elif discard:             self.remove_from_freebusy(uid)             self.remove_event(uid)             self.remove_request(uid)          else:             handled = False          # Upon handling an action, redirect to the main page.          if handled:             self.redirect(self.env.get_path())          return None      def handle_date_controls(self, name, with_time=True):          """         Handle date control information for fields starting with 'name',         returning a (datetime, attr) tuple or None if the fields cannot be used         to construct a datetime object.         """          args = self.env.get_args()          if args.has_key("%s-date" % name):             date = args["%s-date" % name][0]              if with_time:                 hour = args.get("%s-hour" % name, [None])[0]                 minute = args.get("%s-minute" % name, [None])[0]                 second = args.get("%s-second" % name, [None])[0]                 tzid = args.get("%s-tzid" % name, [self.get_tzid()])[0]                  time = (hour or minute or second) and "T%s%s%s" % (hour, minute, second) or ""                 value = "%s%s" % (date, time)                 attr = {"TZID" : tzid, "VALUE" : "DATE-TIME"}                 dt = get_datetime(value, attr)             else:                 attr = {"VALUE" : "DATE"}                 dt = get_datetime(date)              if dt:                 return dt, attr          return None      def set_datetime_in_object(self, dt, tzid, property, obj):          """         Set 'dt' and 'tzid' for the given 'property' in 'obj', returning whether         an update has occurred.         """          if dt:             old_value = obj.get_value(property)             obj[property] = [get_datetime_item(dt, tzid)]             return format_datetime(dt) != old_value          return False      # Page fragment methods.      def show_request_controls(self, obj):          "Show form controls for a request concerning 'obj'."          page = self.page         args = self.env.get_args()          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          attendees = uri_values((obj.get_values("ATTENDEE") or []) + args.get("attendee", []))         is_attendee = self.user in attendees          is_request = obj.get_value("UID") in self._get_requests()          have_other_attendees = len(attendees) > (is_attendee and 1 or 0)          # Show appropriate options depending on the role of the user.          if is_attendee and not is_organiser:             page.p("An action is required for this request:")              page.p()             page.input(name="reply", type="submit", value="Reply")             page.add(" ")             page.input(name="discard", type="submit", value="Discard")             page.p.close()          if is_organiser:             if have_other_attendees:                 page.p("As organiser, you can perform the following:")                  page.p()                 page.input(name="invite", type="submit", value="Invite")                 page.add(" ")                 if is_request:                     page.input(name="discard", type="submit", value="Discard")                 else:                     page.input(name="cancel", type="submit", value="Cancel")                 page.p.close()             else:                 page.p("As attendee, you can perform the following:")                  page.p()                 page.input(name="save", type="submit", value="Save")                 page.add(" ")                 page.input(name="discard", type="submit", value="Discard")                 page.p.close()      property_items = [         ("SUMMARY", "Summary"),         ("DTSTART", "Start"),         ("DTEND", "End"),         ("ORGANIZER", "Organiser"),         ("ATTENDEE", "Attendee"),         ]      partstat_items = [         ("NEEDS-ACTION", "Not confirmed"),         ("ACCEPTED", "Attending"),         ("TENTATIVE", "Tentatively attending"),         ("DECLINED", "Not attending"),         ("DELEGATED", "Delegated"),         ]      def show_object_on_page(self, uid, obj, error=None):          """         Show the calendar object with the given 'uid' and representation 'obj'         on the current page. If 'error' is given, show a suitable message.         """          page = self.page         page.form(method="POST")          # Obtain the user's timezone.          tzid = self.get_tzid()          # Provide controls to change the displayed object.          args = self.env.get_args()          # Add or remove new attendees.         # This does not affect the stored object.          existing_attendees = uri_values(obj.get_values("ATTENDEE") or [])         new_attendees = args.get("added", [])         new_attendee = args.get("attendee", [""])[0]          if args.has_key("add"):             if new_attendee.strip():                 new_attendee = get_uri(new_attendee.strip())                 if new_attendee not in new_attendees and new_attendee not in existing_attendees:                     new_attendees.append(new_attendee)                 new_attendee = ""          if args.has_key("removenew"):             removed_attendee = args["removenew"][0]             if removed_attendee in new_attendees:                 new_attendees.remove(removed_attendee)          # Configure the start and end datetimes.          dtend_control = args.get("dtend-control", [None])[0]         dttimes_control = args.get("dttimes-control", [None])[0]         with_time = dttimes_control == "enable"          t = self.handle_date_controls("dtstart", with_time)         if t:             dtstart, dtstart_attr = t         else:             dtstart, dtstart_attr = obj.get_datetime_item("DTSTART")          if dtend_control == "enable":             t = self.handle_date_controls("dtend", with_time)             if t:                 dtend, dtend_attr = t             else:                 dtend, dtend_attr = None, {}         elif dtend_control == "disable":             dtend, dtend_attr = None, {}         else:             dtend, dtend_attr = obj.get_datetime_item("DTEND")          # Change end dates to refer to the actual dates, not the iCalendar         # "next day" dates.          if dtend and not isinstance(dtend, datetime):             dtend -= timedelta(1)          # Show the end datetime controls if already active or if an object needs         # them.          dtend_enabled = dtend_control == "enable" or isinstance(dtend, datetime) or dtstart != dtend         dttimes_enabled = dttimes_control == "enable" or isinstance(dtstart, datetime) or isinstance(dtend, datetime)          if dtend_enabled:             page.input(name="dtend-control", type="radio", value="enable", id="dtend-enable", checked="checked")             page.input(name="dtend-control", type="radio", value="disable", id="dtend-disable")         else:             page.input(name="dtend-control", type="radio", value="enable", id="dtend-enable")             page.input(name="dtend-control", type="radio", value="disable", id="dtend-disable", checked="checked")          if dttimes_enabled:             page.input(name="dttimes-control", type="radio", value="enable", id="dttimes-enable", checked="checked")             page.input(name="dttimes-control", type="radio", value="disable", id="dttimes-disable")         else:             page.input(name="dttimes-control", type="radio", value="enable", id="dttimes-enable")             page.input(name="dttimes-control", type="radio", value="disable", id="dttimes-disable", checked="checked")          # Provide a summary of the object.          page.table(class_="object", cellspacing=5, cellpadding=5)         page.thead()         page.tr()         page.th("Event", class_="mainheading", colspan=2)         page.tr.close()         page.thead.close()         page.tbody()          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          for name, label in self.property_items:             page.tr()              # Handle datetimes specially.              if name in ["DTSTART", "DTEND"]:                 field = name.lower()                  page.th(label, class_="objectheading %s%s" % (field, error and field in error and " error" or ""))                  # Obtain the datetime.                  if name == "DTSTART":                     dt, attr, event_tzid = dtstart, dtstart_attr, dtstart_attr.get("TZID", tzid)                  # Where no end datetime exists, use the start datetime as the                 # basis of any potential datetime specified if dt-control is                 # set.                  else:                     dt, attr, event_tzid = dtend or dtstart, dtend_attr or dtstart_attr, (dtend_attr or dtstart_attr).get("TZID", tzid)                  # Show controls for editing as organiser.                  if is_organiser:                     value = format_datetime(dt)                      page.td(class_="objectvalue %s" % field)                     if name == "DTEND":                         page.div(class_="dt disabled")                         page.label("Specify end date", for_="dtend-enable", class_="enable")                         page.div.close()                      page.div(class_="dt enabled")                     self._show_date_controls(field, value, attr, tzid)                     if name == "DTSTART":                         page.label("Specify times", for_="dttimes-enable", class_="time disabled enable")                         page.label("Specify dates only", for_="dttimes-disable", class_="time enabled disable")                     elif name == "DTEND":                         page.label("End on same day", for_="dtend-disable", class_="disable")                     page.div.close()                      page.td.close()                  # Show a label as attendee.                  else:                     page.td(self.format_datetime(dt, "full"))                  page.tr.close()              # Handle the summary specially.              elif name == "SUMMARY":                 value = args.get("summary", [obj.get_value(name)])[0]                  page.th(label, class_="objectheading")                 page.td()                 if is_organiser:                     page.input(name="summary", type="text", value=value, size=80)                 else:                     page.add(value)                 page.td.close()                 page.tr.close()              # Handle potentially many values.              else:                 items = obj.get_items(name) or []                 rowspan = len(items)                  if name == "ATTENDEE":                     rowspan += len(new_attendees) + 1                 elif not items:                     continue                  page.th(label, class_="objectheading", rowspan=rowspan)                  first = True                  for i, (value, attr) in enumerate(items):                     if not first:                         page.tr()                     else:                         first = False                      if name in ("ATTENDEE", "ORGANIZER"):                         value = get_uri(value)                          page.td(class_="objectvalue")                         page.add(value)                         page.add(" ")                          partstat = attr.get("PARTSTAT")                         if value == self.user and (not is_organiser or name == "ORGANIZER"):                             self._show_menu("partstat", partstat, self.partstat_items, "partstat")                         else:                             page.span(dict(self.partstat_items).get(partstat, ""), class_="partstat")                          if is_organiser and name == "ATTENDEE":                             if value in args.get("remove", []):                                 page.input(name="remove", type="checkbox", value=value, id="remove-%d" % i, class_="remove", checked="checked")                             else:                                 page.input(name="remove", type="checkbox", value=value, id="remove-%d" % i, class_="remove")                             page.label("Remove", for_="remove-%d" % i, class_="remove")                             page.label("Uninvited", for_="remove-%d" % i, class_="removed")                      else:                         page.td(class_="objectvalue")                         page.add(value)                      page.td.close()                     page.tr.close()                  # Allow more attendees to be specified.                  if is_organiser and name == "ATTENDEE":                     for i, attendee in enumerate(new_attendees):                         if not first:                             page.tr()                         else:                             first = False                          page.td()                         page.input(name="added", type="value", value=attendee)                         page.input(name="removenew", type="submit", value=attendee, id="removenew-%d" % i, class_="remove")                         page.label("Remove", for_="removenew-%d" % i, class_="remove")                         page.td.close()                         page.tr.close()                      if not first:                         page.tr()                      page.td()                     page.input(name="attendee", type="value", value=new_attendee)                     page.input(name="add", type="submit", value="add", id="add-%d" % i, class_="add")                     page.label("Add", for_="add-%d" % i, class_="add")                     page.td.close()                     page.tr.close()          page.tbody.close()         page.table.close()          self.show_recurrences(obj)         self.show_conflicting_events(uid, obj)         self.show_request_controls(obj)          page.form.close()      def show_recurrences(self, obj):          "Show recurrences for the object having the given representation 'obj'."          page = self.page          # Obtain the user's timezone.          tzid = self.get_tzid()          window_size = 100          periods = obj.get_periods(self.get_tzid(), window_size)          if len(periods) == 1:             return          page.p("This event occurs on the following occasions within the next %d days:" % window_size)          page.table(cellspacing=5, cellpadding=5, class_="conflicts")         page.thead()         page.tr()         page.th("Start")         page.th("End")         page.tr.close()         page.thead.close()         page.tbody()          for start, end in periods:             page.tr()             page.td(self.format_datetime(start, "long"))             page.td(self.format_datetime(end, "long"))             page.tr.close()          page.tbody.close()         page.table.close()      def show_conflicting_events(self, uid, obj):          """         Show conflicting events for the object having the given 'uid' and         representation 'obj'.         """          page = self.page          # Obtain the user's timezone.          tzid = self.get_tzid()          dtstart = format_datetime(obj.get_utc_datetime("DTSTART"))         dtend = format_datetime(obj.get_utc_datetime("DTEND"))          # Indicate whether there are conflicting events.          freebusy = self.store.get_freebusy(self.user)          if freebusy:              # Obtain any time zone details from the suggested event.              _dtstart, attr = obj.get_item("DTSTART")             tzid = attr.get("TZID", tzid)              # Show any conflicts.              conflicts = [t for t in have_conflict(freebusy, [(dtstart, dtend)], True) if t[2] != uid]              if conflicts:                 page.p("This event conflicts with others:")                  page.table(cellspacing=5, cellpadding=5, class_="conflicts")                 page.thead()                 page.tr()                 page.th("Event")                 page.th("Start")                 page.th("End")                 page.tr.close()                 page.thead.close()                 page.tbody()                  for t in conflicts:                     start, end, found_uid = t[:3]                      # Provide details of any conflicting event.                      start = self.format_datetime(to_timezone(get_datetime(start), tzid), "long")                     end = self.format_datetime(to_timezone(get_datetime(end), tzid), "long")                      page.tr()                      # Show the event summary for the conflicting event.                      page.td()                      found_obj = self._get_object(found_uid)                     if found_obj:                         page.a(found_obj.get_value("SUMMARY"), href=self.env.new_url(found_uid))                     else:                         page.add("No details available")                      page.td.close()                      page.td(start)                     page.td(end)                      page.tr.close()                  page.tbody.close()                 page.table.close()      def show_requests_on_page(self):          "Show requests for the current user."          # NOTE: This list could be more informative, but it is envisaged that         # NOTE: the requests would be visited directly anyway.          requests = self._get_requests()          self.page.div(id="pending-requests")          if requests:             self.page.p("Pending requests:")              self.page.ul()              for request in requests:                 obj = self._get_object(request)                 if obj:                     self.page.li()                     self.page.a(obj.get_value("SUMMARY"), href="#request-%s" % request)                     self.page.li.close()              self.page.ul.close()          else:             self.page.p("There are no pending requests.")          self.page.div.close()      def show_participants_on_page(self):          "Show participants for scheduling purposes."          args = self.env.get_args()         participants = args.get("participants", [])          try:             for name, value in args.items():                 if name.startswith("remove-participant-"):                     i = int(name[len("remove-participant-"):])                     del participants[i]                     break         except ValueError:             pass          # Trim empty participants.          while participants and not participants[-1].strip():             participants.pop()          # Show any specified participants together with controls to remove and         # add participants.          self.page.div(id="participants")          self.page.p("Participants for scheduling:")          for i, participant in enumerate(participants):             self.page.p()             self.page.input(name="participants", type="text", value=participant)             self.page.input(name="remove-participant-%d" % i, type="submit", value="Remove")             self.page.p.close()          self.page.p()         self.page.input(name="participants", type="text")         self.page.input(name="add-participant", type="submit", value="Add")         self.page.p.close()          self.page.div.close()          return participants      # Full page output methods.      def show_object(self, path_info):          "Show an object request using the given 'path_info' for the current user."          uid = self._get_uid(path_info)         obj = self._get_object(uid)          if not obj:             return False          error = self.handle_request(uid, obj)          if not error:             return True          self.new_page(title="Event")         self.show_object_on_page(uid, obj, error)          return True      def show_calendar(self):          "Show the calendar for the current user."          handled = self.handle_newevent()          self.new_page(title="Calendar")         page = self.page          # Form controls are used in various places on the calendar page.          page.form(method="POST")          self.show_requests_on_page()         participants = self.show_participants_on_page()          # Show a button for scheduling a new event.          page.p(class_="controls")         page.input(name="newevent", type="submit", value="New event", id="newevent", accesskey="N")         page.input(name="reset", type="submit", value="Clear selections", id="reset")         page.p.close()          # Show controls for hiding empty days and busy slots.         # The positioning of the control, paragraph and table are important here.          page.input(name="showdays", type="checkbox", value="show", id="showdays", accesskey="D")         page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy", accesskey="B")          page.p(class_="controls")         page.label("Hide busy time periods", for_="hidebusy", class_="hidebusy enable")         page.label("Show busy time periods", for_="hidebusy", class_="hidebusy disable")         page.label("Show empty days", for_="showdays", class_="showdays disable")         page.label("Hide empty days", for_="showdays", class_="showdays enable")         page.p.close()          freebusy = self.store.get_freebusy(self.user)          if not freebusy:             page.p("No events scheduled.")             return          # Obtain the user's timezone.          tzid = self.get_tzid()          # Day view: start at the earliest known day and produce days until the         # latest known day, perhaps with expandable sections of empty days.          # Month view: start at the earliest known month and produce months until         # the latest known month, perhaps with expandable sections of empty         # months.          # Details of users to invite to new events could be superimposed on the         # calendar.          # Requests are listed and linked to their tentative positions in the         # calendar. Other participants are also shown.          request_summary = self._get_request_summary()          period_groups = [request_summary, freebusy]         period_group_types = ["request", "freebusy"]         period_group_sources = ["Pending requests", "Your schedule"]          for i, participant in enumerate(participants):             period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))             period_group_types.append("freebusy-part%d" % i)             period_group_sources.append(participant)          groups = []         group_columns = []         group_types = period_group_types         group_sources = period_group_sources         all_points = set()          # Obtain time point information for each group of periods.          for periods in period_groups:             periods = convert_periods(periods, tzid)              # Get the time scale with start and end points.              scale = get_scale(periods)              # Get the time slots for the periods.              slots = get_slots(scale)              # Add start of day time points for multi-day periods.              add_day_start_points(slots, tzid)              # Record the slots and all time points employed.              groups.append(slots)             all_points.update([point for point, active in slots])          # Partition the groups into days.          days = {}         partitioned_groups = []         partitioned_group_types = []         partitioned_group_sources = []          for slots, group_type, group_source in zip(groups, group_types, group_sources):              # Propagate time points to all groups of time slots.              add_slots(slots, all_points)              # Count the number of columns employed by the group.              columns = 0              # Partition the time slots by day.              partitioned = {}              for day, day_slots in partition_by_day(slots).items():                 intervals = []                 last = None                  for point, active in day_slots:                     columns = max(columns, len(active))                     if last:                         intervals.append((last, point))                     last = point                  if last:                     intervals.append((last, None))                  if not days.has_key(day):                     days[day] = set()                  # Convert each partition to a mapping from points to active                 # periods.                  partitioned[day] = dict(day_slots)                  # Record the divisions or intervals within each day.                  days[day].update(intervals)              if group_type != "request" or columns:                 group_columns.append(columns)                 partitioned_groups.append(partitioned)                 partitioned_group_types.append(group_type)                 partitioned_group_sources.append(group_source)          # Add empty days.          add_empty_days(days, tzid)          # Show the controls permitting day selection.          self.show_calendar_day_controls(days)          # Show the calendar itself.          page.table(cellspacing=5, cellpadding=5, class_="calendar")         self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)         self.show_calendar_days(days, partitioned_groups, partitioned_group_types, group_columns)         page.table.close()          # End the form region.          page.form.close()      # More page fragment methods.      def show_calendar_day_controls(self, days):          "Show controls for the given 'days' in the calendar."          page = self.page         slots = self.env.get_args().get("slot", [])          for day in days:             value, identifier = self._day_value_and_identifier(day)             self._slot_selector(value, identifier, slots)          # Generate a dynamic stylesheet to allow day selections to colour         # specific days.         # NOTE: The style details need to be coordinated with the static         # NOTE: stylesheet.          page.style(type="text/css")          for day in days:             daystr = format_datetime(day)             page.add("""\ input.newevent.selector#day-%s-:checked ~ table label.day.day-%s, input.newevent.selector#day-%s-:checked ~ table label.timepoint.day-%s {     background-color: #5f4;     text-decoration: underline; } """ % (daystr, daystr, daystr, daystr))          page.style.close()      def show_calendar_participant_headings(self, group_types, group_sources, group_columns):          """         Show headings for the participants and other scheduling contributors,         defined by 'group_types', 'group_sources' and 'group_columns'.         """          page = self.page          page.colgroup(span=1, id="columns-timeslot")          for group_type, columns in zip(group_types, group_columns):             page.colgroup(span=max(columns, 1), id="columns-%s" % group_type)          page.thead()         page.tr()         page.th("", class_="emptyheading")          for group_type, source, columns in zip(group_types, group_sources, group_columns):             page.th(source,                 class_=(group_type == "request" and "requestheading" or "participantheading"),                 colspan=max(columns, 1))          page.tr.close()         page.thead.close()      def show_calendar_days(self, days, partitioned_groups, partitioned_group_types, group_columns):          """         Show calendar days, defined by a collection of 'days', the contributing         period information as 'partitioned_groups' (partitioned by day), the         'partitioned_group_types' indicating the kind of contribution involved,         and the 'group_columns' defining the number of columns in each group.         """          page = self.page          # Determine the number of columns required. Where participants provide         # no columns for events, one still needs to be provided for the         # participant itself.          all_columns = sum([max(columns, 1) for columns in group_columns])          # Determine the days providing time slots.          all_days = days.items()         all_days.sort()          # Produce a heading and time points for each day.          for day, intervals in all_days:             groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]             is_empty = True              for slots in groups_for_day:                 if not slots:                     continue                  for active in slots.values():                     if active:                         is_empty = False                         break              page.thead(class_="separator%s" % (is_empty and " empty" or ""))             page.tr()             page.th(class_="dayheading container", colspan=all_columns+1)             self._day_heading(day)             page.th.close()             page.tr.close()             page.thead.close()              page.tbody(class_="points%s" % (is_empty and " empty" or ""))             self.show_calendar_points(intervals, groups_for_day, partitioned_group_types, group_columns)             page.tbody.close()      def show_calendar_points(self, intervals, groups, group_types, group_columns):          """         Show the time 'intervals' along with period information from the given         'groups', having the indicated 'group_types', each with the number of         columns given by 'group_columns'.         """          page = self.page          # Obtain the user's timezone.          tzid = self.get_tzid()          # Produce a row for each interval.          intervals = list(intervals)         intervals.sort()          for point, endpoint in intervals:             continuation = point == get_start_of_day(point, tzid)              # Some rows contain no period details and are marked as such.              have_active = reduce(lambda x, y: x or y, [slots and slots.get(point) for slots in groups], None)              css = " ".join(                 ["slot"] +                 (have_active and ["busy"] or ["empty"]) +                 (continuation and ["daystart"] or [])                 )              page.tr(class_=css)             page.th(class_="timeslot")             self._time_point(point, endpoint)             page.th.close()              # Obtain slots for the time point from each group.              for columns, slots, group_type in zip(group_columns, groups, group_types):                 active = slots and slots.get(point)                  # Where no periods exist for the given time interval, generate                 # an empty cell. Where a participant provides no periods at all,                 # the colspan is adjusted to be 1, not 0.                  if not active:                     page.td(class_="empty container", colspan=max(columns, 1))                     self._empty_slot(point, endpoint)                     page.td.close()                     continue                  slots = slots.items()                 slots.sort()                 spans = get_spans(slots)                  empty = 0                  # Show a column for each active period.                  for t in active:                     if t and len(t) >= 2:                          # Flush empty slots preceding this one.                          if empty:                             page.td(class_="empty container", colspan=empty)                             self._empty_slot(point, endpoint)                             page.td.close()                             empty = 0                          start, end, uid, key = get_freebusy_details(t)                         span = spans[key]                          # Produce a table cell only at the start of the period                         # or when continued at the start of a day.                          if point == start or continuation:                              obj = self._get_object(uid)                              has_continued = continuation and point != start                             will_continue = not ends_on_same_day(point, end, tzid)                             is_organiser = obj and get_uri(obj.get_value("ORGANIZER")) == self.user                              css = " ".join(                                 ["event"] +                                 (has_continued and ["continued"] or []) +                                 (will_continue and ["continues"] or []) +                                 (is_organiser and ["organising"] or ["attending"])                                 )                              # Only anchor the first cell of events.                              if point == start:                                 page.td(class_=css, rowspan=span, id="%s-%s" % (group_type, uid))                             else:                                 page.td(class_=css, rowspan=span)                              if not obj:                                 page.span("(Participant is busy)")                             else:                                 summary = obj.get_value("SUMMARY")                                  # Only link to events if they are not being                                 # updated by requests.                                  if uid in self._get_requests() and group_type != "request":                                     page.span(summary)                                 else:                                     href = "%s/%s" % (self.env.get_url().rstrip("/"), uid)                                     page.a(summary, href=href)                              page.td.close()                     else:                         empty += 1                  # Pad with empty columns.                  empty = columns - len(active)                  if empty:                     page.td(class_="empty container", colspan=empty)                     self._empty_slot(point, endpoint)                     page.td.close()              page.tr.close()      def _day_heading(self, day):          """         Generate a heading for 'day' of the following form:          <label class="day day-20150203" for="day-20150203">Tuesday, 3 February 2015</label>         """          page = self.page         daystr = format_datetime(day)         value, identifier = self._day_value_and_identifier(day)         page.label(self.format_date(day, "full"), class_="day day-%s" % daystr, for_=identifier)      def _time_point(self, point, endpoint):          """         Generate headings for the 'point' to 'endpoint' period of the following         form:          <label class="timepoint day-20150203" for="slot-20150203T090000-20150203T100000">09:00:00 CET</label>         <span class="endpoint">10:00:00 CET</span>         """          page = self.page         tzid = self.get_tzid()         daystr = format_datetime(point.date())         value, identifier = self._slot_value_and_identifier(point, endpoint)         slots = self.env.get_args().get("slot", [])         self._slot_selector(value, identifier, slots)         page.label(self.format_time(point, "long"), class_="timepoint day-%s" % daystr, for_=identifier)         page.span(self.format_time(endpoint or get_end_of_day(point, tzid), "long"), class_="endpoint")      def _slot_selector(self, value, identifier, slots):         reset = self.env.get_args().has_key("reset")         page = self.page         if not reset and value in slots:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector", checked="checked")         else:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector")      def _empty_slot(self, point, endpoint):         page = self.page         value, identifier = self._slot_value_and_identifier(point, endpoint)         page.label("Select/deselect period", class_="newevent popup", for_=identifier)      def _day_value_and_identifier(self, day):         value = "%s-" % format_datetime(day)         identifier = "day-%s" % value         return value, identifier      def _slot_value_and_identifier(self, point, endpoint):         value = "%s-%s" % (format_datetime(point), endpoint and format_datetime(endpoint) or "")         identifier = "slot-%s" % value         return value, identifier      def _show_menu(self, name, default, items, class_=""):         page = self.page         values = self.env.get_args().get(name, [default])         page.select(name=name, class_=class_)         for v, label in items:             if v in values:                 page.option(label, value=v, selected="selected")             else:                 page.option(label, value=v)         page.select.close()      def _show_date_controls(self, name, default, attr, tzid):          """         Show date controls for a field with the given 'name' and 'default' value         and 'attr', with the given 'tzid' being used if no other time regime         information is provided.         """          page = self.page         args = self.env.get_args()          event_tzid = attr.get("TZID", tzid)         dt = get_datetime(default, attr)          # Show dates for up to one week around the current date.          base = get_date(dt)         items = []         for i in range(-7, 8):             d = base + timedelta(i)             items.append((format_datetime(d), self.format_date(d, "full")))          self._show_menu("%s-date" % name, format_datetime(base), items)          # Show time details.          dt_time = isinstance(dt, datetime) and dt or None         hour = args.get("%s-hour" % name, "%02d" % (dt_time and dt_time.hour or 0))         minute = args.get("%s-minute" % name, "%02d" % (dt_time and dt_time.minute or 0))         second = args.get("%s-second" % name, "%02d" % (dt_time and dt_time.second or 0))          page.span(class_="time enabled")         page.input(name="%s-hour" % name, type="text", value=hour, maxlength=2, size=2)         page.add(":")         page.input(name="%s-minute" % name, type="text", value=minute, maxlength=2, size=2)         page.add(":")         page.input(name="%s-second" % name, type="text", value=second, maxlength=2, size=2)         page.add(" ")         self._show_menu("%s-tzid" % name, event_tzid,             [(event_tzid, event_tzid)] + (             event_tzid != tzid and [(tzid, tzid)] or []             ))         page.span.close()      # Incoming HTTP request direction.      def select_action(self):          "Select the desired action and show the result."          path_info = self.env.get_path_info().strip("/")          if not path_info:             self.show_calendar()         elif self.show_object(path_info):             pass         else:             self.no_page()      def __call__(self):          "Interpret a request and show an appropriate response."          if not self.user:             self.no_user()         else:             self.select_action()          # Write the headers and actual content.          print >>self.out, "Content-Type: text/html; charset=%s" % self.encoding         print >>self.out         self.out.write(unicode(self.page).encode(self.encoding))  if __name__ == "__main__":     Manager()()  # vim: tabstop=4 expandtab shiftwidth=4