#!/usr/bin/env python  """ Common resource functionality for Web calendar clients.  Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from datetime import datetime, timedelta from imiptools.client import Client, ClientForObject from imiptools.data import get_address, get_uri, uri_item, uri_values from imiptools.dates import format_datetime, get_recurrence_start_point, to_date from imiptools.period import remove_period, remove_affected_period from imipweb.data import event_period_from_period, form_period_from_period, FormDate from imipweb.env import CGIEnvironment from urllib import urlencode import babel.dates import imip_store import markup import pytz  class Resource:      "A Web application resource."      def __init__(self, resource=None):          """         Initialise a resource, allowing it to share the environment of any given         existing 'resource'.         """          self.encoding = "utf-8"         self.env = CGIEnvironment(self.encoding)          self.objects = {}         self.locale = None         self.requests = None          self.out = resource and resource.out or self.env.get_output()         self.page = resource and resource.page or markup.page()         self.html_ids = None      # Presentation methods.      def new_page(self, title):         self.page.init(title=title, charset=self.encoding, css=self.env.new_url("styles.css"))         self.html_ids = set()      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)      def link_to(self, uid, recurrenceid=None, args=None):          """         Return a link to an object with the given 'uid' and 'recurrenceid'.         See get_identifiers for the decoding of such links.          If 'args' is specified, the given dictionary is encoded and included.         """          path = [uid]         if recurrenceid:             path.append(recurrenceid)         return "%s%s" % (self.env.new_url("/".join(path)), args and ("?%s" % urlencode(args)) or "")      # Access to objects.      def get_identifiers(self, path_info):          """         Return identifiers provided by 'path_info', potentially encoded by         'link_to'.         """          parts = path_info.lstrip("/").split("/")          # UID only.          if len(parts) == 1:             return parts[0], None          # UID and RECURRENCE-ID.          else:             return parts[:2]      def _get_object(self, uid, recurrenceid=None, section=None, username=None):         if self.objects.has_key((uid, recurrenceid, section, username)):             return self.objects[(uid, recurrenceid, section, username)]          obj = self.objects[(uid, recurrenceid, section, username)] = self.get_stored_object(uid, recurrenceid, section, username)         return obj      def _get_recurrences(self, uid):         return self.store.get_recurrences(self.user, uid)      def _get_active_recurrences(self, uid):         return self.store.get_active_recurrences(self.user, uid)      def _get_requests(self):         if self.requests is None:             self.requests = self.store.get_requests(self.user)         return self.requests      def _have_request(self, uid, recurrenceid=None, type=None, strict=False):         return self.store.have_request(self._get_requests(), uid, recurrenceid, type, strict)      def _get_counters(self, uid, recurrenceid=None):         return self.store.get_counters(self.user, uid, recurrenceid)      def _get_request_summary(self):          "Return a list of periods comprising the request summary."          summary = []          for uid, recurrenceid, request_type in self._get_requests():              # Obtain either normal objects or counter-proposals.              if not request_type:                 objs = [self._get_object(uid, recurrenceid)]             elif request_type == "COUNTER":                 objs = []                 for attendee in self.store.get_counters(self.user, uid, recurrenceid):                     objs.append(self._get_object(uid, recurrenceid, "counters", attendee))              # For each object, obtain the periods involved.              for obj in objs:                 if obj:                     recurrenceids = self._get_active_recurrences(uid)                      # Obtain only active periods, not those replaced by redefined                     # recurrences, converting to free/busy periods.                      for p in obj.get_active_periods(recurrenceids, self.get_tzid(), self.get_window_end()):                         summary.append(obj.get_freebusy_period(p))          return summary      # Preference methods.      def get_user_locale(self):         if not self.locale:             self.locale = self.get_preferences().get("LANG", "en")         return self.locale      # 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(             isinstance(dt, datetime) and babel.dates.format_datetime or babel.dates.format_date,             dt, format)      def _format_datetime(self, fn, dt, format):         return fn(dt, format=format, locale=self.get_user_locale())  class ResourceClient(Resource, Client):      "A Web application resource and calendar client."      def __init__(self, resource=None):         Resource.__init__(self, resource)         user = self.env.get_user()         Client.__init__(self, user and get_uri(user) or None)  class ResourceClientForObject(Resource, ClientForObject):      "A Web application resource and calendar client for a specific object."      def __init__(self, resource=None, messenger=None):         Resource.__init__(self, resource)         user = self.env.get_user()         ClientForObject.__init__(self, None, user and get_uri(user) or None, messenger)      # Communication methods.      def send_message(self, method, sender, from_organiser, parts=None):          """         Create a full calendar object employing the given 'method', and send it         to the appropriate recipients, also sending a copy to the 'sender'. The         'from_organiser' value indicates whether the organiser is sending this         message (and is thus equivalent to "as organiser").         """          parts = parts or [self.obj.to_part(method)]          # As organiser, send an invitation to attendees, excluding oneself if         # also attending. The updated event will be saved by the outgoing         # handler.          organiser = get_uri(self.obj.get_value("ORGANIZER"))         attendees = uri_values(self.obj.get_values("ATTENDEE"))          if from_organiser:             recipients = [get_address(attendee) for attendee in attendees if attendee != self.user]         else:             recipients = [get_address(organiser)]          # Since the outgoing handler updates this user's free/busy details,         # the stored details will probably not have the updated details at         # this point, so we update our copy for serialisation as the bundled         # free/busy object.          freebusy = self.store.get_freebusy(self.user)         self.update_freebusy(freebusy, self.user, from_organiser)          # Bundle free/busy information if appropriate.          part = self.get_freebusy_part(freebusy)         if part:             parts.append(part)          self._send_message(sender, recipients, parts)      def _send_message(self, sender, recipients, parts):          # Explicitly specify the outgoing BCC recipient since we are sending as         # the generic calendar user.          message = self.messenger.make_outgoing_message(parts, recipients, outgoing_bcc=sender)         self.messenger.sendmail(recipients, message.as_string(), outgoing_bcc=sender)      # Action methods.      def process_declined_counter(self, attendee):          "Process a declined counter-proposal."          # Obtain the counter-proposal for the attendee.          obj = self.get_stored_object(self.uid, self.recurrenceid, "counters", attendee)         if not obj:             return False          method = "DECLINECOUNTER"         obj.update_dtstamp()         obj.update_sequence(False)         self._send_message(get_address(self.user), [get_address(attendee)], parts=[obj.to_part(method)])         return True      def process_received_request(self):          """         Process the current request for the current user. Return whether any         action was taken.         """          # Reply only on behalf of this user.          attendee_attr = self.update_participation(self.obj)          if not attendee_attr:             return False          self.obj["ATTENDEE"] = [(self.user, attendee_attr)]         self.update_dtstamp()         self.update_sequence(False)         self.send_message("REPLY", get_address(self.user), from_organiser=False)         return True      def process_created_request(self, method, to_cancel=None, to_unschedule=None):          """         Process the current request, sending a created request of the given         'method' to attendees. Return whether any action was taken.          If 'to_cancel' is specified, a list of participants to be sent cancel         messages is provided.          If 'to_unschedule' is specified, a list of periods to be unscheduled is         provided.         """          # Here, the organiser should be the current user.          organiser, organiser_attr = uri_item(self.obj.get_item("ORGANIZER"))          self.update_sender(organiser_attr)         self.update_dtstamp()         self.update_sequence(True)          parts = [self.obj.to_part(method)]          # Add message parts with cancelled occurrence information.         # NOTE: This could probably be merged with the updated event message.          if to_unschedule:             obj = self.obj.copy()             obj.remove_all(["RRULE", "RDATE", "DTSTART", "DTEND", "DURATION"])              for p in to_unschedule:                 if not p.origin:                     continue                 obj["RECURRENCE-ID"] = [(format_datetime(p.get_start()), p.get_start_attr())]                 parts.append(obj.to_part("CANCEL"))          # Send the updated event, along with a cancellation for each of the         # unscheduled occurrences.          self.send_message("CANCEL", get_address(organiser), from_organiser=True, parts=parts)          # When cancelling, replace the attendees with those for whom the event         # is now cancelled.          if to_cancel:             obj = self.obj.copy()             obj["ATTENDEE"] = to_cancel              # Send a cancellation to all uninvited attendees.              self.send_message("CANCEL", get_address(organiser), from_organiser=True)          return True  class FormUtilities:      "Utility methods resource mix-in."      def prefixed_args(self, prefix, convert=None):          """         Return values for all arguments having the given 'prefix' in their         names, removing the prefix to obtain each value from the argument name         itself. The 'convert' callable can be specified to perform a conversion         (to int, for example).         """          args = self.env.get_args()          values = []         for name in args.keys():             if name.startswith(prefix):                 value = name[len(prefix):]                 if convert:                     try:                         value = convert(value)                     except ValueError:                         pass                 values.append(value)         return values      def control(self, name, type, value, selected=False, **kw):          """         Show a control with the given 'name', 'type' and 'value', with         'selected' indicating whether it should be selected (checked or         equivalent), and with keyword arguments setting other properties.         """          page = self.page         if type in ("checkbox", "radio") and selected:             page.input(name=name, type=type, value=value, checked=selected, **kw)         else:             page.input(name=name, type=type, value=value, **kw)      def menu(self, name, default, items, class_="", index=None):          """         Show a select menu having the given 'name', set to the given 'default',         providing the given (value, label) 'items', and employing the given CSS         'class_' if specified.         """          page = self.page         values = self.env.get_args().get(name, [default])         if index is not None:             values = values[index:]             values = values and values[0:1] or [default]          page.select(name=name, class_=class_)         for v, label in items:             if v is None:                 continue             if v in values:                 page.option(label, value=v, selected="selected")             else:                 page.option(label, value=v)         page.select.close()      def date_controls(self, name, default, index=None, show_tzid=True, read_only=False):          """         Show date controls for a field with the given 'name' and 'default' form         date value.          If 'index' is specified, default field values will be overridden by the         element from a collection of existing form values with the specified         index; otherwise, field values will be overridden by a single form         value.          If 'show_tzid' is set to a false value, the time zone menu will not be         provided.          If 'read_only' is set to a true value, the controls will be hidden and         labels will be employed instead.         """          page = self.page          # Show dates for up to one week around the current date.          dt = default.as_datetime()         if not dt:             dt = date.today()          base = to_date(dt)          # Show a date label with a hidden field if read-only.          if read_only:             self.control("%s-date" % name, "hidden", format_datetime(base))             page.span(self.format_date(base, "long"))          # Show dates for up to one week around the current date.         # NOTE: Support paging to other dates.          else:             items = []             for i in range(-7, 8):                 d = base + timedelta(i)                 items.append((format_datetime(d), self.format_date(d, "full")))             self.menu("%s-date" % name, format_datetime(base), items, index=index)          # Show time details.          page.span(class_="time enabled")          if read_only:             page.span("%s:%s:%s" % (default.get_hour(), default.get_minute(), default.get_second()))             self.control("%s-hour" % name, "hidden", default.get_hour())             self.control("%s-minute" % name, "hidden", default.get_minute())             self.control("%s-second" % name, "hidden", default.get_second())         else:             self.control("%s-hour" % name, "text", default.get_hour(), maxlength=2, size=2)             page.add(":")             self.control("%s-minute" % name, "text", default.get_minute(), maxlength=2, size=2)             page.add(":")             self.control("%s-second" % name, "text", default.get_second(), maxlength=2, size=2)          # Show time zone details.          if show_tzid:             page.add(" ")             tzid = default.get_tzid() or self.get_tzid()              # Show a label if read-only or a menu otherwise.              if read_only:                 self.control("%s-tzid" % name, "hidden", tzid)                 page.span(tzid)             else:                 self.timezone_menu("%s-tzid" % name, tzid, index)          page.span.close()      def timezone_menu(self, name, default, index=None):          """         Show timezone controls using a menu with the given 'name', set to the         given 'default' unless a field of the given 'name' provides a value.         """          entries = [(tzid, tzid) for tzid in pytz.all_timezones]         self.menu(name, default, entries, index=index)  class DateTimeFormUtilities:      "Date/time control methods resource mix-in."      # Control naming helpers.      def element_identifier(self, name, index=None):         return index is not None and "%s-%d" % (name, index) or name      def element_name(self, name, suffix, index=None):         return index is not None and "%s-%s" % (name, suffix) or name      def element_enable(self, index=None):         return index is not None and str(index) or "enable"      def show_object_datetime_controls(self, period, index=None):          """         Show datetime-related controls if already active or if an object needs         them for the given 'period'. The given 'index' is used to parameterise         individual controls for dynamic manipulation.         """          p = form_period_from_period(period)          page = self.page         args = self.env.get_args()         _id = self.element_identifier         _name = self.element_name         _enable = self.element_enable          # Add a dynamic stylesheet to permit the controls to modify the display.         # NOTE: The style details need to be coordinated with the static         # NOTE: stylesheet.          if index is not None:             page.style(type="text/css")              # Unlike the rules for object properties, these affect recurrence             # properties.              page.add("""\ input#dttimes-enable-%(index)d, input#dtend-enable-%(index)d, input#dttimes-enable-%(index)d:not(:checked) ~ .recurrence td.objectvalue .time.enabled, input#dttimes-enable-%(index)d:checked ~ .recurrence td.objectvalue .time.disabled, input#dtend-enable-%(index)d:not(:checked) ~ .recurrence td.objectvalue.dtend .dt.enabled, input#dtend-enable-%(index)d:checked ~ .recurrence td.objectvalue.dtend .dt.disabled {     display: none; }""" % {"index" : index})              page.style.close()          self.control(             _name("dtend-control", "recur", index), "checkbox",             _enable(index), p.end_enabled,             id=_id("dtend-enable", index)             )          self.control(             _name("dttimes-control", "recur", index), "checkbox",             _enable(index), p.times_enabled,             id=_id("dttimes-enable", index)             )      def show_datetime_controls(self, formdate, show_start):          """         Show datetime details from the current object for the 'formdate',         showing start details if 'show_start' is set to a true value. Details         will appear as controls for organisers and labels for attendees.         """          page = self.page          # Show controls for editing as organiser.          if self.is_organiser():             page.td(class_="objectvalue dt%s" % (show_start and "start" or "end"))              if show_start:                 page.div(class_="dt enabled")                 self.date_controls("dtstart", formdate)                 page.br()                 page.label("Specify times", for_="dttimes-enable", class_="time disabled enable")                 page.label("Specify dates only", for_="dttimes-enable", class_="time enabled disable")                 page.div.close()              else:                 page.div(class_="dt disabled")                 page.label("Specify end date", for_="dtend-enable", class_="enable")                 page.div.close()                 page.div(class_="dt enabled")                 self.date_controls("dtend", formdate)                 page.br()                 page.label("End on same day", for_="dtend-enable", class_="disable")                 page.div.close()              page.td.close()          # Show a label as attendee.          else:             dt = formdate.as_datetime()             if dt:                 page.td(self.format_datetime(dt, "full"))             else:                 page.td("(Unrecognised date)")      def show_recurrence_controls(self, index, period, recurrenceid, recurrenceids, show_start):          """         Show datetime details from the current object for the recurrence having         the given 'index', with the recurrence period described by 'period',         indicating a start, end and origin of the period from the event details,         employing any 'recurrenceid' and 'recurrenceids' for the object to         configure the displayed information.          If 'show_start' is set to a true value, the start details will be shown;         otherwise, the end details will be shown.         """          page = self.page         _id = self.element_identifier         _name = self.element_name          p = event_period_from_period(period)         replaced = not recurrenceid and p.is_replaced(recurrenceids)          # Show controls for editing as organiser.          if self.is_organiser() and not replaced:             page.td(class_="objectvalue dt%s" % (show_start and "start" or "end"))              read_only = period.origin == "RRULE"              if show_start:                 page.div(class_="dt enabled")                 self.date_controls(_name("dtstart", "recur", index), p.get_form_start(), index=index, read_only=read_only)                 if not read_only:                     page.br()                     page.label("Specify times", for_=_id("dttimes-enable", index), class_="time disabled enable")                     page.label("Specify dates only", for_=_id("dttimes-enable", index), class_="time enabled disable")                 page.div.close()                  # Put the origin somewhere.                  self.control("recur-origin", "hidden", p.origin or "")              else:                 page.div(class_="dt disabled")                 if not read_only:                     page.label("Specify end date", for_=_id("dtend-enable", index), class_="enable")                 page.div.close()                 page.div(class_="dt enabled")                 self.date_controls(_name("dtend", "recur", index), p.get_form_end(), index=index, show_tzid=False, read_only=read_only)                 if not read_only:                     page.br()                     page.label("End on same day", for_=_id("dtend-enable", index), class_="disable")                 page.div.close()              page.td.close()          # Show label as attendee.          else:             self.show_recurrence_label(p, recurrenceid, recurrenceids, show_start)      def show_recurrence_label(self, period, recurrenceid, recurrenceids, show_start):          """         Show datetime details for the given 'period', employing any         'recurrenceid' and 'recurrenceids' for the object to configure the         displayed information.          If 'show_start' is set to a true value, the start details will be shown;         otherwise, the end details will be shown.         """          page = self.page          p = event_period_from_period(period)         replaced = not recurrenceid and p.is_replaced(recurrenceids)          css = " ".join([             replaced and "replaced" or "",             p.is_affected(recurrenceid) and "affected" or ""             ])          formdate = show_start and p.get_form_start() or p.get_form_end()         dt = formdate.as_datetime()         if dt:             page.td(self.format_datetime(dt, "long"), class_=css)         else:             page.td("(Unrecognised date)")      def get_date_control_values(self, name, multiple=False, tzid_name=None):          """         Return a form date object representing fields starting with 'name'. If         'multiple' is set to a true value, many date objects will be returned         corresponding to a collection of datetimes.          If 'tzid_name' is specified, the time zone information will be acquired         from fields starting with 'tzid_name' instead of 'name'.         """          args = self.env.get_args()          dates = args.get("%s-date" % name, [])         hours = args.get("%s-hour" % name, [])         minutes = args.get("%s-minute" % name, [])         seconds = args.get("%s-second" % name, [])         tzids = args.get("%s-tzid" % (tzid_name or name), [])          # Handle absent values by employing None values.          field_values = map(None, dates, hours, minutes, seconds, tzids)          if not field_values and not multiple:             all_values = FormDate()         else:             all_values = []             for date, hour, minute, second, tzid in field_values:                 value = FormDate(date, hour, minute, second, tzid or self.get_tzid())                  # Return a single value or append to a collection of all values.                  if not multiple:                     return value                 else:                     all_values.append(value)          return all_values      def set_date_control_values(self, name, formdates, tzid_name=None):          """         Replace form fields starting with 'name' using the values of the given         'formdates'.          If 'tzid_name' is specified, the time zone information will be stored in         fields starting with 'tzid_name' instead of 'name'.         """          args = self.env.get_args()          args["%s-date" % name] = [d.date for d in formdates]         args["%s-hour" % name] = [d.hour for d in formdates]         args["%s-minute" % name] = [d.minute for d in formdates]         args["%s-second" % name] = [d.second for d in formdates]         args["%s-tzid" % (tzid_name or name)] = [d.tzid for d in formdates]  # vim: tabstop=4 expandtab shiftwidth=4