#!/usr/bin/env python  """ Common resource functionality for Web calendar clients.  Copyright (C) 2014, 2015, 2016, 2017 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 date, datetime, timedelta from imiptools.client import Client, ClientForObject from imiptools.data import get_uri from imiptools.dates import format_datetime, to_date from imiptools.freebusy import FreeBusyCollection from imipweb.data import event_period_from_period, form_period_from_period, \                          PeriodError from imipweb.env import CGIEnvironment from urllib import urlencode import babel.dates import hashlib, hmac import markup import pytz import time  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=None, recurrenceid=None, args=None):          """         Return a link to a resource, being an object with any given 'uid' and         'recurrenceid', or the main resource otherwise.          See get_identifiers for the decoding of such links.          If 'args' is specified, the given dictionary is encoded and included.         """          path = []         if uid:             path.append(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 _is_request(self):         return self._have_request(self.uid, self.recurrenceid)      def _get_counters(self, uid, recurrenceid=None):         return self.store.get_counters(self.user, uid, recurrenceid)      def _get_request_summary(self, view_period):          """         Return a list of periods comprising the request summary within the given         'view_period'.         """          summary = FreeBusyCollection()          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_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(),                         start=view_period.get_start(), end=view_period.get_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", True) or "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)  class FormUtilities:      "Utility methods resource mix-in."      def get_validation_token(self, details=None):          "Return a token suitable for validating a form submission."          # Use a secret held in the user's preferences.          prefs = self.get_preferences()         if not prefs.has_key("secret"):             prefs["secret"] = str(time.time())          # Combine it with the user identity and any supplied details.          secret = prefs["secret"].encode("utf-8")         details = u"".join([self.env.get_user()] + (details or [])).encode("utf-8")          return hmac.new(secret, details, hashlib.sha256).hexdigest()      def check_validation_token(self, name="token", details=None):          """         Check the field having the given 'name', returning if its value matches         the validation token generated using any given 'details'.         """          return self.env.get_args().get(name, [None])[0] == self.get_validation_token(details)      def validator(self, name="token", details=None):          """         Show a control having the given 'name' that is used to validate form         submissions, employing any additional 'details' in the construction of         the validation token.         """          self.page.input(name=name, type="hidden", value=self.get_validation_token(details))      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="checked", **kw)         else:             page.input(name=name, type=type, value=value, **kw)      def menu(self, name, default, items, values=None, class_=""):          """         Show a select menu having the given 'name', set to the given 'default',         providing the given (value, label) 'items', selecting the given 'values'         (or using the request parameters if not specified), and employing the         given CSS 'class_' if specified.         """          page = self.page         values = values 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, show_tzid=True, read_only=False):          """         Show date controls for a field with the given 'name' and 'default' form         date 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.          page.span(class_="date enabled")          dt = default.as_datetime()          # For invalid datetimes, try to get a date instead.          if not dt:             dt = default.as_datetime(with_time=False)              # For invalid dates, just use today's date.              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)          page.span.close()          # 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)          page.span.close()      def timezone_menu(self, name, default):          """         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)  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 str(index or 0)      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         _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; }  input#dtend-enable-%(index)d:not(:checked) ~ .recurrence td.objectvalue.dtend .date.enabled, input#dtend-enable-%(index)d:checked ~ .recurrence td.objectvalue.dtend .date.disabled {     visibility: hidden; }""" % {"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.          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:             self.date_controls("dtend", formdate)             page.div(class_="dt disabled")             page.label("Specify end date", for_="dtend-enable", class_="enable")             page.div.close()             page.div(class_="dt enabled")             page.label("End on same day", for_="dtend-enable", class_="disable")             page.div.close()          page.td.close()      def show_recurrence_controls(self, index, period, recurrenceid, 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' 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          period = form_period_from_period(period)          # Show controls for editing.          if not period.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), period.get_form_start(), 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()                  self.show_recurrence_state(index, period)             else:                 self.date_controls(_name("dtend", "recur", index), period.get_form_end(), show_tzid=False, read_only=read_only)                 if not read_only:                     page.div(class_="dt disabled")                     page.label("Specify end date", for_=_id("dtend-enable", index), class_="enable")                     page.div.close()                     page.div(class_="dt enabled")                     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(index, period, recurrenceid, show_start)      def show_recurrence_label(self, index, period, recurrenceid, show_start):          """         Show datetime details from the current object for the recurrence having         the given 'index', for the given recurrence 'period', employing any         'recurrenceid' 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         _name = self.element_name          try:             p = event_period_from_period(period)         except PeriodError, exc:             affected = False         else:             affected = p.is_affected(recurrenceid)          period = form_period_from_period(period)          css = " ".join([             period.replaced and "replaced" or "",             affected and "affected" or ""             ])          formdate = show_start and period.get_form_start() or period.get_form_end()         dt = formdate.as_datetime()         if dt:             page.td(class_=css)             if show_start:                 self.date_controls(_name("dtstart", "recur", index), period.get_form_start(), read_only=True)                 self.show_recurrence_state(index, period)             else:                 self.date_controls(_name("dtend", "recur", index), period.get_form_end(), show_tzid=False, read_only=True)             page.td.close()         else:             page.td("(Unrecognised date)")      def show_recurrence_state(self, index, period):          "Insert at 'index' additional state held by 'period'."          self.control("recur-origin", "hidden", period.origin or "")         self.control("recur-replaced", "hidden", period.replaced and str(index) or "")         self.control("recur-id", "hidden", period.recurrenceid or "")  # vim: tabstop=4 expandtab shiftwidth=4