#!/usr/bin/env python  """ A Web interface to an event 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/>. """  from datetime import datetime from imiptools.data import get_address, get_uri, uri_values from imiptools.dates import format_datetime, get_datetime, \                             get_datetime_item, get_end_of_day, get_start_of_day, \                             get_start_of_next_day, get_timestamp, ends_on_same_day, \                             to_timezone from imiptools.period import add_day_start_points, add_empty_days, add_slots, \                              get_scale, get_slots, get_spans, partition_by_day, Point from imipweb.resource import ResourceClient  class CalendarPage(ResourceClient):      "A request handler for the calendar page."      # Request logic methods.      def handle_newevent(self):          """         Handle any new event operation, creating a new event and redirecting to         the event page for further activity.         """          # Handle a submitted form.          args = self.env.get_args()          if not args.has_key("newevent"):             return          # Create a new event using the available information.          slots = args.get("slot", [])         participants = args.get("participants", [])         summary = args.get("summary", [None])[0]          if not slots:             return          # Obtain the user's timezone.          tzid = self.get_tzid()          # Coalesce the selected slots.          slots.sort()         coalesced = []         last = None          for slot in slots:             start, end = (slot.split("-", 1) + [None])[:2]             start = get_datetime(start, {"TZID" : tzid})             end = end and get_datetime(end, {"TZID" : tzid}) or get_start_of_next_day(start, tzid)              if last:                 last_start, last_end = last                  # Merge adjacent dates and datetimes.                  if start == last_end or \                     not isinstance(start, datetime) and \                     get_start_of_day(last_end, tzid) == get_start_of_day(start, tzid):                      last = last_start, end                     continue                  # Handle datetimes within dates.                 # Datetime periods are within single days and are therefore                 # discarded.                  elif not isinstance(last_start, datetime) and \                     get_start_of_day(start, tzid) == get_start_of_day(last_start, tzid):                      continue                  # Add separate dates and datetimes.                  else:                     coalesced.append(last)              last = start, end          if last:             coalesced.append(last)          # Invent a unique identifier.          utcnow = get_timestamp()         uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))          # Create a calendar object and store it as a request.          record = []         rwrite = record.append          # Define a single occurrence if only one coalesced slot exists.          start, end = coalesced[0]         start_value, start_attr = get_datetime_item(start, tzid)         end_value, end_attr = get_datetime_item(end, tzid)          rwrite(("UID", {}, uid))         rwrite(("SUMMARY", {}, summary or ("New event at %s" % utcnow)))         rwrite(("DTSTAMP", {}, utcnow))         rwrite(("DTSTART", start_attr, start_value))         rwrite(("DTEND", end_attr, end_value))         rwrite(("ORGANIZER", {}, self.user))          participants = uri_values(filter(None, participants))          for participant in participants:             rwrite(("ATTENDEE", {"RSVP" : "TRUE", "PARTSTAT" : "NEEDS-ACTION"}, participant))          if self.user not in participants:             rwrite(("ATTENDEE", {"PARTSTAT" : "ACCEPTED"}, self.user))          # Define additional occurrences if many slots are defined.          rdates = []          for start, end in coalesced[1:]:             start_value, start_attr = get_datetime_item(start, tzid)             end_value, end_attr = get_datetime_item(end, tzid)             rdates.append("%s/%s" % (start_value, end_value))          if rdates:             rwrite(("RDATE", {"VALUE" : "PERIOD", "TZID" : tzid}, rdates))          node = ("VEVENT", {}, record)          self.store.set_event(self.user, uid, None, node=node)         self.store.queue_request(self.user, uid)          # Redirect to the object (or the first of the objects), where instead of         # attendee controls, there will be organiser controls.          self.redirect(self.link_to(uid))      # Page fragment methods.      def show_requests_on_page(self):          "Show requests for the current user."          page = self.page          # NOTE: This list could be more informative, but it is envisaged that         # NOTE: the requests would be visited directly anyway.          requests = self._get_requests()          page.div(id="pending-requests")          if requests:             page.p("Pending requests:")              page.ul()              for uid, recurrenceid, request_type in requests:                 obj = self._get_object(uid, recurrenceid)                 if obj:                     page.li()                     page.a(obj.get_value("SUMMARY"), href="#request-%s-%s" % (uid, recurrenceid or ""))                     page.li.close()              page.ul.close()          else:             page.p("There are no pending requests.")          page.div.close()      def show_participants_on_page(self):          "Show participants for scheduling purposes."          page = self.page         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.          page.div(id="participants")          page.p("Participants for scheduling:")          for i, participant in enumerate(participants):             page.p()             page.input(name="participants", type="text", value=participant)             page.input(name="remove-participant-%d" % i, type="submit", value="Remove")             page.p.close()          page.p()         page.input(name="participants", type="text")         page.input(name="add-participant", type="submit", value="Add")         page.p.close()          page.div.close()          return participants      # Full page output methods.      def show(self):          "Show the calendar for the current user."          self.new_page(title="Calendar")         page = self.page          handled = self.handle_newevent()         freebusy = self.store.get_freebusy(self.user)          if not freebusy:             page.p("No events scheduled.")             return          # 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()          # Obtain the user's timezone.          tzid = self.get_tzid()          # Day view: start at the earliest known day and produce days until the         # latest known day, perhaps with expandable sections of empty days.          # Month view: start at the earliest known month and produce months until         # the latest known month, perhaps with expandable sections of empty         # months.          # Details of users to invite to new events could be superimposed on the         # calendar.          # Requests are listed and linked to their tentative positions in the         # calendar. Other participants are also shown.          request_summary = self._get_request_summary()          period_groups = [request_summary, freebusy]         period_group_types = ["request", "freebusy"]         period_group_sources = ["Pending requests", "Your schedule"]          for i, participant in enumerate(participants):             period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))             period_group_types.append("freebusy-part%d" % i)             period_group_sources.append(participant)          groups = []         group_columns = []         group_types = period_group_types         group_sources = period_group_sources         all_points = set()          # Obtain time point information for each group of periods.          for periods in period_groups:              # Get the time scale with start and end points.              scale = get_scale(periods, tzid)              # Get the time slots for the periods.             # Time slots are collections of Point objects with lists of active             # periods.              slots = get_slots(scale)              # Add start of day time points for multi-day periods.              add_day_start_points(slots, tzid)              # Record the slots and all time points employed.              groups.append(slots)             all_points.update([point for point, active in slots])          # Partition the groups into days.          days = {}         partitioned_groups = []         partitioned_group_types = []         partitioned_group_sources = []          for slots, group_type, group_source in zip(groups, group_types, group_sources):              # Propagate time points to all groups of time slots.              add_slots(slots, all_points)              # Count the number of columns employed by the group.              columns = 0              # Partition the time slots by day.              partitioned = {}              for day, day_slots in partition_by_day(slots).items():                  # Construct a list of time intervals within the day.                  intervals = []                  # Convert each partition to a mapping from points to active                 # periods.                  partitioned[day] = day_points = {}                  last = None                  for point, active in day_slots:                     columns = max(columns, len(active))                     day_points[point] = active                      if last:                         intervals.append((last, point))                      last = point                  if last:                     intervals.append((last, None))                  if not days.has_key(day):                     days[day] = set()                  # Record the divisions or intervals within each day.                  days[day].update(intervals)              # Only include the requests column if it provides objects.              if group_type != "request" or columns:                 group_columns.append(columns)                 partitioned_groups.append(partitioned)                 partitioned_group_types.append(group_type)                 partitioned_group_sources.append(group_source)          # Add empty days.          add_empty_days(days, tzid)          page.p("Select days or periods for a new event.")          # Show controls for hiding empty days and busy slots.         # The positioning of the control, paragraph and table are important here.          page.input(name="showdays", type="checkbox", value="show", id="showdays", accesskey="D")         page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy", accesskey="B")          page.p(class_="controls")         page.label("Hide busy time periods", for_="hidebusy", class_="hidebusy enable")         page.label("Show busy time periods", for_="hidebusy", class_="hidebusy disable")         page.label("Show empty days", for_="showdays", class_="showdays disable")         page.label("Hide empty days", for_="showdays", class_="showdays enable")         page.input(name="reset", type="submit", value="Clear selections", id="reset")         page.label("Clear selections", for_="reset", class_="reset newevent-with-periods")         page.p.close()          # Show the calendar itself.          self.show_calendar_days(days, partitioned_groups, partitioned_group_types, partitioned_group_sources, group_columns)          # End the form region.          page.form.close()      # More page fragment methods.      def show_calendar_day_controls(self, day):          "Show controls for the given 'day' in the calendar."          page = self.page         daystr, dayid = self._day_value_and_identifier(day)          # Generate a dynamic stylesheet to allow day selections to colour         # specific days.         # NOTE: The style details need to be coordinated with the static         # NOTE: stylesheet.          page.style(type="text/css")          page.add("""\ input.newevent.selector#%s:checked ~ table#region-%s label.day, input.newevent.selector#%s:checked ~ table#region-%s label.timepoint {     background-color: #5f4;     text-decoration: underline; } """ % (dayid, dayid, dayid, dayid))          page.style.close()          # Generate controls to select days.          slots = self.env.get_args().get("slot", [])         value, identifier = self._day_value_and_identifier(day)         self._slot_selector(value, identifier, slots)      def show_calendar_interval_controls(self, day, intervals):          "Show controls for the intervals provided by 'day' and 'intervals'."          page = self.page         daystr, dayid = self._day_value_and_identifier(day)          # Generate a dynamic stylesheet to allow day selections to colour         # specific days.         # NOTE: The style details need to be coordinated with the static         # NOTE: stylesheet.          l = []          for point, endpoint in intervals:             timestr, timeid = self._slot_value_and_identifier(point, endpoint)             l.append("""\ input.newevent.selector#%s:checked ~ table#region-%s th#region-%s""" % (timeid, dayid, timeid))          page.style(type="text/css")          page.add(",\n".join(l))         page.add(""" {     background-color: #5f4;     text-decoration: underline; } """)          page.style.close()          # Generate controls to select time periods.          slots = self.env.get_args().get("slot", [])         last = None          # Produce controls for the intervals/slots. Where instants in time are         # encountered, they are merged with the following slots, permitting the         # selection of contiguous time periods. However, the identifiers         # employed by controls corresponding to merged periods will encode the         # instant so that labels may reference them conveniently.          intervals = list(intervals)         intervals.sort()          for point, endpoint in intervals:              # Merge any previous slot with this one, producing a control.              if last:                 _value, identifier = self._slot_value_and_identifier(last, last)                 value, _identifier = self._slot_value_and_identifier(last, endpoint)                 self._slot_selector(value, identifier, slots)              # If representing an instant, hold the slot for merging.              if endpoint and point.point == endpoint.point:                 last = point              # If not representing an instant, produce a control.              else:                 value, identifier = self._slot_value_and_identifier(point, endpoint)                 self._slot_selector(value, identifier, slots)                 last = None          # Produce a control for any unmerged slot.          if last:             _value, identifier = self._slot_value_and_identifier(last, last)             value, _identifier = self._slot_value_and_identifier(last, endpoint)             self._slot_selector(value, identifier, slots)      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,         partitioned_group_sources, 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,         the 'partitioned_group_sources' indicating the origin of each group, and         the 'group_columns' defining the number of columns in each group.         """          page = self.page          # Determine the number of columns required. Where participants provide         # no columns for events, one still needs to be provided for the         # participant itself.          all_columns = sum([max(columns, 1) for columns in group_columns])          # Determine the days providing time slots.          all_days = days.items()         all_days.sort()          # Produce a heading and time points for each day.          for day, intervals in all_days:             groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]             is_empty = True              for slots in groups_for_day:                 if not slots:                     continue                  for active in slots.values():                     if active:                         is_empty = False                         break              daystr, dayid = self._day_value_and_identifier(day)              # Put calendar tables within elements for quicker CSS selection.              page.div(class_="calendar")              # Show the controls permitting day selection as well as the controls             # configuring the new event display.              self.show_calendar_day_controls(day)             self.show_calendar_interval_controls(day, intervals)              # Show an actual table containing the day information.              page.table(cellspacing=5, cellpadding=5, class_="calendar %s" % (is_empty and " empty" or ""), id="region-%s" % dayid)              page.caption(class_="dayheading container separator")             self._day_heading(day)             page.caption.close()              self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)              page.tbody(class_="points")             self.show_calendar_points(intervals, groups_for_day, partitioned_group_types, group_columns)             page.tbody.close()              page.table.close()              # Show a button for scheduling a new event.              page.p(class_="newevent-with-periods")             page.label("Summary:")             page.input(name="summary", type="text")             page.input(name="newevent", type="submit", value="New event", accesskey="N")             page.p.close()              page.div.close()      def show_calendar_points(self, intervals, groups, group_types, group_columns):          """         Show the time 'intervals' along with period information from the given         'groups', having the indicated 'group_types', each with the number of         columns given by 'group_columns'.         """          page = self.page          # Obtain the user's timezone.          tzid = self.get_tzid()          # Produce a row for each interval.          intervals = list(intervals)         intervals.sort()          for point, endpoint in intervals:             continuation = point.point == get_start_of_day(point.point, tzid)              # Some rows contain no period details and are marked as such.              have_active = False             have_active_request = False              for slots, group_type in zip(groups, group_types):                 if slots and slots.get(point):                     if group_type == "request":                         have_active_request = True                     else:                         have_active = True              # Emit properties of the time interval, where post-instant intervals             # are also treated as busy.              css = " ".join([                 "slot",                 (have_active or point.indicator == Point.REPEATED) and "busy" or \                     have_active_request and "suggested" or "empty",                 continuation and "daystart" or ""                 ])              page.tr(class_=css)              # Produce a time interval heading, spanning two rows if this point             # represents an instant.              if point.indicator == Point.PRINCIPAL:                 timestr, timeid = self._slot_value_and_identifier(point, endpoint)                 page.th(class_="timeslot", id="region-%s" % timeid,                     rowspan=(endpoint and point.point == endpoint.point and 2 or 1))                 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:                     self._empty_slot(point, endpoint, max(columns, 1))                     continue                  slots = slots.items()                 slots.sort()                 spans = get_spans(slots)                  empty = 0                  # Show a column for each active period.                  for p in active:                      # The period can be None, meaning an empty column.                      if p:                          # Flush empty slots preceding this one.                          if empty:                             self._empty_slot(point, endpoint, empty)                             empty = 0                          key = p.get_key()                         span = spans[key]                          # Produce a table cell only at the start of the period                         # or when continued at the start of a day.                         # Points defining the ends of instant events should                         # never define the start of new events.                          if point.indicator == Point.PRINCIPAL and (point.point == p.get_start() or continuation):                              has_continued = continuation and point.point != p.get_start()                             will_continue = not ends_on_same_day(point.point, p.get_end(), tzid)                             is_organiser = p.organiser == self.user                              css = " ".join([                                 "event",                                 has_continued and "continued" or "",                                 will_continue and "continues" or "",                                 p.transp == "ORG" and "only-organising" or is_organiser and "organising" or "attending",                                 self._have_request(p.uid, p.recurrenceid, "COUNTER", True) and "counter" or "",                                 ])                              # Only anchor the first cell of events.                             # Need to only anchor the first period for a recurring                             # event.                              html_id = "%s-%s-%s" % (group_type, p.uid, p.recurrenceid or "")                              if point.point == p.get_start() and html_id not in self.html_ids:                                 page.td(class_=css, rowspan=span, id=html_id)                                 self.html_ids.add(html_id)                             else:                                 page.td(class_=css, rowspan=span)                              # Only link to events if they are not being updated                             # by requests.                              if not p.summary or \                                 group_type != "request" and self._have_request(p.uid, p.recurrenceid, None, True):                                  page.span(p.summary or "(Participant is busy)")                              # Link to requests and events (including ones for                             # which counter-proposals exist).                              else:                                 page.a(p.summary, href=self.link_to(p.uid, p.recurrenceid))                              page.td.close()                     else:                         empty += 1                  # Pad with empty columns.                  empty = columns - len(active)                  if empty:                     self._empty_slot(point, endpoint, empty)              page.tr.close()      def _day_heading(self, day):          """         Generate a heading for 'day' of the following form:          <label class="day" for="day-20150203">Tuesday, 3 February 2015</label>         """          page = self.page         value, identifier = self._day_value_and_identifier(day)         page.label(self.format_date(day, "full"), class_="day", for_=identifier)      def _time_point(self, point, endpoint):          """         Generate headings for the 'point' to 'endpoint' period of the following         form:          <label class="timepoint" for="slot-20150203T090000-20150203T100000">09:00:00 CET</label>         <span class="endpoint">10:00:00 CET</span>         """          page = self.page         tzid = self.get_tzid()         value, identifier = self._slot_value_and_identifier(point, endpoint)         page.label(self.format_time(point.point, "long"), class_="timepoint", for_=identifier)         page.span(self.format_time(endpoint and endpoint.point or get_end_of_day(point.point, tzid), "long"), class_="endpoint")      def _slot_selector(self, value, identifier, slots):          """         Provide a timeslot control having the given 'value', employing the         indicated HTML 'identifier', and using the given 'slots' collection         to select any control whose 'value' is in this collection, unless the         "reset" request parameter has been asserted.         """          reset = self.env.get_args().has_key("reset")         page = self.page         if not reset and value in slots:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector", checked="checked")         else:             page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector")      def _empty_slot(self, point, endpoint, colspan):          """         Show an empty slot cell for the given 'point' and 'endpoint', with the         given 'colspan' configuring the cell's appearance.         """          page = self.page         page.td(class_="empty%s" % (point.indicator == Point.PRINCIPAL and " container" or ""), colspan=colspan)         if point.indicator == Point.PRINCIPAL:             value, identifier = self._slot_value_and_identifier(point, endpoint)             page.label("Select/deselect period", class_="newevent popup", for_=identifier)         page.td.close()      def _day_value_and_identifier(self, day):          "Return a day value and HTML identifier for the given 'day'."          value = format_datetime(day)         identifier = "day-%s" % value         return value, identifier      def _slot_value_and_identifier(self, point, endpoint):          """         Return a slot value and HTML identifier for the given 'point' and         'endpoint'.         """          value = "%s-%s" % (format_datetime(point.point), endpoint and format_datetime(endpoint.point) or "")         identifier = "slot-%s" % value         return value, identifier  # vim: tabstop=4 expandtab shiftwidth=4