#!/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, get_datetime, get_datetime_item, \                             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_slots, convert_periods, \                              get_freebusy_details, \                              get_scale, have_conflict, get_slots, get_spans, \                              partition_by_day 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):          """         Create a full calendar object employing the given 'method', and send it         to the appropriate recipients, also sending a copy to the 'sender'.         """          parts = [self.obj.to_part(method)]          if self.user == self.organiser:             recipients = map(get_address, self.attendees)         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)             parts.append(to_part("PUBLISH", [make_freebusy(freebusy, uid, self.user)]))          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, accept, update=False):          """         Process the current request for the given 'user', accepting any request         when 'accept' is true, declining requests otherwise. Return whether any         action was taken.          If 'update' is given, the sequence number will be incremented in order         to override any previous response.         """          # When accepting or declining, do so only on behalf of this user,         # preserving any other attributes set as an attendee.          for attendee, attendee_attr in self.obj.get_items("ATTENDEE"):              if attendee == self.user:                 attendee_attr["PARTSTAT"] = accept and "ACCEPTED" or "DECLINED"                 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)]                 if update:                     sequence = self.obj.get_value("SEQUENCE") or "0"                     self.obj["SEQUENCE"] = [(str(int(sequence) + 1), {})]                 self.update_dtstamp()                  self.send_message("REPLY", get_address(attendee))                  return True          return False      def process_created_request(self, update=False):          """         Process the current request for the given 'user', sending a created         request 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)         if update:             sequence = self.obj.get_value("SEQUENCE") or "0"             self.obj["SEQUENCE"] = [(str(int(sequence) + 1), {})]         self.update_dtstamp()          self.send_message("REQUEST", get_address(self.organiser))          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      # 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_end_datetime(self, dt, format):         if isinstance(dt, date) and not isinstance(dt, datetime):             dt = dt - timedelta(1)         return self.format_datetime(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)      # 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 and page fragment 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          # Coalesce the selected slots.          slots.sort()         coalesced = []         last = None          for slot in slots:             start, end = slot.split("-")             if last:                 if start == last[1]:                     last = last[0], end                     continue                 else:                     coalesced.append(last)             last = start, end          if last:             coalesced.append(last)          # Obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.get("TZID", "UTC")          # 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 = get_datetime(start, {"TZID" : tzid})             end = end and get_datetime(end, {"TZID" : tzid}) or get_start_of_next_day(start, tzid)              start_value, start_attr = get_datetime_item(start)             end_value, end_attr = get_datetime_item(end)              # 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)                 if participant != self.user:                     rwrite(("ATTENDEE", {}, 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, queued):          """         Handle actions involving the given 'uid' and 'obj' object, where         'queued' indicates that the object has not yet been handled.         """          # Handle a submitted form.          args = self.env.get_args()         handled = True          # Update the object.          if args.has_key("summary"):             obj["SUMMARY"] = [(args["summary"][0], {})]          # Process any action.          accept = args.has_key("accept")         decline = args.has_key("decline")         invite = args.has_key("invite")         update = not queued and args.has_key("update")          if accept or decline or invite:              handler = ManagerHandler(obj, self.user, self.messenger)              # Process the object and remove it from the list of requests.              if (accept or decline) and handler.process_received_request(accept, update) or \                 invite and handler.process_created_request(update):                  self.remove_request(uid)          elif args.has_key("discard"):              # Remove the request and the object.              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 handled      def show_request_controls(self, obj, needs_action):          """         Show form controls for a request concerning 'obj', indicating whether         action is needed if 'needs_action' is specified as a true value.         """          page = self.page          is_organiser = obj.get_value("ORGANIZER") == self.user          if not is_organiser:             attendees = obj.get_value_map("ATTENDEE")             attendee_attr = attendees.get(self.user)              if attendee_attr:                 partstat = attendee_attr.get("PARTSTAT")                 if partstat == "ACCEPTED":                     page.p("This request has been accepted.")                 elif partstat == "DECLINED":                     page.p("This request has been declined.")                 else:                     page.p("This request has not yet been dealt with.")          if needs_action:             page.p("An action is required for this request:")         else:             page.p("This request can be updated as follows:")          page.p()          # Show appropriate options depending on the role of the user.          if is_organiser:             page.input(name="invite", type="submit", value="Invite")         else:             page.input(name="accept", type="submit", value="Accept")             page.add(" ")             page.input(name="decline", type="submit", value="Decline")          page.add(" ")         page.input(name="discard", type="submit", value="Discard")          # Updated objects need to have details updated upon sending.          if not needs_action:             page.input(name="update", type="hidden", value="true")          page.p.close()      object_labels = {         "SUMMARY"   : "Summary",         "DTSTART"   : "Start",         "DTEND"     : "End",         "ORGANIZER" : "Organiser",         "ATTENDEE"  : "Attendee",         }      def show_object_on_page(self, uid, obj, needs_action):          """         Show the calendar object with the given 'uid' and representation 'obj'         on the current page.         """          page = self.page         page.form(method="POST")          # Obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.get("TZID", "UTC")          # 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()          for name in ["SUMMARY", "DTSTART", "DTEND", "ORGANIZER", "ATTENDEE"]:             page.tr()              label = self.object_labels.get(name, name)              # Handle datetimes specially.              if name in ["DTSTART", "DTEND"]:                 value, attr = obj.get_item(name)                 tzid = attr.get("TZID", tzid)                 value = (                     name == "DTSTART" and self.format_datetime or self.format_end_datetime                     )(to_timezone(get_datetime(value), tzid), "full")                 page.th(label, class_="objectheading")                 page.td(value)                 page.tr.close()              # Handle the summary specially.              elif name == "SUMMARY":                 value = obj.get_value(name)                 page.th(label, class_="objectheading")                 page.td()                 page.input(name="summary", type="text", value=value, size=80)                 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                      page.td()                     page.add(value)                      if name == "ATTENDEE":                         partstat = attr.get("PARTSTAT")                         if partstat:                             page.add(" (%s)" % partstat)                      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, needs_action)         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          is_request = uid in self._get_requests()         handled = self.handle_request(uid, obj, is_request)          if handled:             return True          self.new_page(title="Event")         self.show_object_on_page(uid, obj, is_request and not handled)          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.p.close()          # Show controls for hiding empty and busy slots.         # The positioning of the control, paragraph and table are important here.          page.input(name="hideslots", type="checkbox", value="hide", id="hideslots")         page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy")          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("Hide unused time periods", for_="hideslots", class_="hideslots enable")         page.label("Show unused time periods", for_="hideslots", class_="hideslots disable")         page.p.close()          freebusy = self.store.get_freebusy(self.user)          if not freebusy:             page.p("No events scheduled.")             return          # Obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.get("TZID", "UTC")          # 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)              # 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)          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()      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:             page.thead()             page.tr()             page.th(class_="dayheading", colspan=all_columns+1)             self._day_heading(day)             page.th.close()             page.tr.close()             page.thead.close()              groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]              page.tbody()             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          # Produce a row for each interval.          intervals = list(intervals)         intervals.sort()          for point, endpoint in intervals:             continuation = point == get_start_of_day(point)              # Some rows contain no period details and are marked as such.              have_active = reduce(lambda x, y: x or y, [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)                  # Show a column for each active period.                  for t in active:                     if t and len(t) >= 2:                         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:                              has_continued = continuation and point != start                             will_continue = not ends_on_same_day(point, end)                             css = " ".join(                                 ["event"] +                                 (has_continued and ["continued"] or []) +                                 (will_continue and ["continues"] or [])                                 )                              # 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)                              obj = self._get_object(uid)                              if not obj:                                 page.span("")                             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:                         page.td(class_="empty container")                         self._empty_slot(point, endpoint)                         page.td.close()                  # Pad with empty columns.                  i = columns - len(active)                 while i > 0:                     i -= 1                     page.td(class_="empty container")                     self._empty_slot(point, endpoint)                     page.td.close()              page.tr.close()      def _day_heading(self, day):         page = self.page         value, identifier = self._day_value_and_identifier(day)         slots = self.env.get_args().get("slot", [])         self._slot_selector(value, identifier, slots)         page.label(self.format_date(day, "full"), class_="day", for_=identifier)      def _time_point(self, point, endpoint):         page = self.page         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", for_=identifier)      def _slot_selector(self, value, identifier, slots):         page = self.page         if value in slots:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent", checked="checked")         else:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent")      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 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