#!/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 imiptools.data import get_uri, uri_dict, uri_items, uri_values from imiptools.dates import to_timezone from imiptools.mail import Messenger from imiptools.period import have_conflict from imipweb.data import EventPeriod, event_period_from_period, FormPeriod, PeriodError from imipweb.client import ManagerClient from imipweb.resource import DateTimeFormUtilities, FormUtilities, ResourceClientForObject  class EventPageFragment(ResourceClientForObject, DateTimeFormUtilities, FormUtilities):      "A resource presenting the details of an event."      def __init__(self, resource=None):         ResourceClientForObject.__init__(self, resource)      # 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"),         ]      def is_organiser(self):         return get_uri(self.obj.get_value("ORGANIZER")) == self.user      def can_remove_attendee(self, attendee):          """         Return whether 'attendee' can be removed from the current object without         notification.         """          return self.can_edit_attendee(attendee) or attendee == self.user      def can_edit_attendee(self, attendee):          "Return whether 'attendee' can be edited by an organiser."          return self.attendee_is_new(attendee) or not self.obj.is_shared()      def attendee_is_new(self, attendee):          "Return whether 'attendee' is new to the current object."          return attendee not in self.get_stored_attendees()      # Access to stored object information.      def get_stored_attendees(self):         return uri_values(self.obj.get_values("ATTENDEE") or [])      def get_stored_main_period(self):          "Return the main event period for the current object."          (dtstart, dtstart_attr), (dtend, dtend_attr) = self.obj.get_main_period_items(self.get_tzid())         return EventPeriod(dtstart, dtend, self.get_tzid(), None, dtstart_attr, dtend_attr)      def get_stored_recurrences(self):          "Return recurrences computed using the current object."          recurrences = []         for period in self.get_periods(self.obj):             if period.origin != "DTSTART":                 recurrences.append(period)         return recurrences      # Access to current object information.      def get_current_main_period(self):         return self.get_stored_main_period()      def get_current_recurrences(self):         return self.get_stored_recurrences()      def get_current_attendees(self):         return self.get_stored_attendees()      # Page fragment methods.      def show_request_controls(self):          "Show form controls for a request."          page = self.page         args = self.env.get_args()          attendees = self.get_current_attendees()         is_attendee = self.user in attendees         is_request = self._have_request(self.uid, self.recurrenceid)          # Show appropriate options depending on the role of the user.          if is_attendee and not self.is_organiser():             page.p("An action is required for this request:")              page.p()             self.control("reply", "submit", "Send reply")             page.add(" ")             self.control("discard", "submit", "Discard event")             page.add(" ")             self.control("ignore", "submit", "Do nothing for now")             page.p.close()          if self.is_organiser():             page.p("As organiser, you can perform the following:")              page.p()             self.control("create", "submit", not self.obj.is_shared() and "Create event" or "Update event")             page.add(" ")              if self.obj.is_shared() and not is_request:                 self.control("cancel", "submit", "Cancel event")             else:                 self.control("discard", "submit", "Discard event")              page.add(" ")             self.control("save", "submit", "Save without sending")             page.p.close()      def show_object_on_page(self, errors=None):          """         Show the calendar object on the current page. If 'errors' is given, show         a suitable message for the different errors provided.         """          page = self.page         page.form(method="POST")          # Add a hidden control to help determine whether editing has already begun.          self.control("editing", "hidden", "true")          args = self.env.get_args()          # Obtain basic event information, generating any necessary editing controls.          attendees = self.update_current_attendees()         period = self.get_current_main_period()         self.show_object_datetime_controls(period)          # Obtain any separate recurrences for this event.          recurrenceids = self._get_active_recurrences(self.uid)         replaced = not self.recurrenceid and period.is_replaced(recurrenceids)          # 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 = uri_items(self.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, errors and field in errors and " error" or ""), rowspan=rowspan)              # Handle datetimes specially.              if name in ["DTSTART", "DTEND"]:                 if not replaced:                      # Obtain the datetime.                      is_start = name == "DTSTART"                      # Where no end datetime exists, use the start datetime as the                     # basis of any potential datetime specified if dt-control is                     # set.                      self.show_datetime_controls(is_start and period.get_form_start() or period.get_form_end(), is_start)                  elif name == "DTSTART":                     page.td(class_="objectvalue %s replaced" % field, rowspan=2)                     page.a("First occurrence replaced by a separate event", href=self.link_to(self.uid, replaced))                     page.td.close()                  page.tr.close()              # Handle the summary specially.              elif name == "SUMMARY":                 value = args.get("summary", [self.obj.get_value(name)])[0]                  page.td(class_="objectvalue summary")                 if self.is_organiser():                     self.control("summary", "text", 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                      # Obtain details of attendees to supply attributes.                      self.show_attendee(i, value, attendee_map.get(value))                     page.tr.close()                  # Allow more attendees to be specified.                  if self.is_organiser():                     if not first:                         page.tr()                      page.td()                     self.control("add", "submit", "add", id="add", class_="add")                     page.label("Add attendee", for_="add", 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 %s" % field)                     page.add(value)                     page.td.close()                     page.tr.close()          page.tbody.close()         page.table.close()          self.show_recurrences(errors)         self.show_conflicting_events()         self.show_request_controls()          page.form.close()      def show_attendee(self, i, attendee, attendee_attr):          """         For the current object, show the attendee in position 'i' with the given         'attendee' value, having 'attendee_attr' as any stored attributes.         """          page = self.page         args = self.env.get_args()          partstat = attendee_attr and attendee_attr.get("PARTSTAT")          page.td(class_="objectvalue")          # Show a form control as organiser for new attendees.          if self.is_organiser() and self.can_edit_attendee(attendee):             self.control("attendee", "value", attendee, size="40")         else:             self.control("attendee", "hidden", attendee)             page.add(attendee)         page.add(" ")          # Show participation status, editable for the current user.          if attendee == self.user:             self.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 self.is_organiser() and self.attendee_is_new(attendee):             self.control("partstat-refresh", "submit", "refresh", id="partstat-%d" % i, class_="refresh")             page.label(dict(self.partstat_items).get(partstat, ""), for_="partstat-%s" % i, class_="partstat")          # Otherwise, just show a label with the participation status.          else:             page.span(dict(self.partstat_items).get(partstat, ""), class_="partstat")          # Permit organisers to remove attendees.          if self.is_organiser():              # Permit the removal of newly-added attendees.              remove_type = self.can_remove_attendee(attendee) and "submit" or "checkbox"             self.control("remove", remove_type, str(i), str(i) in args.get("remove", []), id="remove-%d" % i, class_="remove")              page.label("Remove", for_="remove-%d" % i, class_="remove")             page.label(for_="remove-%d" % i, class_="removed")             page.add("(Uninvited)")             page.span("Re-invite", class_="action")             page.label.close()          page.td.close()      def show_recurrences(self, errors=None):          """         Show recurrences for the current object. If 'errors' is given, show a         suitable message for the different errors provided.         """          page = self.page          # Obtain any parent object if this object is a specific recurrence.          if self.recurrenceid:             parent = self.get_stored_object(self.uid, None)             if not parent:                 return              page.p()             page.a("This event modifies a recurring event.", href=self.link_to(self.uid))             page.p.close()          # Obtain the periods associated with the event.         # NOTE: Add a control to add recurrences here.          recurrences = self.get_current_recurrences()          if len(recurrences) < 1:             return          recurrenceids = self._get_recurrences(self.uid)          page.p("This event occurs on the following occasions within the next %d days:" % self.get_window_size())          # Show each recurrence in a separate table if editable.          if self.is_organiser() and recurrences:              for index, period in enumerate(recurrences):                 self.show_recurrence(index, period, self.recurrenceid, recurrenceids, errors)          # 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()              for index, period in enumerate(recurrences):                 page.tr()                 self.show_recurrence_label(period, self.recurrenceid, recurrenceids, True)                 self.show_recurrence_label(period, self.recurrenceid, recurrenceids, False)                 page.tr.close()              page.tbody.close()             page.table.close()      def show_recurrence(self, index, period, recurrenceid, recurrenceids, errors=None):          """         Show recurrence controls for a recurrence provided by the current object         with the given 'index' position in the list of periods, the given         'period' details, where a 'recurrenceid' indicates any specific         recurrence, and where 'recurrenceids' indicates all known additional         recurrences for the object.          If 'errors' is given, show a suitable message for the different errors         provided.         """          page = self.page         args = self.env.get_args()          p = event_period_from_period(period)         replaced = not recurrenceid and p.is_replaced(recurrenceids)          # Isolate the controls from neighbouring tables.          page.div()          self.show_object_datetime_controls(period, index)          page.table(cellspacing=5, cellpadding=5, class_="recurrence")         page.caption(period.origin == "RRULE" and "Occurrence from rule" or "Occurrence")         page.tbody()          page.tr()         error = errors and ("dtstart", index) in errors and " error" or ""         page.th("Start", class_="objectheading start%s" % error)         self.show_recurrence_controls(index, period, recurrenceid, recurrenceids, True)         page.tr.close()         page.tr()         error = errors and ("dtend", index) in errors and " error" or ""         page.th("End", class_="objectheading end%s" % error)         self.show_recurrence_controls(index, period, recurrenceid, recurrenceids, False)         page.tr.close()          # Permit the removal of recurrences.          if not replaced:             page.tr()             page.th("")             page.td()              remove_type = not self.obj.is_shared() or not period.origin and "submit" or "checkbox"             self.control("recur-remove", remove_type, str(index),                 str(index) in args.get("recur-remove", []),                 id="recur-remove-%d" % index, class_="remove")              page.label("Remove", for_="recur-remove-%d" % index, class_="remove")             page.label(for_="recur-remove-%d" % index, class_="removed")             page.add("(Removed)")             page.span("Re-add", class_="action")             page.label.close()              page.td.close()             page.tr.close()          page.tbody.close()         page.table.close()          page.div.close()      def show_conflicting_events(self):          "Show conflicting events for the current object."          page = self.page         recurrenceids = self._get_active_recurrences(self.uid)          # Obtain the user's timezone.          tzid = self.get_tzid()         periods = self.get_periods(self.obj)          # Indicate whether there are conflicting events.          conflicts = []         attendee_map = uri_dict(self.obj.get_value_map("ATTENDEE"))          for participant in self.get_current_attendees():             if participant == self.user:                 freebusy = self.store.get_freebusy(participant)             else:                 freebusy = self.store.get_freebusy_for_other(self.user, participant)              if not freebusy:                 continue              # Obtain any time zone details from the suggested event.              _dtstart, attr = self.obj.get_item("DTSTART")             tzid = attr.get("TZID", tzid)              # Show any conflicts with periods of actual attendance.              participant_attr = attendee_map.get(participant)             partstat = participant_attr and participant_attr.get("PARTSTAT")             recurrences = self.obj.get_recurrence_start_points(recurrenceids, tzid)              for p in have_conflict(freebusy, periods, True):                 if not self.recurrenceid and p.is_replaced(recurrences):                     continue                  if ( # Unidentified or different event                      (p.uid != self.uid or self.recurrenceid and p.recurrenceid and p.recurrenceid != self.recurrenceid) and                      # Different period or unclear participation with the same period                      (p not in periods or not partstat in ("ACCEPTED", "TENTATIVE")) and                      # Participant not limited to organising                      p.transp != "ORG"                    ):                      conflicts.append(p)          conflicts.sort()          # Show any conflicts with periods of actual attendance.          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(p.get_start(), tzid), "long")                 end = self.format_datetime(to_timezone(p.get_end(), tzid), "long")                  page.tr()                  # Show the event summary for the conflicting event.                  page.td()                 if p.summary:                     page.a(p.summary, href=self.link_to(p.uid, p.recurrenceid))                 else:                     page.add("(Unspecified event)")                 page.td.close()                  page.td(start)                 page.td(end)                  page.tr.close()              page.tbody.close()             page.table.close()  class EventPage(EventPageFragment):      "A request handler for the event page."      def __init__(self, resource=None, messenger=None):         ResourceClientForObject.__init__(self, resource)         self.messenger = messenger or Messenger()      # Request logic methods.      def is_initial_load(self):          "Return whether the event is being loaded and shown for the first time."          return not self.env.get_args().has_key("editing")      def handle_request(self):          """         Handle actions involving the current 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")         create = args.has_key("create")         cancel = args.has_key("cancel")         ignore = args.has_key("ignore")         save = args.has_key("save")          have_action = reply or discard or create or cancel or ignore or save          if not have_action:             return ["action"]          # If ignoring the object, return to the calendar.          if ignore:             self.redirect(self.env.get_path())             return None          # Update the object.          single_user = False          if reply or create or cancel or save:              # Update principal event details if organiser.              if self.is_organiser():                  # Update time periods (main and recurring).                  try:                     period = self.handle_main_period()                 except PeriodError, exc:                     return exc.args                  try:                     periods = self.handle_recurrence_periods()                 except PeriodError, exc:                     return exc.args                  # Set the periods in the object, first obtaining removed and                 # modified period information.                  to_unschedule = self.get_removed_periods()                  self.obj.set_period(period)                 self.obj.set_periods(periods)                  # Update summary.                  if args.has_key("summary"):                     self.obj["SUMMARY"] = [(args["summary"][0], {})]                  # Obtain any participants and those to be removed.                  attendees = self.get_attendees_from_page()                 removed = [attendees[int(i)] for i in args.get("remove", [])]                 to_cancel = self.update_attendees(self.obj, attendees, removed)                 single_user = not attendees or attendees == [self.user]              # Update attendee participation for the current user.              if args.has_key("partstat"):                 self.update_participation(self.obj, args["partstat"][0])          # Process any action.          invite = not save and create and not single_user         save = save or create and single_user          handled = True          if reply or invite or cancel:              client = ManagerClient(self.obj, self.user, self.messenger)              # Process the object and remove it from the list of requests.              if reply and client.process_received_request():                 self.remove_request(self.uid, self.recurrenceid)              elif self.is_organiser() and (invite or cancel):                  # Invitation, uninvitation and unscheduling...                  if client.process_created_request(                     invite and "REQUEST" or "CANCEL", to_cancel, to_unschedule):                      self.remove_request(self.uid, self.recurrenceid)          # Save single user events.          elif save:             self.store.set_event(self.user, self.uid, self.recurrenceid, node=self.obj.to_node())             self.update_event_in_freebusy()             self.remove_request(self.uid, self.recurrenceid)          # Remove the request and the object.          elif discard:             self.remove_event_from_freebusy()             self.remove_event(self.uid, self.recurrenceid)             self.remove_request(self.uid, self.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_main_period(self):          "Return period details for the main start/end period in an event."          return self.get_main_period_from_page().as_event_period()      def handle_recurrence_periods(self):          "Return period details for the recurrences specified for an event."          return [p.as_event_period(i) for i, p in enumerate(self.get_recurrences_from_page())]      # Access to form-originating object information.      def get_main_period_from_page(self):          "Return the main period defined in the event form."          args = self.env.get_args()          dtend_enabled = args.get("dtend-control", [None])[0]         dttimes_enabled = args.get("dttimes-control", [None])[0]         start = self.get_date_control_values("dtstart")         end = self.get_date_control_values("dtend")          return FormPeriod(start, end, dtend_enabled, dttimes_enabled, self.get_tzid())      def get_recurrences_from_page(self):          "Return the recurrences defined in the event form."          args = self.env.get_args()          all_dtend_enabled = args.get("dtend-control-recur", [])         all_dttimes_enabled = args.get("dttimes-control-recur", [])         all_starts = self.get_date_control_values("dtstart-recur", multiple=True)         all_ends = self.get_date_control_values("dtend-recur", multiple=True, tzid_name="dtstart-recur")         all_origins = args.get("recur-origin", [])          periods = []          for index, (start, end, dtend_enabled, dttimes_enabled, origin) in \             enumerate(map(None, all_starts, all_ends, all_dtend_enabled, all_dttimes_enabled, all_origins)):              dtend_enabled = str(index) in all_dtend_enabled             dttimes_enabled = str(index) in all_dttimes_enabled             period = FormPeriod(start, end, dtend_enabled, dttimes_enabled, self.get_tzid(), origin)             periods.append(period)          return periods      def get_removed_periods(self):          "Return a list of recurrence periods to remove upon updating an event."          to_unschedule = []         args = self.env.get_args()         for i in args.get("recur-remove", []):             to_unschedule.append(periods[int(i)])         return to_unschedule      def get_attendees_from_page(self):          """         Return attendees from the request, normalised for iCalendar purposes,         and without duplicates.         """          args = self.env.get_args()          attendees = args.get("attendee", [])         unique_attendees = set()         ordered_attendees = []          for attendee in attendees:             if not attendee.strip():                 continue             attendee = get_uri(attendee)             if attendee not in unique_attendees:                 unique_attendees.add(attendee)                 ordered_attendees.append(attendee)          return ordered_attendees      def update_attendees_from_page(self):          "Add or remove attendees. This does not affect the stored object."          args = self.env.get_args()          attendees = self.get_attendees_from_page()          if args.has_key("add"):             attendees.append("")          # Only actually remove attendees if the event is unsent, if the attendee         # is new, or if it is the current user being removed.          if args.has_key("remove"):             still_to_remove = []              for i in args["remove"]:                 try:                     attendee = attendees[int(i)]                 except IndexError:                     continue                  if self.can_remove_attendee(attendee):                     attendees.remove(attendee)                 else:                     still_to_remove.append(i)              args["remove"] = still_to_remove          return attendees      # Access to current object information.      def get_current_main_period(self):          """         Return the currently active main period for the current object depending         on whether editing has begun or whether the object has just been loaded.         """          if self.is_initial_load() or not self.is_organiser():             return self.get_stored_main_period()         else:             return self.get_main_period_from_page()      def get_current_recurrences(self):          """         Return recurrences for the current object using the original object         details where no editing is in progress, using form data otherwise.         """          if self.is_initial_load() or not self.is_organiser():             return self.get_stored_recurrences()         else:             return self.get_recurrences_from_page()      def get_current_attendees(self):          """         Return attendees for the current object depending on whether the object         has been edited or instead provides such information from its stored         form.         """          if self.is_initial_load() or not self.is_organiser():             return self.get_stored_attendees()         else:             return self.get_attendees_from_page()      def update_current_attendees(self):          "Return an updated collection of attendees for the current object."          if self.is_initial_load() or not self.is_organiser():             return self.get_stored_attendees()         else:             return self.update_attendees_from_page()      # 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_stored_object(uid, recurrenceid)         self.set_object(obj)          if not obj:             return False          errors = self.handle_request()          if not errors:             return True          self.new_page(title="Event")         self.show_object_on_page(errors)          return True  # vim: tabstop=4 expandtab shiftwidth=4