#!/usr/bin/env python  """ A Web interface to a user's calendar.  Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  # Edit this path to refer to the location of the imiptools libraries, if # necessary.  LIBRARY_PATH = "/var/lib/imip-agent"  import babel.dates import cgi, os, sys  sys.path.append(LIBRARY_PATH)  from imiptools.content import Handler, get_address, \                               get_item, get_uri, get_utc_datetime, get_value, \                               get_value_map, get_values, parse_object, to_part from imiptools.dates import format_datetime, get_datetime, get_start_of_day, \                             to_timezone from imiptools.mail import Messenger from imiptools.period import add_day_start_points, add_slots, convert_periods, \                              get_freebusy_details, \                              get_scale, have_conflict, get_slots, get_spans, \                              partition_by_day from imiptools.profile import Preferences from vCalendar import to_node import markup import imip_store  getenv = os.environ.get setenv = os.environ.__setitem__  class CGIEnvironment:      "A CGI-compatible environment."      def __init__(self):         self.args = None         self.method = None         self.path = None         self.path_info = None         self.user = None      def get_args(self):         if self.args is None:             if self.get_method() != "POST":                 setenv("QUERY_STRING", "")             self.args = cgi.parse(keep_blank_values=True)         return self.args      def get_method(self):         if self.method is None:             self.method = getenv("REQUEST_METHOD") or "GET"         return self.method      def get_path(self):         if self.path is None:             self.path = getenv("SCRIPT_NAME") or ""         return self.path      def get_path_info(self):         if self.path_info is None:             self.path_info = getenv("PATH_INFO") or ""         return self.path_info      def get_user(self):         if self.user is None:             self.user = getenv("REMOTE_USER") or ""         return self.user      def get_output(self):         return sys.stdout      def get_url(self):         path = self.get_path()         path_info = self.get_path_info()         return "%s%s" % (path.rstrip("/"), path_info)      def new_url(self, path_info):         path = self.get_path()         return "%s/%s" % (path.rstrip("/"), path_info.lstrip("/"))  class ManagerHandler(Handler):      """     A content handler for use by the manager, as opposed to operating within the     mail processing pipeline.     """      def __init__(self, obj, user, messenger):         details, details_attr = obj.values()[0]         Handler.__init__(self, details)         self.obj = obj         self.user = user         self.messenger = messenger          self.organisers = map(get_address, self.get_values("ORGANIZER"))      # Communication methods.      def send_message(self, sender):          """         Create a full calendar object and send it to the organisers, sending a         copy to the 'sender'.         """          node = to_node(self.obj)         part = to_part("REPLY", [node])         message = self.messenger.make_outgoing_message([part], self.organisers, outgoing_bcc=sender)         self.messenger.sendmail(self.organisers, message.as_string(), outgoing_bcc=sender)      # Action methods.      def process_request(self, accept, update=False):          """         Process the current request for the given 'user', accepting any request         when 'accept' is true, declining requests otherwise. Return whether any         action was taken.          If 'update' is given, the sequence number will be incremented in order         to override any previous response.         """          # When accepting or declining, do so only on behalf of this user,         # preserving any other attributes set as an attendee.          for attendee, attendee_attr in self.get_items("ATTENDEE"):              if attendee == self.user:                 freebusy = self.store.get_freebusy(attendee)                  attendee_attr["PARTSTAT"] = accept and "ACCEPTED" or "DECLINED"                 if self.messenger and self.messenger.sender != get_address(attendee):                     attendee_attr["SENT-BY"] = get_uri(self.messenger.sender)                 self.details["ATTENDEE"] = [(attendee, attendee_attr)]                 if update:                     sequence = self.get_value("SEQUENCE") or "0"                     self.details["SEQUENCE"] = [(str(int(sequence) + 1), {})]                 self.update_dtstamp()                  self.send_message(get_address(attendee))                  return True          return False  class Manager:      "A simple manager application."      def __init__(self, messenger=None):         self.messenger = messenger or Messenger()          self.env = CGIEnvironment()         user = self.env.get_user()         self.user = user and get_uri(user) or None         self.preferences = None         self.locale = None         self.requests = None          self.out = self.env.get_output()         self.page = markup.page()         self.encoding = "utf-8"          self.store = imip_store.FileStore()         self.objects = {}          try:             self.publisher = imip_store.FilePublisher()         except OSError:             self.publisher = None      def _get_uid(self, path_info):         return path_info.lstrip("/").split("/", 1)[0]      def _get_object(self, uid):         if self.objects.has_key(uid):             return self.objects[uid]          f = uid and self.store.get_event(self.user, uid) or None          if not f:             return None          self.objects[uid] = obj = parse_object(f, "utf-8")          if not obj:             return None          return obj      def _get_details(self, obj):         details, details_attr = obj.values()[0]         return details      def _get_requests(self):         if self.requests is None:             self.requests = self.store.get_requests(self.user)         return self.requests      def _get_request_summary(self):         summary = []         for uid in self._get_requests():             obj = self._get_object(uid)             if obj:                 details = self._get_details(obj)                 summary.append((                     get_value(details, "DTSTART"),                     get_value(details, "DTEND"),                     uid                     ))         return summary      # Preference methods.      def get_user_locale(self):         if not self.locale:             self.locale = self.get_preferences().get("LANG", "C")         return self.locale      def get_preferences(self):         if not self.preferences:             self.preferences = Preferences(self.user)         return self.preferences      # Prettyprinting of dates and times.      def format_date(self, dt, format):         return self._format_datetime(babel.dates.format_date, dt, format)      def format_time(self, dt, format):         return self._format_datetime(babel.dates.format_time, dt, format)      def format_datetime(self, dt, format):         return self._format_datetime(babel.dates.format_datetime, dt, format)      def _format_datetime(self, fn, dt, format):         return fn(dt, format=format, locale=self.get_user_locale())      # Data management methods.      def remove_request(self, uid):         return self.store.dequeue_request(self.user, uid)      # Presentation methods.      def new_page(self, title):         self.page.init(title=title, charset=self.encoding)      def status(self, code, message):         self.header("Status", "%s %s" % (code, message))      def header(self, header, value):         print >>self.out, "%s: %s" % (header, value)      def no_user(self):         self.status(403, "Forbidden")         self.new_page(title="Forbidden")         self.page.p("You are not logged in and thus cannot access scheduling requests.")      def no_page(self):         self.status(404, "Not Found")         self.new_page(title="Not Found")         self.page.p("No page is provided at the given address.")      def redirect(self, url):         self.status(302, "Redirect")         self.header("Location", url)         self.new_page(title="Redirect")         self.page.p("Redirecting to: %s" % url)      # Request logic and page fragment methods.      def handle_request(self, uid, request, queued):          """         Handle actions involving the given 'uid' and 'request' object, where         'queued' indicates that the object has not yet been handled.         """          # Handle a submitted form.          args = self.env.get_args()         handled = True          accept = args.has_key("accept")         decline = args.has_key("decline")         update = not queued and args.has_key("update")          if accept or decline:              handler = ManagerHandler(request, self.user, self.messenger)              if handler.process_request(accept, update):                  # Remove the request from the list.                  self.remove_request(uid)          elif args.has_key("ignore"):              # Remove the request from the list.              self.remove_request(uid)          else:             handled = False          if handled:             self.redirect(self.env.get_path())          return handled      def show_request_form(self, obj, needs_action):          """         Show a form for a request concerning 'obj', indicating whether action is         needed if 'needs_action' is specified as a true value.         """          details = self._get_details(obj)          attendees = get_value_map(details, "ATTENDEE")         attendee_attr = attendees.get(self.user)          if attendee_attr:             partstat = attendee_attr.get("PARTSTAT")             if partstat == "ACCEPTED":                 self.page.p("This request has been accepted.")             elif partstat == "DECLINED":                 self.page.p("This request has been declined.")             else:                 self.page.p("This request has been ignored.")          if needs_action:             self.page.p("An action is required for this request:")         else:             self.page.p("This request can be updated as follows:")          self.page.form(method="POST")         self.page.p()         self.page.input(name="accept", type="submit", value="Accept")         self.page.add(" ")         self.page.input(name="decline", type="submit", value="Decline")         self.page.add(" ")         self.page.input(name="ignore", type="submit", value="Ignore")         if not needs_action:             self.page.input(name="update", type="hidden", value="true")         self.page.p.close()         self.page.form.close()      def show_object_on_page(self, uid, obj):          """         Show the calendar object with the given 'uid' and representation 'obj'         on the current page.         """          # Obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.get("TZID", "UTC")          # Provide a summary of the object.          details = self._get_details(obj)          self.page.dl()          for name in ["SUMMARY", "DTSTART", "DTEND", "ORGANIZER", "ATTENDEE"]:             if name in ["DTSTART", "DTEND"]:                 value, attr = get_item(details, name)                 tzid = attr.get("TZID", tzid)                 value = self.format_datetime(to_timezone(get_datetime(value), tzid), "full")                 self.page.dt(name)                 self.page.dd(value)             else:                 for value in get_values(details, name):                     self.page.dt(name)                     self.page.dd(value)          self.page.dl.close()          dtstart = format_datetime(get_utc_datetime(details, "DTSTART"))         dtend = format_datetime(get_utc_datetime(details, "DTEND"))          # Indicate whether there are conflicting events.          freebusy = self.store.get_freebusy(self.user)          if freebusy:              # Obtain any time zone details from the suggested event.              _dtstart, attr = get_item(details, "DTSTART")             tzid = attr.get("TZID", tzid)              # Show any conflicts.              for t in have_conflict(freebusy, [(dtstart, dtend)], True):                 start, end, found_uid = t[:3]                  # Provide details of any conflicting event.                  if uid != found_uid:                     start = self.format_datetime(to_timezone(get_datetime(start), tzid), "full")                     end = self.format_datetime(to_timezone(get_datetime(end), tzid), "full")                     self.page.p("Event conflicts with another from %s to %s: " % (start, end))                      # Show the event summary for the conflicting event.                      found_obj = self._get_object(found_uid)                     if found_obj:                         found_details = self._get_details(found_obj)                         self.page.a(get_value(found_details, "SUMMARY"), href=self.env.new_url(found_uid))      def show_requests_on_page(self):          "Show requests for the current user."          # NOTE: This list could be more informative, but it is envisaged that         # NOTE: the requests would be visited directly anyway.          requests = self._get_requests()          self.page.div(id="pending-requests")          if requests:             self.page.p("Pending requests:")              self.page.ul()              for request in requests:                 obj = self._get_object(request)                 if obj:                     details = self._get_details(obj)                     self.page.li()                     self.page.a(get_value(details, "SUMMARY"), href="#request-%s" % request)                     self.page.li.close()              self.page.ul.close()          else:             self.page.p("There are no pending requests.")          self.page.div.close()      def show_participants_on_page(self):          "Show participants for scheduling purposes."          args = self.env.get_args()         participants = args.get("participants", [])          try:             for name, value in args.items():                 if name.startswith("remove-participant-"):                     i = int(name[len("remove-participant-"):])                     del participants[i]                     break         except ValueError:             pass          # Trim empty participants.          while participants and not participants[-1].strip():             participants.pop()          # Show any specified participants together with controls to remove and         # add participants.          self.page.div(id="participants")          self.page.form(method="POST")          self.page.p("Participants for scheduling:")          for i, participant in enumerate(participants):             self.page.p()             self.page.input(name="participants", type="text", value=participant)             self.page.input(name="remove-participant-%d" % i, type="submit", value="Remove")             self.page.p.close()          self.page.p()         self.page.input(name="participants", type="text")         self.page.input(name="add-participant", type="submit", value="Add")         self.page.p.close()          self.page.form.close()          self.page.div.close()          return participants      # Full page output methods.      def show_object(self, path_info):          "Show an object request using the given 'path_info' for the current user."          uid = self._get_uid(path_info)         obj = self._get_object(uid)          if not obj:             return False          is_request = uid in self._get_requests()         handled = self.handle_request(uid, obj, is_request)          if handled:             return True          self.new_page(title="Event")          self.show_object_on_page(uid, obj)          self.show_request_form(obj, is_request and not handled)          return True      def show_calendar(self):          "Show the calendar for the current user."          self.new_page(title="Calendar")         page = self.page          self.show_requests_on_page()         participants = self.show_participants_on_page()          freebusy = self.store.get_freebusy(self.user)          if not freebusy:             page.p("No events scheduled.")             return          # Obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.get("TZID", "UTC")          # Day view: start at the earliest known day and produce days until the         # latest known day, perhaps with expandable sections of empty days.          # Month view: start at the earliest known month and produce months until         # the latest known month, perhaps with expandable sections of empty         # months.          # Details of users to invite to new events could be superimposed on the         # calendar.          # Requests are listed and linked to their tentative positions in the         # calendar. Other participants are also shown.          request_summary = self._get_request_summary()          period_groups = [request_summary, freebusy]         period_group_types = ["request", "freebusy"]         period_group_sources = ["Pending requests", "Your schedule"]          for participant in participants:             period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))             period_group_types.append("freebusy")             period_group_sources.append(participant)          groups = []         group_columns = []         group_types = period_group_types         group_sources = period_group_sources         all_points = set()          # Obtain time point information for each group of periods.          for periods in period_groups:             periods = convert_periods(periods, tzid)              # Get the time scale with start and end points.              scale = get_scale(periods)              # Get the time slots for the periods.              slots = get_slots(scale)              # Add start of day time points for multi-day periods.              add_day_start_points(slots)              # Record the slots and all time points employed.              groups.append(slots)             all_points.update([point for point, slot 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():                 columns = max(columns, max(map(lambda i: len(i[1]), day_slots)))                  if not days.has_key(day):                     days[day] = set()                  # Convert each partition to a mapping from points to active                 # periods.                  day_slots = dict(day_slots)                 partitioned[day] = day_slots                 days[day].update(day_slots.keys())              if partitioned:                 group_columns.append(columns)                 partitioned_groups.append(partitioned)                 partitioned_group_types.append(group_type)                 partitioned_group_sources.append(group_source)          page.table(border=1, cellspacing=0, cellpadding=5)         self.show_calendar_participant_headings(partitioned_group_sources, group_columns)         self.show_calendar_days(days, partitioned_groups, partitioned_group_types, group_columns)         page.table.close()      def show_calendar_participant_headings(self, group_sources, group_columns):          """         Show headings for the participants and other scheduling contributors,         defined by 'group_sources' and 'group_columns'.         """          page = self.page          page.colgroup(span=1) # for datetime information          for columns in group_columns:             page.colgroup(span=columns)          page.thead()         page.tr()         page.th("", class_="emptyheading")          for source, columns in zip(group_sources, group_columns):             page.th(source, class_="participantheading", colspan=columns)          page.tr.close()         page.thead.close()      def show_calendar_days(self, days, partitioned_groups, partitioned_group_types, group_columns):          """         Show calendar days, defined by a collection of 'days', the contributing         period information as 'partitioned_groups' (partitioned by day), the         'partitioned_group_types' indicating the kind of contribution involved,         and the 'group_columns' defining the number of columns in each group.         """          page = self.page          # Determine the number of columns required, the days providing time         # slots.          all_columns = sum(group_columns)         all_days = days.items()         all_days.sort()          # Produce a heading and time points for each day.          for day, points in all_days:             page.thead()             page.tr()             page.th(class_="dayheading", colspan=all_columns+1)             page.add(self.format_date(day, "full"))             page.th.close()             page.tr.close()             page.thead.close()              groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]              page.tbody()             self.show_calendar_points(points, groups_for_day, partitioned_group_types, group_columns)             page.tbody.close()      def show_calendar_points(self, points, groups, group_types, group_columns):          """         Show the time 'points' along with period information from the given         'groups', having the indicated 'group_types', each with the number of         columns given by 'group_columns'.         """          page = self.page          # Produce a row for each time point.          points = list(points)         points.sort()          for point in points:             continuation = point == get_start_of_day(point)              page.tr()             page.th(class_="timeslot")             page.add(self.format_time(point, "long"))             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)                  if not active:                     page.td(class_="empty", colspan=columns)                     page.td.close()                     continue                  slots = slots.items()                 slots.sort()                 spans = get_spans(slots)                  # Show a column for each active period.                  for t in active:                     if t and len(t) >= 2:                         start, end, uid, key = get_freebusy_details(t)                         span = spans[key]                          # Produce a table cell only at the start of the period                         # or when continued at the start of a day.                          if point == start or continuation:                              page.td(class_="event", rowspan=span)                              obj = self._get_object(uid)                              if not obj:                                 page.span("")                             else:                                 details = self._get_details(obj)                                 summary = get_value(details, "SUMMARY")                                  # Only link to events if they are not being                                 # updated by requests.                                  if uid in self._get_requests() and group_type != "request":                                     page.span(summary, id="%s-%s" % (group_type, uid))                                 else:                                     href = "%s/%s" % (self.env.get_url().rstrip("/"), uid)                                      # Only anchor the first cell of events.                                      if point == start:                                         page.a(summary, href=href, id="%s-%s" % (group_type, uid))                                     else:                                         page.a(summary, href=href)                              page.td.close()                     else:                         page.td(class_="empty")                         page.td.close()                  # Pad with empty columns.                  i = columns - len(active)                 while i > 0:                     i -= 1                     page.td(class_="empty")                     page.td.close()              page.tr.close()      def select_action(self):          "Select the desired action and show the result."          path_info = self.env.get_path_info().strip("/")          if not path_info:             self.show_calendar()         elif self.show_object(path_info):             pass         else:             self.no_page()      def __call__(self):          "Interpret a request and show an appropriate response."          if not self.user:             self.no_user()         else:             self.select_action()          # Write the headers and actual content.          print >>self.out, "Content-Type: text/html; charset=%s" % self.encoding         print >>self.out         self.out.write(unicode(self.page).encode(self.encoding))  if __name__ == "__main__":     Manager()()  # vim: tabstop=4 expandtab shiftwidth=4