#!/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_uri, 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.env import CGIEnvironment 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):          """         Return a link to an object with the given 'uid' and 'recurrenceid'.         See get_identifiers for the decoding of such links.         """          path = [uid]         if recurrenceid:             path.append(recurrenceid)         return self.env.new_url("/".join(path))      # 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"      # 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):         if self.objects.has_key((uid, recurrenceid, section)):             return self.objects[(uid, recurrenceid, section)]          obj = self.objects[(uid, recurrenceid, section)] = self.get_stored_object(uid, recurrenceid, section)         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_request_summary(self):          "Return a list of periods comprising the request summary."          summary = []          for uid, recurrenceid, request_type in self._get_requests():             obj = self.get_stored_object(uid, recurrenceid)             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())      # Data management methods.      def remove_request(self, uid, recurrenceid=None):         return self.store.dequeue_request(self.user, uid, recurrenceid)      def remove_event(self, uid, recurrenceid=None):         return self.store.remove_event(self.user, uid, recurrenceid)  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):         Resource.__init__(self, resource)         user = self.env.get_user()         ClientForObject.__init__(self, None, user and get_uri(user) or None)  class FormUtilities:      "Utility methods."      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 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)  # vim: tabstop=4 expandtab shiftwidth=4