#!/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, parse_object, \                            Object, to_part 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 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 ManagerHandler(Handler):      """     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)         self.set_object(obj)         self.user = user          self.organiser = self.obj.get_value("ORGANIZER")         self.attendees = self.obj.get_values("ATTENDEE")      # 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.          if for_organiser:             recipients = [get_address(attendee) for attendee in self.attendees if attendee != self.user]         else:             recipients = [get_address(self.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)             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 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):          """         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.         """          organiser, organiser_attr = self.obj.get_item("ORGANIZER")          if self.messenger and self.messenger.sender != get_address(organiser):             organiser_attr["SENT-BY"] = get_uri(self.messenger.sender)          self.update_dtstamp()         self.set_sequence(update)          self.send_message(method, get_address(self.organiser), for_organiser=True)         return True  class Manager:      "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()         self.user = user and get_uri(user) or None         self.preferences = 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]          f = uid and self.store.get_event(self.user, uid) or None          if not f:             return None          fragment = parse_object(f, "utf-8")         obj = self.objects[uid] = fragment and Object(fragment)          return obj      def _get_requests(self):         if self.requests is None:             self.requests = self.store.get_requests(self.user)         return self.requests      def _get_request_summary(self):         summary = []         for uid in self._get_requests():             obj = self._get_object(uid)             if obj:                 summary.append((                     obj.get_value("DTSTART"),                     obj.get_value("DTEND"),                     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      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()      # 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], {})]          if args.has_key("partstat"):             organisers = obj.get_value_map("ORGANIZER")             attendees = obj.get_value_map("ATTENDEE")             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 = obj.get_value("ORGANIZER") == self.user          # Obtain the user's timezone and process datetime values.          update = False          if is_organiser:             t = self.handle_date_controls("dtstart")             if t:                 dtstart, attr = t                 update = self.set_datetime_in_object(dtstart, attr["TZID"], "DTSTART", obj) or update             else:                 return ["dtstart"]              # Handle specified end datetimes.              if args.get("dtend-control", [None])[0] == "enable":                 t = self.handle_date_controls("dtend")                 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["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["TZID"], "DTEND", obj) or update              if dtstart >= dtend:                 return ["dtstart", "dtend"]          # 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 \                (invite or cancel) and handler.process_created_request(invite and "REQUEST" or "CANCEL", update):                  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):          """         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()         tzid = self.get_tzid()          if args.has_key("%s-date" % name):             date = args["%s-date" % name][0]             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, [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}             dt = get_datetime(value, attr)             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          is_organiser = obj.get_value("ORGANIZER") == self.user          attendees = obj.get_value_map("ATTENDEE")         is_attendee = attendees.has_key(self.user)         attendee_attr = attendees.get(self.user)          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()                 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()          t = self.handle_date_controls("dtstart")         if t:             dtstart, dtstart_attr = t         else:             dtstart, dtstart_attr = obj.get_datetime_item("DTSTART")          dtend_control = args.get("dtend-control", [None])[0]          if dtend_control == "enable":             t = self.handle_date_controls("dtend")             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_control = dtend_control or (isinstance(dtend, datetime) or dtstart != dtend) and "enable" or None          if dtend_control == "enable":             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")          # 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 = 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)                  strvalue = self.format_datetime(dt, "full")                 value = format_datetime(dt)                  if is_organiser:                     page.td(class_="objectvalue %s" % field)                     if name == "DTEND":                         page.div(class_="disabled")                         page.label("Specify end date", for_="dtend-enable", class_="enable")                         page.div.close()                      page.div(class_="enabled")                     self._show_date_controls(field, value, attr, tzid)                     if name == "DTEND":                         page.label("End on same day", for_="dtend-disable", class_="disable")                     page.div.close()                      page.td.close()                 else:                     page.td(strvalue)                  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)                 if not items:                     continue                  page.th(label, class_="objectheading", rowspan=len(items))                  first = True                  for value, attr in items:                     if not first:                         page.tr()                     else:                         first = False                      if name in ("ATTENDEE", "ORGANIZER"):                         page.td(class_="objectattribute")                         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)                         else:                             page.span(dict(self.partstat_items).get(partstat, ""), class_="partstat")                     else:                         page.td(class_="objectattribute")                         page.add(value)                      page.td.close()                     page.tr.close()          page.tbody.close()         page.table.close()          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.              for t in have_conflict(freebusy, [(dtstart, dtend)], True):                 start, end, found_uid = t[:3]                  # Provide details of any conflicting event.                  if uid != found_uid:                     start = self.format_datetime(to_timezone(get_datetime(start), tzid), "full")                     end = self.format_datetime(to_timezone(get_datetime(end), tzid), "full")                     page.p("Event conflicts with another from %s to %s: " % (start, end))                      # Show the event summary for the conflicting event.                      found_obj = self._get_object(found_uid)                     if found_obj:                         page.a(found_obj.get_value("SUMMARY"), href=self.env.new_url(found_uid))          self.show_request_controls(obj)         page.form.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")         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 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):         page = self.page         values = self.env.get_args().get(name, [default])         page.select(name=name)         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.          if isinstance(dt, datetime):             hour = args.get("%s-hour" % name, "%02d" % dt.hour)             minute = args.get("%s-minute" % name, "%02d" % dt.minute)             second = args.get("%s-second" % name, "%02d" % dt.second)             page.add(" ")             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 []                 ))      # 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