#!/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, \                               format_datetime, get_address, get_datetime, \                               get_item, get_uri, get_utc_datetime, get_value, \                               get_values, parse_object, to_part, to_timezone from imiptools.mail import Messenger from imiptools.period import have_conflict, get_slots, get_spans 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)  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_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):          """         Process the current request for the given 'user', accepting any request         when 'accept' is true, declining requests otherwise. Return whether any         action was taken.         """          # 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)]                 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()          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):         f = uid and self.store.get_event(self.user, uid) or None          if not f:             return None          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      # 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      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):          "Handle actions involving the given 'uid' and 'request' object."          # Handle a submitted form.          args = self.env.get_args()         handled = True          accept = args.has_key("accept")         decline = args.has_key("decline")          if accept or decline:              handler = ManagerHandler(request, self.user, self.messenger)              if handler.process_request(accept):                  # 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):          "Show a form for a request."          self.page.p("Action to take for this request:")         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")         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.         """          details = self._get_details(obj)          # Provide a summary of the object.          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")                 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")              # Show any conflicts.              for t in have_conflict(freebusy, [(dtstart, dtend)], True):                 start, end, found_uid = t[:3]                 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))      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()          if requests:             self.page.p("Pending requests:")              self.page.ul()              for request in requests:                 self.page.li()                 self.page.a(request, href="%s/%s" % (self.env.get_url().rstrip("/"), request))                 self.page.li.close()              self.page.ul.close()          else:             self.page.p("There are no pending requests.")      # 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 = is_request and self.handle_request(uid, obj)          if handled:             return True          self.new_page(title="Event")          self.show_object_on_page(uid, obj)          if is_request and not handled:             self.show_request_form()          return True      def show_calendar(self):          "Show the calendar for the current user."          self.new_page(title="Calendar")         self.show_requests_on_page()          freebusy = self.store.get_freebusy(self.user)         page = self.page          if not freebusy:             page.p("No events scheduled.")             return          # Set the locale and obtain the user's timezone.          prefs = self.get_preferences()         tzid = prefs.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 could be listed and linked to their tentative positions in         # the calendar.          slots = get_slots(freebusy)         spans = get_spans(slots)          page.table(border=1, cellspacing=0, cellpadding=5)          last_day = None         columns = max(map(lambda i: len(i[1]), slots)) + 1          for point, active in slots:             dt = to_timezone(get_datetime(point), tzid or "UTC")             day = dt.date()              if not last_day or last_day < day:                 page.tr()                 page.th(class_="timeslot", colspan=columns)                 page.add(self.format_date(day, "full"))                 page.th.close()                 page.tr.close()              page.tr()             page.th(class_="timeslot")             page.add(self.format_date(dt, "full"))             page.br()             page.add(self.format_time(dt, "long"))             page.th.close()              for t in active:                 if t:                     start, end, uid = t[:3]                     span = spans[uid]                     if point == start:                          page.td(class_="event", rowspan=span)                         obj = self._get_object(uid)                         if obj:                             details = self._get_details(obj)                             page.a(get_value(details, "SUMMARY"), href="%s/%s" % (self.env.get_url().rstrip("/"), uid))                         page.td.close()                 else:                     page.td(class_="empty")                     page.td.close()              page.tr.close()             last_day = day          page.table.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