#!/usr/bin/env python  """ A Web interface to a calendar event.  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/>. """  from datetime import datetime, timedelta from imiptools.client import update_attendees, update_participation from imiptools.data import get_uri, uri_dict, uri_values from imiptools.dates import format_datetime, to_date, get_datetime, \                             get_datetime_item, get_period_item, \                             get_start_of_day, to_timezone from imiptools.mail import Messenger from imiptools.period import have_conflict from imipweb.handler import ManagerHandler from imipweb.resource import Resource import pytz  class EventPage(Resource):      "A request handler for the event page."      def __init__(self, resource=None, messenger=None):         Resource.__init__(self, resource)         self.messenger = messenger or Messenger()      # Various property values and labels.      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"),         (None, "Not indicated"),         ]      # Request logic methods.      def handle_request(self, uid, recurrenceid, obj):          """         Handle actions involving the given 'uid', 'recurrenceid', and 'obj' as         the object's representation, 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")         ignore = args.has_key("ignore")          have_action = reply or discard or invite or cancel or save or ignore          if not have_action:             return ["action"]          # If ignoring the object, return to the calendar.          if ignore:             self.redirect(self.env.get_path())             return None          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          # Obtain the user's timezone and process datetime values.          update = False         periods = None          if is_organiser:             periods, errors = self.handle_all_period_controls()             if errors:                 return errors          # Update the object.          if reply or invite or cancel or save:              # Update principal event details if organiser.              if is_organiser:                  # Update time periods (main and recurring).                  if periods:                     self.set_period_in_object(obj, periods[0])                     self.set_periods_in_object(obj, periods[1:])                  # Update summary.                  if args.has_key("summary"):                     obj["SUMMARY"] = [(args["summary"][0], {})]                  # Obtain any participants and those to be removed.                  attendees = args.get("attendee")                 removed = args.get("remove")                 to_cancel = update_attendees(obj, attendees, removed)              # Update attendee participation.              if args.has_key("partstat"):                 update_participation(obj, self.user, args["partstat"][0])          # 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):                 self.remove_request(uid, recurrenceid)              elif is_organiser and (invite or cancel):                  if handler.process_created_request(                     invite and "REQUEST" or "CANCEL", update, to_cancel):                      self.remove_request(uid, recurrenceid)          # Save single user events.          elif save:             self.store.set_event(self.user, uid, recurrenceid, node=obj.to_node())             self.update_freebusy(uid, recurrenceid, obj)             self.remove_request(uid, recurrenceid)          # Remove the request and the object.          elif discard:             self.remove_from_freebusy(uid, recurrenceid)             self.remove_event(uid, recurrenceid)             self.remove_request(uid, recurrenceid)          else:             handled = False          # Upon handling an action, redirect to the main page.          if handled:             self.redirect(self.env.get_path())          return None      def handle_all_period_controls(self):          """         Handle datetime controls for a particular period, where 'index' may be         used to indicate a recurring period, or the main start and end datetimes         are handled.         """          args = self.env.get_args()          periods = []          # Get the main period details.          dtend_enabled = args.get("dtend-control", [None])[0]         dttimes_enabled = args.get("dttimes-control", [None])[0]         start_values = self.get_date_control_values("dtstart")         end_values = self.get_date_control_values("dtend")          period, errors = self.handle_period_controls(start_values, end_values, dtend_enabled, dttimes_enabled)          if errors:             return None, errors          periods.append(period)          # Get the recurring period details.          all_dtend_enabled = args.get("dtend-control-recur", [])         all_dttimes_enabled = args.get("dttimes-control-recur", [])         all_start_values = self.get_date_control_values("dtstart-recur", multiple=True)         all_end_values = self.get_date_control_values("dtend-recur", multiple=True, tzid_name="dtstart-recur")          for index, (start_values, end_values, dtend_enabled, dttimes_enabled) in \             enumerate(map(None, all_start_values, all_end_values, all_dtend_enabled, all_dttimes_enabled)):              dtend_enabled = str(index) in all_dtend_enabled             dttimes_enabled = str(index) in all_dttimes_enabled             period, errors = self.handle_period_controls(start_values, end_values, dtend_enabled, dttimes_enabled)              if errors:                 return None, errors              periods.append(period)          return periods, None      def handle_period_controls(self, start_values, end_values, dtend_enabled, dttimes_enabled):          """         Handle datetime controls for a particular period, described by the given         'start_values' and 'end_values', with 'dtend_enabled' and         'dttimes_enabled' affecting the usage of the provided values.         """          t = self.handle_date_control_values(start_values, dttimes_enabled)         if t:             dtstart, dtstart_attr = t         else:             return None, ["dtstart"]          # Handle specified end datetimes.          if dtend_enabled:             t = self.handle_date_control_values(end_values, dttimes_enabled)             if t:                 dtend, dtend_attr = t                  # Convert end dates to iCalendar "next day" dates.                  if not isinstance(dtend, datetime):                     dtend += timedelta(1)             else:                 return None, ["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)             dtend_attr = dtstart_attr              if isinstance(dtstart, datetime):                 dtend = get_start_of_day(dtend, attr["TZID"])          if dtstart > dtend:             return None, ["dtstart", "dtend"]          return ((dtstart, dtstart_attr), (dtend, dtend_attr)), None      def handle_date_control_values(self, values, with_time=True):          """         Handle date control information for the given 'values', returning a         (datetime, attr) tuple, or None if the fields cannot be used to         construct a datetime object.         """          if not values or not values["date"]:             return None         elif with_time:             value = "%s%s" % (values["date"], values["time"])             attr = {"TZID" : values["tzid"], "VALUE" : "DATE-TIME"}             dt = get_datetime(value, attr)         else:             attr = {"VALUE" : "DATE"}             dt = get_datetime(values["date"])          if dt:             return dt, attr          return None      def get_date_control_values(self, name, multiple=False, tzid_name=None):          """         Return a dictionary containing date, time and tzid entries for fields         starting with 'name'. If 'multiple' is set to a true value, many         dictionaries will be returned corresponding to a collection of         datetimes. If 'tzid_name' is specified, the time zone information will         be acquired from a field starting with 'tzid_name' instead of 'name'.         """          args = self.env.get_args()          dates = args.get("%s-date" % name, [])         hours = args.get("%s-hour" % name, [])         minutes = args.get("%s-minute" % name, [])         seconds = args.get("%s-second" % name, [])         tzids = args.get("%s-tzid" % (tzid_name or name), [])          # Handle absent values by employing None values.          field_values = map(None, dates, hours, minutes, seconds, tzids)         if not field_values and not multiple:             field_values = [(None, None, None, None, None)]          all_values = []          for date, hour, minute, second, tzid in field_values:              # Construct a usable dictionary of values.              time = (hour or minute or second) and \                 "T%s%s%s" % (                     (hour or "").rjust(2, "0")[:2],                     (minute or "").rjust(2, "0")[:2],                     (second or "").rjust(2, "0")[:2]                     ) or ""              value = {                 "date" : date,                 "time" : time,                 "tzid" : tzid or self.get_tzid()                 }              # Return a single value or append to a collection of all values.              if not multiple:                 return value             else:                 all_values.append(value)          return all_values      def set_period_in_object(self, obj, period):          "Set in the given 'obj' the given 'period' as the main start and end."          (dtstart, dtstart_attr), (dtend, dtend_attr) = period          result = self.set_datetime_in_object(dtstart, dtstart_attr.get("TZID"), "DTSTART", obj)         result = self.set_datetime_in_object(dtend, dtend_attr.get("TZID"), "DTEND", obj) or result         return result      def set_periods_in_object(self, obj, periods):          "Set in the given 'obj' the given 'periods'."          update = False          old_values = obj.get_values("RDATE")         new_rdates = []          if obj.has_key("RDATE"):             del obj["RDATE"]          for period in periods:             (dtstart, dtstart_attr), (dtend, dtend_attr) = period             tzid = dtstart_attr.get("TZID") or dtend_attr.get("TZID")             new_rdates.append(get_period_item(dtstart, dtend, tzid))          obj["RDATE"] = new_rdates          # NOTE: To do: calculate the update status.         return update      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      def handle_attendees(self, obj):          "Add or remove attendees. This does not affect the stored object."          args = self.env.get_args()          attendees = args.get("attendee", [])          if args.has_key("add"):             attendees.append("")          if args.has_key("remove"):             removed_attendee = args["remove"][0]             if removed_attendee in attendees:                 attendees.remove(removed_attendee)          return attendees      def get_event_period(self, obj):          """         Return (dtstart, dtstart attributes), (dtend, dtend attributes) for         'obj'.         """          dtstart, dtstart_attr = obj.get_datetime_item("DTSTART")         if obj.has_key("DTEND"):             dtend, dtend_attr = obj.get_datetime_item("DTEND")         elif obj.has_key("DURATION"):             duration = obj.get_duration("DURATION")             dtend = dtstart + duration             dtend_attr = dtstart_attr         else:             dtend, dtend_attr = dtstart, dtstart_attr         return (dtstart, dtstart_attr), (dtend, dtend_attr)      # 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 []) + filter(None, args.get("attendee", [])))         is_attendee = self.user in attendees          is_request = (obj.get_value("UID"), obj.get_value("RECURRENCE-ID")) 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="Send reply")             page.add(" ")             page.input(name="discard", type="submit", value="Discard event")             page.add(" ")             page.input(name="ignore", type="submit", value="Do nothing for now")             page.p.close()          if is_organiser:             page.p("As organiser, you can perform the following:")              if have_other_attendees:                 page.p()                 page.input(name="invite", type="submit", value="Invite/notify attendees")                 page.add(" ")                 if is_request:                     page.input(name="discard", type="submit", value="Discard event")                 else:                     page.input(name="cancel", type="submit", value="Cancel event")                 page.add(" ")                 page.input(name="ignore", type="submit", value="Do nothing for now")                 page.p.close()             else:                 page.p()                 page.input(name="save", type="submit", value="Save event")                 page.add(" ")                 page.input(name="discard", type="submit", value="Discard event")                 page.add(" ")                 page.input(name="ignore", type="submit", value="Do nothing for now")                 page.p.close()      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")          page.input(name="editing", type="hidden", value="true")          args = self.env.get_args()          # Obtain the user's timezone.          tzid = self.get_tzid()          # Obtain basic event information, showing any necessary editing controls.          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user         initial_load = not args.has_key("editing")          existing_attendees = uri_values(obj.get_values("ATTENDEE") or [])         attendees = is_organiser and self.handle_attendees(obj) or \             (initial_load or not is_organiser) and existing_attendees or []          (dtstart, dtstart_attr), (dtend, dtend_attr) = self.get_event_period(obj)         self.show_object_datetime_controls(dtstart, dtend)          # 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, label in self.property_items:             field = name.lower()              items = obj.get_items(name) or []             rowspan = len(items)              if name == "ATTENDEE":                 rowspan = len(attendees) + 1 # for the add button             elif not items:                 continue              page.tr()             page.th(label, class_="objectheading %s%s" % (field, error and field in error and " error" or ""), rowspan=rowspan)              # Handle datetimes specially.              if name in ["DTSTART", "DTEND"]:                  # Obtain the datetime.                  if name == "DTSTART":                     dt, attr = dtstart, dtstart_attr                  # 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 = dtend or dtstart, dtend_attr or dtstart_attr                  self.show_datetime_controls(obj, dt, attr, name == "DTSTART")                  page.tr.close()              # Handle the summary specially.              elif name == "SUMMARY":                 value = args.get("summary", [obj.get_value(name)])[0]                  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 attendees specially.              elif name == "ATTENDEE":                 attendee_map = dict(items)                 first = True                  for i, value in enumerate(attendees):                     if not first:                         page.tr()                     else:                         first = False                      page.td(class_="objectvalue")                      # Obtain details of existing attendees.                      attr = attendee_map.get(value)                     partstat = attr and attr.get("PARTSTAT")                      # Show a form control as organiser for new attendees.                      if is_organiser and not partstat:                         page.input(name="attendee", type="value", value=value, size="40")                     else:                         page.input(name="attendee", type="hidden", value=value)                         page.add(value)                     page.add(" ")                      # Show participation status, editable for the current user.                      if value == self.user:                         self._show_menu("partstat", partstat, self.partstat_items, "partstat")                      # Allow the participation indicator to act as a submit                     # button in order to refresh the page and show a control for                     # the current user, if indicated.                      elif is_organiser:                         page.input(name="partstat-refresh", type="submit", value="refresh", id="partstat-%d" % i, class_="refresh")                         page.label(dict(self.partstat_items).get(partstat, ""), for_="partstat-%s" % i, class_="partstat")                     else:                         page.span(dict(self.partstat_items).get(partstat, ""), class_="partstat")                      # Permit organisers to remove attendees.                      if is_organiser:                          # Permit the removal of newly-added attendees.                          remove_type = (value in existing_attendees and value != self.user) and "checkbox" or "submit"                          self._control("remove", remove_type, value, value in args.get("remove", []), id="remove-%d" % i, class_="remove")                          page.label("Remove", for_="remove-%d" % i, class_="remove")                         page.label("Uninvited", for_="remove-%d" % i, class_="removed")                      page.td.close()                     page.tr.close()                  # Allow more attendees to be specified.                  if is_organiser:                     i = len(attendees)                      if not first:                         page.tr()                      page.td()                     page.input(name="add", type="submit", value="add", id="add-%d" % i, class_="add")                     page.label("Add attendee", for_="add-%d" % i, class_="add")                     page.td.close()                     page.tr.close()              # Handle potentially many values of other kinds.              else:                 first = True                  for i, (value, attr) in enumerate(items):                     if not first:                         page.tr()                     else:                         first = False                      page.td(class_="objectvalue")                     page.add(value)                     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         is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          # Obtain any parent object if this object is a specific recurrence.          uid = obj.get_value("UID")         recurrenceid = format_datetime(obj.get_utc_datetime("RECURRENCE-ID"))          if recurrenceid:             obj = self._get_object(uid)             if not obj:                 return              page.p("This event modifies a recurring event.")          # Obtain the periods associated with the event in the user's time zone.          periods = obj.get_periods(self.get_tzid(), self.get_window_end())         recurrenceids = self._get_recurrences(uid)          if len(periods) == 1:             return          if is_organiser:             page.p("This event recurs on the following occasions within the next %d days:" % self.get_window_size())         else:             page.p("This event occurs on the following occasions within the next %d days:" % self.get_window_size())          # Determine whether any periods are explicitly created or are part of a         # rule.          explicit_periods = filter(lambda p: p.origin != "RRULE", periods)          # Show each recurrence in a separate table if editable.          if is_organiser and explicit_periods:              for index, p in enumerate(periods[1:]):                  # Isolate the controls from neighbouring tables.                  page.div()                  self.show_object_datetime_controls(p.start, p.end, index)                  # NOTE: Need to customise the TH classes according to errors and                 # NOTE: index information.                  page.table(cellspacing=5, cellpadding=5, class_="recurrence")                 page.caption("Occurrence")                 page.tbody()                 page.tr()                 page.th("Start", class_="objectheading start")                 self.show_recurrence_controls(obj, index, p.start, p.end, p.origin, recurrenceid, recurrenceids, True)                 page.tr.close()                 page.tr()                 page.th("End", class_="objectheading end")                 self.show_recurrence_controls(obj, index, p.start, p.end, p.origin, recurrenceid, recurrenceids, False)                 page.tr.close()                 page.tbody.close()                 page.table.close()                  page.div.close()          # Otherwise, use a compact single table.          else:             page.table(cellspacing=5, cellpadding=5, class_="recurrence")             page.caption("Occurrences")             page.thead()             page.tr()             page.th("Start", class_="objectheading start")             page.th("End", class_="objectheading end")             page.tr.close()             page.thead.close()             page.tbody()              # Show only subsequent periods if organiser, since the principal             # period will be the start and end datetimes.              for index, p in enumerate(is_organiser and periods[1:] or periods):                 page.tr()                 self.show_recurrence_controls(obj, index, p.start, p.end, p.origin, recurrenceid, recurrenceids, True)                 self.show_recurrence_controls(obj, index, p.start, p.end, p.origin, recurrenceid, recurrenceids, False)                 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()         periods = obj.get_periods_for_freebusy(self.get_tzid(), self.get_window_end())          # 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 = list([p for p in have_conflict(freebusy, periods, True) if p.uid != uid])             conflicts.sort()              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 p in conflicts:                      # Provide details of any conflicting event.                      start = self.format_datetime(to_timezone(get_datetime(p.start), tzid), "long")                     end = self.format_datetime(to_timezone(get_datetime(p.end), tzid), "long")                      page.tr()                      # Show the event summary for the conflicting event.                      page.td()                     page.a(p.summary, href=self.link_to(p.uid))                     page.td.close()                      page.td(start)                     page.td(end)                      page.tr.close()                  page.tbody.close()                 page.table.close()      # Generation of controls within page fragments.      def show_object_datetime_controls(self, start, end, index=None):          """         Show datetime-related controls if already active or if an object needs         them for the given 'start' to 'end' period. The given 'index' is used to         parameterise individual controls for dynamic manipulation.         """          page = self.page         args = self.env.get_args()         sn = self._suffixed_name         ssn = self._simple_suffixed_name          # Add a dynamic stylesheet to permit the controls to modify the display.         # NOTE: The style details need to be coordinated with the static         # NOTE: stylesheet.          if index is not None:             page.style(type="text/css")              # Unlike the rules for object properties, these affect recurrence             # properties.              page.add("""\ input#dttimes-enable-%(index)d, input#dtend-enable-%(index)d, input#dttimes-enable-%(index)d:not(:checked) ~ .recurrence td.objectvalue .time.enabled, input#dttimes-enable-%(index)d:checked ~ .recurrence td.objectvalue .time.disabled, input#dtend-enable-%(index)d:not(:checked) ~ .recurrence td.objectvalue.dtend .dt.enabled, input#dtend-enable-%(index)d:checked ~ .recurrence td.objectvalue.dtend .dt.disabled {     display: none; }""" % {"index" : index})              page.style.close()          dtend_control = args.get(ssn("dtend-control", "recur", index), [])         dttimes_control = args.get(ssn("dttimes-control", "recur", index), [])          dtend_enabled = index is not None and str(index) in dtend_control or index is None and dtend_control         dttimes_enabled = index is not None and str(index) in dttimes_control or index is None and dttimes_control          initial_load = not args.has_key("editing")          dtend_enabled = dtend_enabled or initial_load and (isinstance(end, datetime) or start != end - timedelta(1))         dttimes_enabled = dttimes_enabled or initial_load and (isinstance(start, datetime) or isinstance(end, datetime))          self._control(             ssn("dtend-control", "recur", index), "checkbox",             index is not None and str(index) or "enable", dtend_enabled,             id=sn("dtend-enable", index)             )          self._control(             ssn("dttimes-control", "recur", index), "checkbox",             index is not None and str(index) or "enable", dttimes_enabled,             id=sn("dttimes-enable", index)             )      def show_datetime_controls(self, obj, dt, attr, show_start):          """         Show datetime details from the given 'obj' for the datetime 'dt' and         attributes 'attr', showing start details if 'show_start' is set         to a true value. Details will appear as controls for organisers and         labels for attendees.         """          page = self.page         is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          # Change end dates to refer to the actual dates, not the iCalendar         # "next day" dates.          if not show_start and not isinstance(dt, datetime):             dt -= timedelta(1)          # Show controls for editing as organiser.          if is_organiser:             page.td(class_="objectvalue dt%s" % (show_start and "start" or "end"))              if show_start:                 page.div(class_="dt enabled")                 self._show_date_controls("dtstart", dt, attr.get("TZID"))                 page.br()                 page.label("Specify times", for_="dttimes-enable", class_="time disabled enable")                 page.label("Specify dates only", for_="dttimes-enable", class_="time enabled disable")                 page.div.close()              else:                 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("dtend", dt, attr.get("TZID"))                 page.br()                 page.label("End on same day", for_="dtend-enable", class_="disable")                 page.div.close()              page.td.close()          # Show a label as attendee.          else:             page.td(self.format_datetime(dt, "full"))      def show_recurrence_controls(self, obj, index, start, end, origin, recurrenceid, recurrenceids, show_start):          """         Show datetime details from the given 'obj' for the recurrence having the         given 'index', with the recurrence period described by the datetimes         'start' and 'end', indicating the 'origin' of the period from the event         details, employing any 'recurrenceid' and 'recurrenceids' for the object         to configure the displayed information.          If 'show_start' is set to a true value, the start details will be shown;         otherwise, the end details will be shown.         """          page = self.page         sn = self._suffixed_name         ssn = self._simple_suffixed_name          is_organiser = get_uri(obj.get_value("ORGANIZER")) == self.user          # Change end dates to refer to the actual dates, not the iCalendar         # "next day" dates.          if not isinstance(end, datetime):             end -= timedelta(1)          start_utc = format_datetime(to_timezone(start, "UTC"))         replaced = recurrenceids and start_utc in recurrenceids and "replaced" or ""         css = " ".join([             replaced,             recurrenceid and start_utc == recurrenceid and "affected" or ""             ])          # Show controls for editing as organiser.          if is_organiser and not replaced and origin != "RRULE":             page.td(class_="objectvalue dt%s" % (show_start and "start" or "end"))              if show_start:                 page.div(class_="dt enabled")                 self._show_date_controls(ssn("dtstart", "recur", index), start, index=index)                 page.br()                 page.label("Specify times", for_=sn("dttimes-enable", index), class_="time disabled enable")                 page.label("Specify dates only", for_=sn("dttimes-enable", index), class_="time enabled disable")                 page.div.close()              else:                 page.div(class_="dt disabled")                 page.label("Specify end date", for_=sn("dtend-enable", index), class_="enable")                 page.div.close()                 page.div(class_="dt enabled")                 self._show_date_controls(ssn("dtend", "recur", index), end, index=index, show_tzid=False)                 page.br()                 page.label("End on same day", for_=sn("dtend-enable", index), class_="disable")                 page.div.close()              page.td.close()          # Show label as attendee.          else:             page.td(self.format_datetime(show_start and start or end, "long"), class_=css)      # Full page output methods.      def show(self, path_info):          "Show an object request using the given 'path_info' for the current user."          uid, recurrenceid = self._get_identifiers(path_info)         obj = self._get_object(uid, recurrenceid)          if not obj:             return False          error = self.handle_request(uid, recurrenceid, obj)          if not error:             return True          self.new_page(title="Event")         self.show_object_on_page(uid, obj, error)          return True      # Utility methods.      def _control(self, name, type, value, selected, **kw):          """         Show a control with the given 'name', 'type' and 'value', with         'selected' indicating whether it should be selected (checked or         equivalent), and with keyword arguments setting other properties.         """          page = self.page         if selected:             page.input(name=name, type=type, value=value, checked=selected, **kw)         else:             page.input(name=name, type=type, value=value, **kw)      def _show_menu(self, name, default, items, class_="", index=None):          """         Show a select menu having the given 'name', set to the given 'default',         providing the given (value, label) 'items', and employing the given CSS         'class_' if specified.         """          page = self.page         values = self.env.get_args().get(name, [default])         if index is not None:             values = values[index:]             values = values and values[0:1] or [default]          page.select(name=name, class_=class_)         for v, label in items:             if v is None:                 continue             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, tzid=None, index=None, show_tzid=True):          """         Show date controls for a field with the given 'name' and 'default' value         and 'tzid'. If 'index' is specified, default field values will be         overridden by the element from a collection of existing form values with         the specified index; otherwise, field values will be overridden by a         single form value.          If 'show_tzid' is set to a false value, the time zone menu will not be         provided.         """          page = self.page         args = self.env.get_args()          # Show dates for up to one week around the current date.          base = to_date(default)         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, index=index)          # Show time details.          default_time = isinstance(default, datetime) and default or None          hour = args.get("%s-hour" % name, [])[index or 0:]         hour = hour and hour[0] or "%02d" % (default_time and default_time.hour or 0)         minute = args.get("%s-minute" % name, [])[index or 0:]         minute = minute and minute[0] or "%02d" % (default_time and default_time.minute or 0)         second = args.get("%s-second" % name, [])[index or 0:]         second = second and second[0] or "%02d" % (default_time and default_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)         if show_tzid:             tzid = tzid or self.get_tzid()             page.add(" ")             self._show_timezone_menu("%s-tzid" % name, tzid, index)         page.span.close()      def _show_timezone_menu(self, name, default, index=None):          """         Show timezone controls using a menu with the given 'name', set to the         given 'default' unless a field of the given 'name' provides a value.         """          entries = [(tzid, tzid) for tzid in pytz.all_timezones]         self._show_menu(name, default, entries, index=index)  # vim: tabstop=4 expandtab shiftwidth=4