imip-agent

Annotated imip_manager.py

276:b2d092b08bdb
275:900077963563
274:525ea9b0310f
2015-02-05 Paul Boddie file changeset files shortlog Colour events according to the organiser/attendee role of the user.
paul@69 1 
#!/usr/bin/env python
paul@69 2 
 
 paul@146      3 
"""
 
 paul@146      4 
A Web interface to a user's calendar.
 
 paul@146      5 
 
 paul@146      6 
Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>
 
 paul@146      7 
 
 paul@146      8 
This program is free software; you can redistribute it and/or modify it under
 
 paul@146      9 
the terms of the GNU General Public License as published by the Free Software
 
 paul@146     10 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@146     11 
version.
 
 paul@146     12 
 
 paul@146     13 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@146     14 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@146     15 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@146     16 
details.
 
 paul@146     17 
 
 paul@146     18 
You should have received a copy of the GNU General Public License along with
 
 paul@146     19 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@146     20 
"""
 
 paul@146     21 
 
 paul@146     22 
# Edit this path to refer to the location of the imiptools libraries, if
 
 paul@146     23 
# necessary.
 
 paul@146     24 
 
 paul@146     25 
LIBRARY_PATH = "/var/lib/imip-agent"
 
 paul@146     26 
 
 paul@232     27 
from datetime import date, datetime, timedelta
 
 paul@149     28 
import babel.dates
 
 paul@149     29 
import cgi, os, sys
 
 paul@69     30 
 
 paul@146     31 
sys.path.append(LIBRARY_PATH)
 
 paul@69     32 
 
 paul@213     33 
from imiptools.content import Handler
 
 paul@222     34 
from imiptools.data import get_address, get_uri, make_freebusy, parse_object, \
 
 paul@222     35 
                           Object, to_part
 
 paul@239     36 
from imiptools.dates import format_datetime, get_datetime, get_datetime_item, \
 
 paul@241     37 
                            get_end_of_day, get_start_of_day, get_start_of_next_day, \
 
 paul@274     38 
                            get_timestamp, ends_on_same_day, to_timezone
 
 paul@83     39 
from imiptools.mail import Messenger
 
 paul@162     40 
from imiptools.period import add_day_start_points, add_slots, convert_periods, \
 
 paul@185     41 
                             get_freebusy_details, \
 
 paul@162     42 
                             get_scale, have_conflict, get_slots, get_spans, \
 
 paul@162     43 
                             partition_by_day
 
 paul@147     44 
from imiptools.profile import Preferences
 
 paul@213     45 
import imip_store
 
 paul@69     46 
import markup
 
 paul@69     47 
 
 paul@69     48 
getenv = os.environ.get
 
 paul@69     49 
setenv = os.environ.__setitem__
 
 paul@69     50 
 
 paul@69     51 
class CGIEnvironment:
 
 paul@69     52 
 
 paul@69     53 
    "A CGI-compatible environment."
 
 paul@69     54 
 
 paul@212     55 
    def __init__(self, charset=None):
 
 paul@212     56 
        self.charset = charset
 
 paul@69     57 
        self.args = None
 
 paul@69     58 
        self.method = None
 
 paul@69     59 
        self.path = None
 
 paul@69     60 
        self.path_info = None
 
 paul@69     61 
        self.user = None
 
 paul@69     62 
 
 paul@69     63 
    def get_args(self):
 
 paul@69     64 
        if self.args is None:
 
 paul@69     65 
            if self.get_method() != "POST":
 
 paul@69     66 
                setenv("QUERY_STRING", "")
 
 paul@212     67 
            args = cgi.parse(keep_blank_values=True)
 
 paul@212     68 
 
 paul@212     69 
            if not self.charset:
 
 paul@212     70 
                self.args = args
 
 paul@212     71 
            else:
 
 paul@212     72 
                self.args = {}
 
 paul@212     73 
                for key, values in args.items():
 
 paul@212     74 
                    self.args[key] = [unicode(value, self.charset) for value in values]
 
 paul@212     75 
 
 paul@69     76 
        return self.args
 
 paul@69     77 
 
 paul@69     78 
    def get_method(self):
 
 paul@69     79 
        if self.method is None:
 
 paul@69     80 
            self.method = getenv("REQUEST_METHOD") or "GET"
 
 paul@69     81 
        return self.method
 
 paul@69     82 
 
 paul@69     83 
    def get_path(self):
 
 paul@69     84 
        if self.path is None:
 
 paul@69     85 
            self.path = getenv("SCRIPT_NAME") or ""
 
 paul@69     86 
        return self.path
 
 paul@69     87 
 
 paul@69     88 
    def get_path_info(self):
 
 paul@69     89 
        if self.path_info is None:
 
 paul@69     90 
            self.path_info = getenv("PATH_INFO") or ""
 
 paul@69     91 
        return self.path_info
 
 paul@69     92 
 
 paul@69     93 
    def get_user(self):
 
 paul@69     94 
        if self.user is None:
 
 paul@69     95 
            self.user = getenv("REMOTE_USER") or ""
 
 paul@69     96 
        return self.user
 
 paul@69     97 
 
 paul@69     98 
    def get_output(self):
 
 paul@69     99 
        return sys.stdout
 
 paul@69    100 
 
 paul@69    101 
    def get_url(self):
 
 paul@69    102 
        path = self.get_path()
 
 paul@69    103 
        path_info = self.get_path_info()
 
 paul@69    104 
        return "%s%s" % (path.rstrip("/"), path_info)
 
 paul@69    105 
 
 paul@154    106 
    def new_url(self, path_info):
 
 paul@154    107 
        path = self.get_path()
 
 paul@154    108 
        return "%s/%s" % (path.rstrip("/"), path_info.lstrip("/"))
 
 paul@154    109 
 
 paul@222    110 
class ManagerHandler(Handler):
 
 paul@79    111 
 
 paul@121    112 
    """
 
 paul@121    113 
    A content handler for use by the manager, as opposed to operating within the
 
 paul@121    114 
    mail processing pipeline.
 
 paul@121    115 
    """
 
 paul@79    116 
 
 paul@121    117 
    def __init__(self, obj, user, messenger):
 
 paul@224    118 
        Handler.__init__(self, messenger=messenger)
 
 paul@224    119 
        self.set_object(obj)
 
 paul@79    120 
        self.user = user
 
 paul@82    121 
 
 paul@213    122 
        self.organiser = self.obj.get_value("ORGANIZER")
 
 paul@213    123 
        self.attendees = self.obj.get_values("ATTENDEE")
 
 paul@79    124 
 
 paul@79    125 
    # Communication methods.
 
 paul@79    126 
 
 paul@253    127 
    def send_message(self, method, sender, for_organiser):
 
 paul@79    128 
 
 paul@79    129 
        """
 
 paul@207    130 
        Create a full calendar object employing the given 'method', and send it
 
 paul@253    131 
        to the appropriate recipients, also sending a copy to the 'sender'. The
 
 paul@253    132 
        'for_organiser' value indicates whether the organiser is sending this
 
 paul@253    133 
        message.
 
 paul@79    134 
        """
 
 paul@79    135 
 
 paul@219    136 
        parts = [self.obj.to_part(method)]
 
 paul@207    137 
 
 paul@260    138 
        # As organiser, send an invitation to attendees, excluding oneself if
 
 paul@260    139 
        # also attending. The updated event will be saved by the outgoing
 
 paul@260    140 
        # handler.
 
 paul@260    141 
 
 paul@253    142 
        if for_organiser:
 
 paul@260    143 
            recipients = [get_address(attendee) for attendee in self.attendees if attendee != self.user]
 
 paul@207    144 
        else:
 
 paul@207    145 
            recipients = [get_address(self.organiser)]
 
 paul@207    146 
 
 paul@219    147 
        # Bundle free/busy information if appropriate.
 
 paul@219    148 
 
 paul@219    149 
        preferences = Preferences(self.user)
 
 paul@219    150 
 
 paul@219    151 
        if preferences.get("freebusy_sharing") == "share" and \
 
 paul@219    152 
           preferences.get("freebusy_bundling") == "always":
 
 paul@219    153 
 
 paul@222    154 
            # Invent a unique identifier.
 
 paul@222    155 
 
 paul@222    156 
            utcnow = get_timestamp()
 
 paul@222    157 
            uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))
 
 paul@222    158 
 
 paul@222    159 
            freebusy = self.store.get_freebusy(self.user)
 
 paul@222    160 
            parts.append(to_part("PUBLISH", [make_freebusy(freebusy, uid, self.user)]))
 
 paul@219    161 
 
 paul@219    162 
        message = self.messenger.make_outgoing_message(parts, recipients, outgoing_bcc=sender)
 
 paul@207    163 
        self.messenger.sendmail(recipients, message.as_string(), outgoing_bcc=sender)
 
 paul@79    164 
 
 paul@79    165 
    # Action methods.
 
 paul@79    166 
 
 paul@266    167 
    def process_received_request(self, update=False):
 
 paul@79    168 
 
 paul@79    169 
        """
 
 paul@266    170 
        Process the current request for the given 'user'. Return whether any
 
 paul@79    171 
        action was taken.
 
 paul@155    172 
 
 paul@155    173 
        If 'update' is given, the sequence number will be incremented in order
 
 paul@155    174 
        to override any previous response.
 
 paul@79    175 
        """
 
 paul@79    176 
 
 paul@266    177 
        # Reply only on behalf of this user.
 
 paul@79    178 
 
 paul@213    179 
        for attendee, attendee_attr in self.obj.get_items("ATTENDEE"):
 
 paul@79    180 
 
 paul@79    181 
            if attendee == self.user:
 
 paul@266    182 
                if attendee_attr.has_key("RSVP"):
 
 paul@266    183 
                    del attendee_attr["RSVP"]
 
 paul@128    184 
                if self.messenger and self.messenger.sender != get_address(attendee):
 
 paul@128    185 
                    attendee_attr["SENT-BY"] = get_uri(self.messenger.sender)
 
 paul@213    186 
                self.obj["ATTENDEE"] = [(attendee, attendee_attr)]
 
 paul@273    187 
 
 paul@158    188 
                self.update_dtstamp()
 
 paul@273    189 
                self.set_sequence(update)
 
 paul@155    190 
 
 paul@253    191 
                self.send_message("REPLY", get_address(attendee), for_organiser=False)
 
 paul@79    192 
 
 paul@79    193 
                return True
 
 paul@79    194 
 
 paul@79    195 
        return False
 
 paul@79    196 
 
 paul@255    197 
    def process_created_request(self, method, update=False):
 
 paul@207    198 
 
 paul@207    199 
        """
 
 paul@207    200 
        Process the current request for the given 'user', sending a created
 
 paul@255    201 
        request of the given 'method' to attendees. Return whether any action
 
 paul@255    202 
        was taken.
 
 paul@207    203 
 
 paul@207    204 
        If 'update' is given, the sequence number will be incremented in order
 
 paul@207    205 
        to override any previous message.
 
 paul@207    206 
        """
 
 paul@207    207 
 
 paul@213    208 
        organiser, organiser_attr = self.obj.get_item("ORGANIZER")
 
 paul@213    209 
 
 paul@213    210 
        if self.messenger and self.messenger.sender != get_address(organiser):
 
 paul@213    211 
            organiser_attr["SENT-BY"] = get_uri(self.messenger.sender)
 
 paul@273    212 
 
 paul@207    213 
        self.update_dtstamp()
 
 paul@273    214 
        self.set_sequence(update)
 
 paul@207    215 
 
 paul@255    216 
        self.send_message(method, get_address(self.organiser), for_organiser=True)
 
 paul@207    217 
        return True
 
 paul@207    218 
 
 paul@69    219 
class Manager:
 
 paul@69    220 
 
 paul@69    221 
    "A simple manager application."
 
 paul@69    222 
 
 paul@82    223 
    def __init__(self, messenger=None):
 
 paul@82    224 
        self.messenger = messenger or Messenger()
 
 paul@82    225 
 
 paul@212    226 
        self.encoding = "utf-8"
 
 paul@212    227 
        self.env = CGIEnvironment(self.encoding)
 
 paul@212    228 
 
 paul@69    229 
        user = self.env.get_user()
 
 paul@77    230 
        self.user = user and get_uri(user) or None
 
 paul@147    231 
        self.preferences = None
 
 paul@149    232 
        self.locale = None
 
 paul@121    233 
        self.requests = None
 
 paul@121    234 
 
 paul@69    235 
        self.out = self.env.get_output()
 
 paul@69    236 
        self.page = markup.page()
 
 paul@69    237 
 
 paul@77    238 
        self.store = imip_store.FileStore()
 
 paul@162    239 
        self.objects = {}
 
 paul@77    240 
 
 paul@77    241 
        try:
 
 paul@77    242 
            self.publisher = imip_store.FilePublisher()
 
 paul@77    243 
        except OSError:
 
 paul@77    244 
            self.publisher = None
 
 paul@77    245 
 
 paul@121    246 
    def _get_uid(self, path_info):
 
 paul@121    247 
        return path_info.lstrip("/").split("/", 1)[0]
 
 paul@121    248 
 
 paul@117    249 
    def _get_object(self, uid):
 
 paul@162    250 
        if self.objects.has_key(uid):
 
 paul@162    251 
            return self.objects[uid]
 
 paul@162    252 
 
 paul@117    253 
        f = uid and self.store.get_event(self.user, uid) or None
 
 paul@117    254 
 
 paul@117    255 
        if not f:
 
 paul@117    256 
            return None
 
 paul@117    257 
 
 paul@213    258 
        fragment = parse_object(f, "utf-8")
 
 paul@213    259 
        obj = self.objects[uid] = fragment and Object(fragment)
 
 paul@117    260 
 
 paul@121    261 
        return obj
 
 paul@121    262 
 
 paul@121    263 
    def _get_requests(self):
 
 paul@121    264 
        if self.requests is None:
 
 paul@121    265 
            self.requests = self.store.get_requests(self.user)
 
 paul@121    266 
        return self.requests
 
 paul@117    267 
 
 paul@162    268 
    def _get_request_summary(self):
 
 paul@162    269 
        summary = []
 
 paul@162    270 
        for uid in self._get_requests():
 
 paul@162    271 
            obj = self._get_object(uid)
 
 paul@162    272 
            if obj:
 
 paul@162    273 
                summary.append((
 
 paul@213    274 
                    obj.get_value("DTSTART"),
 
 paul@213    275 
                    obj.get_value("DTEND"),
 
 paul@162    276 
                    uid
 
 paul@162    277 
                    ))
 
 paul@162    278 
        return summary
 
 paul@162    279 
 
 paul@147    280 
    # Preference methods.
 
 paul@147    281 
 
 paul@149    282 
    def get_user_locale(self):
 
 paul@149    283 
        if not self.locale:
 
 paul@149    284 
            self.locale = self.get_preferences().get("LANG", "C")
 
 paul@149    285 
        return self.locale
 
 paul@147    286 
 
 paul@147    287 
    def get_preferences(self):
 
 paul@147    288 
        if not self.preferences:
 
 paul@147    289 
            self.preferences = Preferences(self.user)
 
 paul@147    290 
        return self.preferences
 
 paul@147    291 
 
 paul@244    292 
    def get_tzid(self):
 
 paul@244    293 
        prefs = self.get_preferences()
 
 paul@244    294 
        return prefs.get("TZID", "UTC")
 
 paul@244    295 
 
 paul@162    296 
    # Prettyprinting of dates and times.
 
 paul@162    297 
 
 paul@149    298 
    def format_date(self, dt, format):
 
 paul@149    299 
        return self._format_datetime(babel.dates.format_date, dt, format)
 
 paul@149    300 
 
 paul@149    301 
    def format_time(self, dt, format):
 
 paul@149    302 
        return self._format_datetime(babel.dates.format_time, dt, format)
 
 paul@149    303 
 
 paul@149    304 
    def format_datetime(self, dt, format):
 
 paul@232    305 
        return self._format_datetime(
 
 paul@232    306 
            isinstance(dt, datetime) and babel.dates.format_datetime or babel.dates.format_date,
 
 paul@232    307 
            dt, format)
 
 paul@232    308 
 
 paul@232    309 
    def format_end_datetime(self, dt, format):
 
 paul@235    310 
        if isinstance(dt, date) and not isinstance(dt, datetime):
 
 paul@232    311 
            dt = dt - timedelta(1)
 
 paul@232    312 
        return self.format_datetime(dt, format)
 
 paul@149    313 
 
 paul@149    314 
    def _format_datetime(self, fn, dt, format):
 
 paul@149    315 
        return fn(dt, format=format, locale=self.get_user_locale())
 
 paul@149    316 
 
 paul@78    317 
    # Data management methods.
 
 paul@78    318 
 
 paul@78    319 
    def remove_request(self, uid):
 
 paul@105    320 
        return self.store.dequeue_request(self.user, uid)
 
 paul@78    321 
 
 paul@234    322 
    def remove_event(self, uid):
 
 paul@234    323 
        return self.store.remove_event(self.user, uid)
 
 paul@234    324 
 
 paul@78    325 
    # Presentation methods.
 
 paul@78    326 
 
 paul@69    327 
    def new_page(self, title):
 
 paul@192    328 
        self.page.init(title=title, charset=self.encoding, css=self.env.new_url("styles.css"))
 
 paul@69    329 
 
 paul@69    330 
    def status(self, code, message):
 
 paul@123    331 
        self.header("Status", "%s %s" % (code, message))
 
 paul@123    332 
 
 paul@123    333 
    def header(self, header, value):
 
 paul@123    334 
        print >>self.out, "%s: %s" % (header, value)
 
 paul@69    335 
 
 paul@69    336 
    def no_user(self):
 
 paul@69    337 
        self.status(403, "Forbidden")
 
 paul@69    338 
        self.new_page(title="Forbidden")
 
 paul@69    339 
        self.page.p("You are not logged in and thus cannot access scheduling requests.")
 
 paul@69    340 
 
 paul@70    341 
    def no_page(self):
 
 paul@70    342 
        self.status(404, "Not Found")
 
 paul@70    343 
        self.new_page(title="Not Found")
 
 paul@70    344 
        self.page.p("No page is provided at the given address.")
 
 paul@70    345 
 
 paul@123    346 
    def redirect(self, url):
 
 paul@123    347 
        self.status(302, "Redirect")
 
 paul@123    348 
        self.header("Location", url)
 
 paul@123    349 
        self.new_page(title="Redirect")
 
 paul@123    350 
        self.page.p("Redirecting to: %s" % url)
 
 paul@123    351 
 
 paul@246    352 
    # Request logic methods.
 
 paul@121    353 
 
 paul@202    354 
    def handle_newevent(self):
 
 paul@202    355 
 
 paul@207    356 
        """
 
 paul@207    357 
        Handle any new event operation, creating a new event and redirecting to
 
 paul@207    358 
        the event page for further activity.
 
 paul@207    359 
        """
 
 paul@202    360 
 
 paul@202    361 
        # Handle a submitted form.
 
 paul@202    362 
 
 paul@202    363 
        args = self.env.get_args()
 
 paul@202    364 
 
 paul@202    365 
        if not args.has_key("newevent"):
 
 paul@202    366 
            return
 
 paul@202    367 
 
 paul@202    368 
        # Create a new event using the available information.
 
 paul@202    369 
 
 paul@236    370 
        slots = args.get("slot", [])
 
 paul@202    371 
        participants = args.get("participants", [])
 
 paul@202    372 
 
 paul@236    373 
        if not slots:
 
 paul@202    374 
            return
 
 paul@202    375 
 
 paul@273    376 
        # Obtain the user's timezone.
 
 paul@273    377 
 
 paul@273    378 
        tzid = self.get_tzid()
 
 paul@273    379 
 
 paul@236    380 
        # Coalesce the selected slots.
 
 paul@236    381 
 
 paul@236    382 
        slots.sort()
 
 paul@236    383 
        coalesced = []
 
 paul@236    384 
        last = None
 
 paul@236    385 
 
 paul@236    386 
        for slot in slots:
 
 paul@236    387 
            start, end = slot.split("-")
 
 paul@273    388 
            start = get_datetime(start, {"TZID" : tzid})
 
 paul@273    389 
            end = end and get_datetime(end, {"TZID" : tzid}) or get_start_of_next_day(start, tzid)
 
 paul@248    390 
 
 paul@236    391 
            if last:
 
 paul@248    392 
                last_start, last_end = last
 
 paul@248    393 
 
 paul@248    394 
                # Merge adjacent dates and datetimes.
 
 paul@248    395 
 
 paul@273    396 
                if start == last_end or get_start_of_day(last_end, tzid) == get_start_of_day(start, tzid):
 
 paul@248    397 
                    last = last_start, end
 
 paul@236    398 
                    continue
 
 paul@248    399 
 
 paul@248    400 
                # Handle datetimes within dates.
 
 paul@248    401 
                # Datetime periods are within single days and are therefore
 
 paul@248    402 
                # discarded.
 
 paul@248    403 
 
 paul@273    404 
                elif get_start_of_day(start, tzid) == get_start_of_day(last_start, tzid):
 
 paul@248    405 
                    continue
 
 paul@248    406 
 
 paul@248    407 
                # Add separate dates and datetimes.
 
 paul@248    408 
 
 paul@236    409 
                else:
 
 paul@236    410 
                    coalesced.append(last)
 
 paul@248    411 
 
 paul@236    412 
            last = start, end
 
 paul@236    413 
 
 paul@236    414 
        if last:
 
 paul@236    415 
            coalesced.append(last)
 
 paul@202    416 
 
 paul@202    417 
        # Invent a unique identifier.
 
 paul@202    418 
 
 paul@222    419 
        utcnow = get_timestamp()
 
 paul@202    420 
        uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))
 
 paul@202    421 
 
 paul@236    422 
        # Define a single occurrence if only one coalesced slot exists.
 
 paul@236    423 
        # Otherwise, many occurrences are defined.
 
 paul@202    424 
 
 paul@236    425 
        for i, (start, end) in enumerate(coalesced):
 
 paul@236    426 
            this_uid = "%s-%s" % (uid, i)
 
 paul@236    427 
 
 paul@252    428 
            start_value, start_attr = get_datetime_item(start, tzid)
 
 paul@252    429 
            end_value, end_attr = get_datetime_item(end, tzid)
 
 paul@239    430 
 
 paul@236    431 
            # Create a calendar object and store it as a request.
 
 paul@236    432 
 
 paul@236    433 
            record = []
 
 paul@236    434 
            rwrite = record.append
 
 paul@202    435 
 
 paul@236    436 
            rwrite(("UID", {}, this_uid))
 
 paul@236    437 
            rwrite(("SUMMARY", {}, "New event at %s" % utcnow))
 
 paul@236    438 
            rwrite(("DTSTAMP", {}, utcnow))
 
 paul@239    439 
            rwrite(("DTSTART", start_attr, start_value))
 
 paul@239    440 
            rwrite(("DTEND", end_attr, end_value))
 
 paul@236    441 
            rwrite(("ORGANIZER", {}, self.user))
 
 paul@202    442 
 
 paul@236    443 
            for participant in participants:
 
 paul@236    444 
                if not participant:
 
 paul@236    445 
                    continue
 
 paul@236    446 
                participant = get_uri(participant)
 
 paul@253    447 
                rwrite(("ATTENDEE", {"RSVP" : "TRUE", "PARTSTAT" : "NEEDS-ACTION"}, participant))
 
 paul@202    448 
 
 paul@236    449 
            obj = ("VEVENT", {}, record)
 
 paul@236    450 
 
 paul@236    451 
            self.store.set_event(self.user, this_uid, obj)
 
 paul@236    452 
            self.store.queue_request(self.user, this_uid)
 
 paul@202    453 
 
 paul@236    454 
        # Redirect to the object (or the first of the objects), where instead of
 
 paul@236    455 
        # attendee controls, there will be organiser controls.
 
 paul@236    456 
 
 paul@236    457 
        self.redirect(self.env.new_url("%s-0" % uid))
 
 paul@202    458 
 
 paul@212    459 
    def handle_request(self, uid, obj, queued):
 
 paul@121    460 
 
 paul@155    461 
        """
 
 paul@212    462 
        Handle actions involving the given 'uid' and 'obj' object, where
 
 paul@155    463 
        'queued' indicates that the object has not yet been handled.
 
 paul@155    464 
        """
 
 paul@121    465 
 
 paul@121    466 
        # Handle a submitted form.
 
 paul@121    467 
 
 paul@121    468 
        args = self.env.get_args()
 
 paul@123    469 
        handled = True
 
 paul@121    470 
 
 paul@212    471 
        # Update the object.
 
 paul@212    472 
 
 paul@212    473 
        if args.has_key("summary"):
 
 paul@213    474 
            obj["SUMMARY"] = [(args["summary"][0], {})]
 
 paul@212    475 
 
 paul@257    476 
        if args.has_key("partstat"):
 
 paul@257    477 
            attendees = obj.get_value_map("ATTENDEE")
 
 paul@257    478 
            if attendees.has_key(self.user):
 
 paul@257    479 
                attendees[self.user]["PARTSTAT"] = args["partstat"][0]
 
 paul@257    480 
 
 paul@212    481 
        # Process any action.
 
 paul@212    482 
 
 paul@266    483 
        reply = args.has_key("reply")
 
 paul@255    484 
        discard = args.has_key("discard")
 
 paul@207    485 
        invite = args.has_key("invite")
 
 paul@255    486 
        cancel = args.has_key("cancel")
 
 paul@257    487 
        save = args.has_key("save")
 
 paul@155    488 
        update = not queued and args.has_key("update")
 
 paul@121    489 
 
 paul@266    490 
        if reply or invite or cancel:
 
 paul@121    491 
 
 paul@212    492 
            handler = ManagerHandler(obj, self.user, self.messenger)
 
 paul@121    493 
 
 paul@212    494 
            # Process the object and remove it from the list of requests.
 
 paul@121    495 
 
 paul@266    496 
            if reply and handler.process_received_request(update) or \
 
 paul@255    497 
               (invite or cancel) and handler.process_created_request(invite and "REQUEST" or "CANCEL", update):
 
 paul@121    498 
 
 paul@121    499 
                self.remove_request(uid)
 
 paul@121    500 
 
 paul@257    501 
        # Save single user events.
 
 paul@121    502 
 
 paul@257    503 
        elif save:
 
 paul@257    504 
            self.store.set_event(self.user, uid, obj.to_node())
 
 paul@257    505 
            freebusy = self.store.get_freebusy(self.user)
 
 paul@257    506 
            self.remove_request(uid)
 
 paul@121    507 
 
 paul@257    508 
        # Remove the request and the object.
 
 paul@257    509 
 
 paul@257    510 
        elif discard:
 
 paul@234    511 
            self.remove_event(uid)
 
 paul@121    512 
            self.remove_request(uid)
 
 paul@121    513 
 
 paul@121    514 
        else:
 
 paul@123    515 
            handled = False
 
 paul@121    516 
 
 paul@212    517 
        # Upon handling an action, redirect to the main page.
 
 paul@212    518 
 
 paul@123    519 
        if handled:
 
 paul@123    520 
            self.redirect(self.env.get_path())
 
 paul@123    521 
 
 paul@123    522 
        return handled
 
 paul@121    523 
 
 paul@246    524 
    # Page fragment methods.
 
 paul@246    525 
 
 paul@254    526 
    def show_request_controls(self, obj, needs_update):
 
 paul@155    527 
 
 paul@155    528 
        """
 
 paul@212    529 
        Show form controls for a request concerning 'obj', indicating whether
 
 paul@254    530 
        an update will be performed if 'needs_update' is specified as a true
 
 paul@254    531 
        value.
 
 paul@155    532 
        """
 
 paul@155    533 
 
 paul@212    534 
        page = self.page
 
 paul@212    535 
 
 paul@213    536 
        is_organiser = obj.get_value("ORGANIZER") == self.user
 
 paul@207    537 
 
 paul@253    538 
        attendees = obj.get_value_map("ATTENDEE")
 
 paul@253    539 
        is_attendee = attendees.has_key(self.user)
 
 paul@253    540 
        attendee_attr = attendees.get(self.user)
 
 paul@121    541 
 
 paul@257    542 
        have_other_attendees = len(attendees) > (is_attendee and 1 or 0)
 
 paul@257    543 
 
 paul@257    544 
        # Show appropriate options depending on the role of the user.
 
 paul@257    545 
 
 paul@257    546 
        if is_attendee and not is_organiser:
 
 paul@253    547 
            partstat = attendee_attr.get("PARTSTAT")
 
 paul@266    548 
            if not partstat:
 
 paul@253    549 
                page.p("This request has not yet been dealt with.")
 
 paul@121    550 
 
 paul@255    551 
            if needs_update:
 
 paul@255    552 
                page.p("This request can be updated as follows:")
 
 paul@255    553 
            else:
 
 paul@255    554 
                page.p("An action is required for this request:")
 
 paul@253    555 
 
 paul@255    556 
            page.p()
 
 paul@266    557 
            page.input(name="reply", type="submit", value="Reply")
 
 paul@255    558 
            page.add(" ")
 
 paul@255    559 
            page.input(name="discard", type="submit", value="Discard")
 
 paul@255    560 
            page.p.close()
 
 paul@207    561 
 
 paul@255    562 
        if is_organiser:
 
 paul@257    563 
            if have_other_attendees:
 
 paul@257    564 
                if needs_update:
 
 paul@257    565 
                    page.p("As organiser, you can perform the following:")
 
 paul@257    566 
                else:
 
 paul@257    567 
                    page.p("As organiser, you will need to perform an action:")
 
 paul@255    568 
 
 paul@257    569 
                page.p()
 
 paul@257    570 
                page.input(name="invite", type="submit", value="Invite")
 
 paul@257    571 
                page.add(" ")
 
 paul@257    572 
                page.input(name="cancel", type="submit", value="Cancel")
 
 paul@257    573 
                page.p.close()
 
 paul@257    574 
            else:
 
 paul@257    575 
                page.p()
 
 paul@257    576 
                page.input(name="save", type="submit", value="Save")
 
 paul@257    577 
                page.p.close()
 
 paul@207    578 
 
 paul@207    579 
        # Updated objects need to have details updated upon sending.
 
 paul@207    580 
 
 paul@254    581 
        if needs_update:
 
 paul@212    582 
            page.input(name="update", type="hidden", value="true")
 
 paul@207    583 
 
 paul@210    584 
    object_labels = {
 
 paul@210    585 
        "SUMMARY"   : "Summary",
 
 paul@210    586 
        "DTSTART"   : "Start",
 
 paul@210    587 
        "DTEND"     : "End",
 
 paul@210    588 
        "ORGANIZER" : "Organiser",
 
 paul@210    589 
        "ATTENDEE"  : "Attendee",
 
 paul@210    590 
        }
 
 paul@210    591 
 
 paul@257    592 
    partstat_items = [
 
 paul@257    593 
        ("NEEDS-ACTION", "Not confirmed"),
 
 paul@257    594 
        ("ACCEPTED", "Attending"),
 
 paul@259    595 
        ("TENTATIVE", "Tentatively attending"),
 
 paul@257    596 
        ("DECLINED", "Not attending"),
 
 paul@257    597 
        ]
 
 paul@257    598 
 
 paul@254    599 
    def show_object_on_page(self, uid, obj, needs_update):
 
 paul@121    600 
 
 paul@121    601 
        """
 
 paul@121    602 
        Show the calendar object with the given 'uid' and representation 'obj'
 
 paul@121    603 
        on the current page.
 
 paul@121    604 
        """
 
 paul@121    605 
 
 paul@210    606 
        page = self.page
 
 paul@212    607 
        page.form(method="POST")
 
 paul@210    608 
 
 paul@154    609 
        # Obtain the user's timezone.
 
 paul@154    610 
 
 paul@244    611 
        tzid = self.get_tzid()
 
 paul@121    612 
 
 paul@121    613 
        # Provide a summary of the object.
 
 paul@121    614 
 
 paul@230    615 
        page.table(class_="object", cellspacing=5, cellpadding=5)
 
 paul@212    616 
        page.thead()
 
 paul@212    617 
        page.tr()
 
 paul@265    618 
        page.th("Event", class_="mainheading", colspan=3)
 
 paul@212    619 
        page.tr.close()
 
 paul@212    620 
        page.thead.close()
 
 paul@212    621 
        page.tbody()
 
 paul@121    622 
 
 paul@269    623 
        is_organiser = obj.get_value("ORGANIZER") == self.user
 
 paul@269    624 
 
 paul@121    625 
        for name in ["SUMMARY", "DTSTART", "DTEND", "ORGANIZER", "ATTENDEE"]:
 
 paul@210    626 
            page.tr()
 
 paul@210    627 
 
 paul@210    628 
            label = self.object_labels.get(name, name)
 
 paul@210    629 
 
 paul@210    630 
            # Handle datetimes specially.
 
 paul@210    631 
 
 paul@147    632 
            if name in ["DTSTART", "DTEND"]:
 
 paul@213    633 
                value, attr = obj.get_item(name)
 
 paul@154    634 
                tzid = attr.get("TZID", tzid)
 
 paul@232    635 
                value = (
 
 paul@232    636 
                    name == "DTSTART" and self.format_datetime or self.format_end_datetime
 
 paul@232    637 
                    )(to_timezone(get_datetime(value), tzid), "full")
 
 paul@210    638 
                page.th(label, class_="objectheading")
 
 paul@265    639 
                page.td(value, colspan=2)
 
 paul@210    640 
                page.tr.close()
 
 paul@210    641 
 
 paul@212    642 
            # Handle the summary specially.
 
 paul@212    643 
 
 paul@212    644 
            elif name == "SUMMARY":
 
 paul@213    645 
                value = obj.get_value(name)
 
 paul@212    646 
                page.th(label, class_="objectheading")
 
 paul@265    647 
                page.td(colspan=2)
 
 paul@269    648 
                if is_organiser:
 
 paul@269    649 
                    page.input(name="summary", type="text", value=value, size=80)
 
 paul@269    650 
                else:
 
 paul@269    651 
                    page.add(value)
 
 paul@212    652 
                page.td.close()
 
 paul@212    653 
                page.tr.close()
 
 paul@212    654 
 
 paul@210    655 
            # Handle potentially many values.
 
 paul@210    656 
 
 paul@147    657 
            else:
 
 paul@213    658 
                items = obj.get_items(name)
 
 paul@233    659 
                if not items:
 
 paul@233    660 
                    continue
 
 paul@233    661 
 
 paul@210    662 
                page.th(label, class_="objectheading", rowspan=len(items))
 
 paul@210    663 
 
 paul@210    664 
                first = True
 
 paul@210    665 
 
 paul@210    666 
                for value, attr in items:
 
 paul@210    667 
                    if not first:
 
 paul@210    668 
                        page.tr()
 
 paul@210    669 
                    else:
 
 paul@210    670 
                        first = False
 
 paul@121    671 
 
 paul@265    672 
                    if name == "ATTENDEE":
 
 paul@265    673 
                        page.td(class_="objectattribute")
 
 paul@265    674 
                        page.add(value)
 
 paul@265    675 
                        page.td.close()
 
 paul@265    676 
                        page.td(class_="partstat")
 
 paul@210    677 
 
 paul@210    678 
                        partstat = attr.get("PARTSTAT")
 
 paul@269    679 
                        if value == self.user:
 
 paul@257    680 
                            self._show_menu("partstat", partstat, self.partstat_items)
 
 paul@265    681 
                        else:
 
 paul@265    682 
                            page.add(dict(self.partstat_items).get(partstat, ""))
 
 paul@265    683 
                    else:
 
 paul@265    684 
                        page.td(class_="objectattribute", colspan=2)
 
 paul@265    685 
                        page.add(value)
 
 paul@210    686 
 
 paul@210    687 
                    page.td.close()
 
 paul@210    688 
                    page.tr.close()
 
 paul@210    689 
 
 paul@212    690 
        page.tbody.close()
 
 paul@210    691 
        page.table.close()
 
 paul@121    692 
 
 paul@213    693 
        dtstart = format_datetime(obj.get_utc_datetime("DTSTART"))
 
 paul@213    694 
        dtend = format_datetime(obj.get_utc_datetime("DTEND"))
 
 paul@121    695 
 
 paul@121    696 
        # Indicate whether there are conflicting events.
 
 paul@121    697 
 
 paul@121    698 
        freebusy = self.store.get_freebusy(self.user)
 
 paul@121    699 
 
 paul@121    700 
        if freebusy:
 
 paul@121    701 
 
 paul@121    702 
            # Obtain any time zone details from the suggested event.
 
 paul@121    703 
 
 paul@213    704 
            _dtstart, attr = obj.get_item("DTSTART")
 
 paul@154    705 
            tzid = attr.get("TZID", tzid)
 
 paul@121    706 
 
 paul@121    707 
            # Show any conflicts.
 
 paul@121    708 
 
 paul@121    709 
            for t in have_conflict(freebusy, [(dtstart, dtend)], True):
 
 paul@121    710 
                start, end, found_uid = t[:3]
 
 paul@154    711 
 
 paul@154    712 
                # Provide details of any conflicting event.
 
 paul@154    713 
 
 paul@121    714 
                if uid != found_uid:
 
 paul@149    715 
                    start = self.format_datetime(to_timezone(get_datetime(start), tzid), "full")
 
 paul@149    716 
                    end = self.format_datetime(to_timezone(get_datetime(end), tzid), "full")
 
 paul@210    717 
                    page.p("Event conflicts with another from %s to %s: " % (start, end))
 
 paul@154    718 
 
 paul@154    719 
                    # Show the event summary for the conflicting event.
 
 paul@154    720 
 
 paul@154    721 
                    found_obj = self._get_object(found_uid)
 
 paul@154    722 
                    if found_obj:
 
 paul@213    723 
                        page.a(found_obj.get_value("SUMMARY"), href=self.env.new_url(found_uid))
 
 paul@121    724 
 
 paul@254    725 
        self.show_request_controls(obj, needs_update)
 
 paul@212    726 
        page.form.close()
 
 paul@212    727 
 
 paul@121    728 
    def show_requests_on_page(self):
 
 paul@69    729 
 
 paul@69    730 
        "Show requests for the current user."
 
 paul@69    731 
 
 paul@69    732 
        # NOTE: This list could be more informative, but it is envisaged that
 
 paul@69    733 
        # NOTE: the requests would be visited directly anyway.
 
 paul@69    734 
 
 paul@121    735 
        requests = self._get_requests()
 
 paul@70    736 
 
 paul@185    737 
        self.page.div(id="pending-requests")
 
 paul@185    738 
 
 paul@80    739 
        if requests:
 
 paul@114    740 
            self.page.p("Pending requests:")
 
 paul@114    741 
 
 paul@80    742 
            self.page.ul()
 
 paul@69    743 
 
 paul@80    744 
            for request in requests:
 
 paul@165    745 
                obj = self._get_object(request)
 
 paul@165    746 
                if obj:
 
 paul@165    747 
                    self.page.li()
 
 paul@213    748 
                    self.page.a(obj.get_value("SUMMARY"), href="#request-%s" % request)
 
 paul@165    749 
                    self.page.li.close()
 
 paul@80    750 
 
 paul@80    751 
            self.page.ul.close()
 
 paul@80    752 
 
 paul@80    753 
        else:
 
 paul@80    754 
            self.page.p("There are no pending requests.")
 
 paul@69    755 
 
 paul@185    756 
        self.page.div.close()
 
 paul@185    757 
 
 paul@185    758 
    def show_participants_on_page(self):
 
 paul@185    759 
 
 paul@185    760 
        "Show participants for scheduling purposes."
 
 paul@185    761 
 
 paul@185    762 
        args = self.env.get_args()
 
 paul@185    763 
        participants = args.get("participants", [])
 
 paul@185    764 
 
 paul@185    765 
        try:
 
 paul@185    766 
            for name, value in args.items():
 
 paul@185    767 
                if name.startswith("remove-participant-"):
 
 paul@185    768 
                    i = int(name[len("remove-participant-"):])
 
 paul@185    769 
                    del participants[i]
 
 paul@185    770 
                    break
 
 paul@185    771 
        except ValueError:
 
 paul@185    772 
            pass
 
 paul@185    773 
 
 paul@185    774 
        # Trim empty participants.
 
 paul@185    775 
 
 paul@185    776 
        while participants and not participants[-1].strip():
 
 paul@185    777 
            participants.pop()
 
 paul@185    778 
 
 paul@185    779 
        # Show any specified participants together with controls to remove and
 
 paul@185    780 
        # add participants.
 
 paul@185    781 
 
 paul@185    782 
        self.page.div(id="participants")
 
 paul@185    783 
 
 paul@185    784 
        self.page.p("Participants for scheduling:")
 
 paul@185    785 
 
 paul@185    786 
        for i, participant in enumerate(participants):
 
 paul@185    787 
            self.page.p()
 
 paul@185    788 
            self.page.input(name="participants", type="text", value=participant)
 
 paul@185    789 
            self.page.input(name="remove-participant-%d" % i, type="submit", value="Remove")
 
 paul@185    790 
            self.page.p.close()
 
 paul@185    791 
 
 paul@185    792 
        self.page.p()
 
 paul@185    793 
        self.page.input(name="participants", type="text")
 
 paul@185    794 
        self.page.input(name="add-participant", type="submit", value="Add")
 
 paul@185    795 
        self.page.p.close()
 
 paul@185    796 
 
 paul@185    797 
        self.page.div.close()
 
 paul@185    798 
 
 paul@185    799 
        return participants
 
 paul@185    800 
 
 paul@121    801 
    # Full page output methods.
 
 paul@70    802 
 
 paul@121    803 
    def show_object(self, path_info):
 
 paul@70    804 
 
 paul@121    805 
        "Show an object request using the given 'path_info' for the current user."
 
 paul@70    806 
 
 paul@121    807 
        uid = self._get_uid(path_info)
 
 paul@121    808 
        obj = self._get_object(uid)
 
 paul@121    809 
 
 paul@121    810 
        if not obj:
 
 paul@70    811 
            return False
 
 paul@70    812 
 
 paul@123    813 
        is_request = uid in self._get_requests()
 
 paul@155    814 
        handled = self.handle_request(uid, obj, is_request)
 
 paul@77    815 
 
 paul@123    816 
        if handled:
 
 paul@123    817 
            return True
 
 paul@73    818 
 
 paul@123    819 
        self.new_page(title="Event")
 
 paul@254    820 
        self.show_object_on_page(uid, obj, not is_request)
 
 paul@73    821 
 
 paul@70    822 
        return True
 
 paul@70    823 
 
 paul@114    824 
    def show_calendar(self):
 
 paul@114    825 
 
 paul@114    826 
        "Show the calendar for the current user."
 
 paul@114    827 
 
 paul@202    828 
        handled = self.handle_newevent()
 
 paul@202    829 
 
 paul@114    830 
        self.new_page(title="Calendar")
 
 paul@162    831 
        page = self.page
 
 paul@162    832 
 
 paul@196    833 
        # Form controls are used in various places on the calendar page.
 
 paul@196    834 
 
 paul@196    835 
        page.form(method="POST")
 
 paul@196    836 
 
 paul@121    837 
        self.show_requests_on_page()
 
 paul@185    838 
        participants = self.show_participants_on_page()
 
 paul@114    839 
 
 paul@196    840 
        # Show a button for scheduling a new event.
 
 paul@196    841 
 
 paul@230    842 
        page.p(class_="controls")
 
 paul@196    843 
        page.input(name="newevent", type="submit", value="New event", id="newevent")
 
 paul@258    844 
        page.input(name="reset", type="submit", value="Clear selections", id="reset")
 
 paul@196    845 
        page.p.close()
 
 paul@196    846 
 
 paul@231    847 
        # Show controls for hiding empty and busy slots.
 
 paul@203    848 
        # The positioning of the control, paragraph and table are important here.
 
 paul@203    849 
 
 paul@203    850 
        page.input(name="hideslots", type="checkbox", value="hide", id="hideslots")
 
 paul@231    851 
        page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy")
 
 paul@203    852 
 
 paul@230    853 
        page.p(class_="controls")
 
 paul@237    854 
        page.label("Hide busy time periods", for_="hidebusy", class_="hidebusy enable")
 
 paul@237    855 
        page.label("Show busy time periods", for_="hidebusy", class_="hidebusy disable")
 
 paul@237    856 
        page.label("Hide unused time periods", for_="hideslots", class_="hideslots enable")
 
 paul@237    857 
        page.label("Show unused time periods", for_="hideslots", class_="hideslots disable")
 
 paul@203    858 
        page.p.close()
 
 paul@203    859 
 
 paul@114    860 
        freebusy = self.store.get_freebusy(self.user)
 
 paul@114    861 
 
 paul@114    862 
        if not freebusy:
 
 paul@114    863 
            page.p("No events scheduled.")
 
 paul@114    864 
            return
 
 paul@114    865 
 
 paul@154    866 
        # Obtain the user's timezone.
 
 paul@147    867 
 
 paul@244    868 
        tzid = self.get_tzid()
 
 paul@147    869 
 
 paul@114    870 
        # Day view: start at the earliest known day and produce days until the
 
 paul@114    871 
        # latest known day, perhaps with expandable sections of empty days.
 
 paul@114    872 
 
 paul@114    873 
        # Month view: start at the earliest known month and produce months until
 
 paul@114    874 
        # the latest known month, perhaps with expandable sections of empty
 
 paul@114    875 
        # months.
 
 paul@114    876 
 
 paul@114    877 
        # Details of users to invite to new events could be superimposed on the
 
 paul@114    878 
        # calendar.
 
 paul@114    879 
 
 paul@185    880 
        # Requests are listed and linked to their tentative positions in the
 
 paul@185    881 
        # calendar. Other participants are also shown.
 
 paul@185    882 
 
 paul@185    883 
        request_summary = self._get_request_summary()
 
 paul@185    884 
 
 paul@185    885 
        period_groups = [request_summary, freebusy]
 
 paul@185    886 
        period_group_types = ["request", "freebusy"]
 
 paul@185    887 
        period_group_sources = ["Pending requests", "Your schedule"]
 
 paul@185    888 
 
 paul@187    889 
        for i, participant in enumerate(participants):
 
 paul@185    890 
            period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))
 
 paul@187    891 
            period_group_types.append("freebusy-part%d" % i)
 
 paul@185    892 
            period_group_sources.append(participant)
 
 paul@114    893 
 
 paul@162    894 
        groups = []
 
 paul@162    895 
        group_columns = []
 
 paul@185    896 
        group_types = period_group_types
 
 paul@185    897 
        group_sources = period_group_sources
 
 paul@162    898 
        all_points = set()
 
 paul@162    899 
 
 paul@162    900 
        # Obtain time point information for each group of periods.
 
 paul@162    901 
 
 paul@185    902 
        for periods in period_groups:
 
 paul@162    903 
            periods = convert_periods(periods, tzid)
 
 paul@162    904 
 
 paul@162    905 
            # Get the time scale with start and end points.
 
 paul@162    906 
 
 paul@162    907 
            scale = get_scale(periods)
 
 paul@162    908 
 
 paul@162    909 
            # Get the time slots for the periods.
 
 paul@162    910 
 
 paul@162    911 
            slots = get_slots(scale)
 
 paul@162    912 
 
 paul@162    913 
            # Add start of day time points for multi-day periods.
 
 paul@162    914 
 
 paul@244    915 
            add_day_start_points(slots, tzid)
 
 paul@162    916 
 
 paul@162    917 
            # Record the slots and all time points employed.
 
 paul@162    918 
 
 paul@162    919 
            groups.append(slots)
 
 paul@201    920 
            all_points.update([point for point, active in slots])
 
 paul@162    921 
 
 paul@162    922 
        # Partition the groups into days.
 
 paul@162    923 
 
 paul@162    924 
        days = {}
 
 paul@162    925 
        partitioned_groups = []
 
 paul@171    926 
        partitioned_group_types = []
 
 paul@185    927 
        partitioned_group_sources = []
 
 paul@162    928 
 
 paul@185    929 
        for slots, group_type, group_source in zip(groups, group_types, group_sources):
 
 paul@162    930 
 
 paul@162    931 
            # Propagate time points to all groups of time slots.
 
 paul@162    932 
 
 paul@162    933 
            add_slots(slots, all_points)
 
 paul@162    934 
 
 paul@162    935 
            # Count the number of columns employed by the group.
 
 paul@162    936 
 
 paul@162    937 
            columns = 0
 
 paul@162    938 
 
 paul@162    939 
            # Partition the time slots by day.
 
 paul@162    940 
 
 paul@162    941 
            partitioned = {}
 
 paul@162    942 
 
 paul@162    943 
            for day, day_slots in partition_by_day(slots).items():
 
 paul@201    944 
                intervals = []
 
 paul@201    945 
                last = None
 
 paul@201    946 
 
 paul@201    947 
                for point, active in day_slots:
 
 paul@201    948 
                    columns = max(columns, len(active))
 
 paul@201    949 
                    if last:
 
 paul@201    950 
                        intervals.append((last, point))
 
 paul@201    951 
                    last = point
 
 paul@201    952 
 
 paul@201    953 
                if last:
 
 paul@201    954 
                    intervals.append((last, None))
 
 paul@162    955 
 
 paul@162    956 
                if not days.has_key(day):
 
 paul@162    957 
                    days[day] = set()
 
 paul@162    958 
 
 paul@162    959 
                # Convert each partition to a mapping from points to active
 
 paul@162    960 
                # periods.
 
 paul@162    961 
 
 paul@201    962 
                partitioned[day] = dict(day_slots)
 
 paul@201    963 
 
 paul@201    964 
                # Record the divisions or intervals within each day.
 
 paul@201    965 
 
 paul@201    966 
                days[day].update(intervals)
 
 paul@162    967 
 
 paul@194    968 
            if group_type != "request" or columns:
 
 paul@194    969 
                group_columns.append(columns)
 
 paul@194    970 
                partitioned_groups.append(partitioned)
 
 paul@194    971 
                partitioned_group_types.append(group_type)
 
 paul@194    972 
                partitioned_group_sources.append(group_source)
 
 paul@114    973 
 
 paul@243    974 
        self.show_calendar_day_controls(days)
 
 paul@243    975 
 
 paul@230    976 
        page.table(cellspacing=5, cellpadding=5, class_="calendar")
 
 paul@188    977 
        self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)
 
 paul@171    978 
        self.show_calendar_days(days, partitioned_groups, partitioned_group_types, group_columns)
 
 paul@162    979 
        page.table.close()
 
 paul@114    980 
 
 paul@196    981 
        # End the form region.
 
 paul@196    982 
 
 paul@196    983 
        page.form.close()
 
 paul@196    984 
 
 paul@246    985 
    # More page fragment methods.
 
 paul@246    986 
 
 paul@243    987 
    def show_calendar_day_controls(self, days):
 
 paul@243    988 
 
 paul@243    989 
        "Show controls for the given 'days' in the calendar."
 
 paul@243    990 
 
 paul@243    991 
        page = self.page
 
 paul@243    992 
        slots = self.env.get_args().get("slot", [])
 
 paul@243    993 
 
 paul@243    994 
        for day in days:
 
 paul@243    995 
            value, identifier = self._day_value_and_identifier(day)
 
 paul@243    996 
            self._slot_selector(value, identifier, slots)
 
 paul@243    997 
 
 paul@243    998 
        # Generate a dynamic stylesheet to allow day selections to colour
 
 paul@243    999 
        # specific days.
 
 paul@243   1000 
        # NOTE: The style details need to be coordinated with the static
 
 paul@243   1001 
        # NOTE: stylesheet.
 
 paul@243   1002 
 
 paul@243   1003 
        page.style(type="text/css")
 
 paul@243   1004 
 
 paul@243   1005 
        for day in days:
 
 paul@243   1006 
            daystr = format_datetime(day)
 
 paul@243   1007 
            page.add("""\
 
 paul@249   1008 
input.newevent.selector#day-%s-:checked ~ table label.day.day-%s,
 
 paul@249   1009 
input.newevent.selector#day-%s-:checked ~ table label.timepoint.day-%s {
 
 paul@243   1010 
    background-color: #5f4;
 
 paul@243   1011 
    text-decoration: underline;
 
 paul@243   1012 
}
 
 paul@243   1013 
""" % (daystr, daystr, daystr, daystr))
 
 paul@243   1014 
 
 paul@243   1015 
        page.style.close()
 
 paul@243   1016 
 
 paul@188   1017 
    def show_calendar_participant_headings(self, group_types, group_sources, group_columns):
 
 paul@186   1018 
 
 paul@186   1019 
        """
 
 paul@186   1020 
        Show headings for the participants and other scheduling contributors,
 
 paul@188   1021 
        defined by 'group_types', 'group_sources' and 'group_columns'.
 
 paul@186   1022 
        """
 
 paul@186   1023 
 
 paul@185   1024 
        page = self.page
 
 paul@185   1025 
 
 paul@188   1026 
        page.colgroup(span=1, id="columns-timeslot")
 
 paul@186   1027 
 
 paul@188   1028 
        for group_type, columns in zip(group_types, group_columns):
 
 paul@191   1029 
            page.colgroup(span=max(columns, 1), id="columns-%s" % group_type)
 
 paul@186   1030 
 
 paul@185   1031 
        page.thead()
 
 paul@185   1032 
        page.tr()
 
 paul@185   1033 
        page.th("", class_="emptyheading")
 
 paul@185   1034 
 
 paul@193   1035 
        for group_type, source, columns in zip(group_types, group_sources, group_columns):
 
 paul@193   1036 
            page.th(source,
 
 paul@193   1037 
                class_=(group_type == "request" and "requestheading" or "participantheading"),
 
 paul@193   1038 
                colspan=max(columns, 1))
 
 paul@185   1039 
 
 paul@185   1040 
        page.tr.close()
 
 paul@185   1041 
        page.thead.close()
 
 paul@185   1042 
 
 paul@171   1043 
    def show_calendar_days(self, days, partitioned_groups, partitioned_group_types, group_columns):
 
 paul@186   1044 
 
 paul@186   1045 
        """
 
 paul@186   1046 
        Show calendar days, defined by a collection of 'days', the contributing
 
 paul@186   1047 
        period information as 'partitioned_groups' (partitioned by day), the
 
 paul@186   1048 
        'partitioned_group_types' indicating the kind of contribution involved,
 
 paul@186   1049 
        and the 'group_columns' defining the number of columns in each group.
 
 paul@186   1050 
        """
 
 paul@186   1051 
 
 paul@162   1052 
        page = self.page
 
 paul@162   1053 
 
 paul@191   1054 
        # Determine the number of columns required. Where participants provide
 
 paul@191   1055 
        # no columns for events, one still needs to be provided for the
 
 paul@191   1056 
        # participant itself.
 
 paul@147   1057 
 
 paul@191   1058 
        all_columns = sum([max(columns, 1) for columns in group_columns])
 
 paul@191   1059 
 
 paul@191   1060 
        # Determine the days providing time slots.
 
 paul@191   1061 
 
 paul@162   1062 
        all_days = days.items()
 
 paul@162   1063 
        all_days.sort()
 
 paul@162   1064 
 
 paul@162   1065 
        # Produce a heading and time points for each day.
 
 paul@162   1066 
 
 paul@201   1067 
        for day, intervals in all_days:
 
 paul@186   1068 
            page.thead()
 
 paul@114   1069 
            page.tr()
 
 paul@243   1070 
            page.th(class_="dayheading container", colspan=all_columns+1)
 
 paul@239   1071 
            self._day_heading(day)
 
 paul@114   1072 
            page.th.close()
 
 paul@153   1073 
            page.tr.close()
 
 paul@186   1074 
            page.thead.close()
 
 paul@114   1075 
 
 paul@162   1076 
            groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]
 
 paul@162   1077 
 
 paul@186   1078 
            page.tbody()
 
 paul@201   1079 
            self.show_calendar_points(intervals, groups_for_day, partitioned_group_types, group_columns)
 
 paul@186   1080 
            page.tbody.close()
 
 paul@185   1081 
 
 paul@201   1082 
    def show_calendar_points(self, intervals, groups, group_types, group_columns):
 
 paul@186   1083 
 
 paul@186   1084 
        """
 
 paul@201   1085 
        Show the time 'intervals' along with period information from the given
 
 paul@186   1086 
        'groups', having the indicated 'group_types', each with the number of
 
 paul@186   1087 
        columns given by 'group_columns'.
 
 paul@186   1088 
        """
 
 paul@186   1089 
 
 paul@162   1090 
        page = self.page
 
 paul@162   1091 
 
 paul@244   1092 
        # Obtain the user's timezone.
 
 paul@244   1093 
 
 paul@244   1094 
        tzid = self.get_tzid()
 
 paul@244   1095 
 
 paul@203   1096 
        # Produce a row for each interval.
 
 paul@162   1097 
 
 paul@201   1098 
        intervals = list(intervals)
 
 paul@201   1099 
        intervals.sort()
 
 paul@162   1100 
 
 paul@201   1101 
        for point, endpoint in intervals:
 
 paul@244   1102 
            continuation = point == get_start_of_day(point, tzid)
 
 paul@153   1103 
 
 paul@203   1104 
            # Some rows contain no period details and are marked as such.
 
 paul@203   1105 
 
 paul@203   1106 
            have_active = reduce(lambda x, y: x or y, [slots.get(point) for slots in groups], None)
 
 paul@203   1107 
 
 paul@203   1108 
            css = " ".join(
 
 paul@203   1109 
                ["slot"] +
 
 paul@231   1110 
                (have_active and ["busy"] or ["empty"]) +
 
 paul@203   1111 
                (continuation and ["daystart"] or [])
 
 paul@203   1112 
                )
 
 paul@203   1113 
 
 paul@203   1114 
            page.tr(class_=css)
 
 paul@162   1115 
            page.th(class_="timeslot")
 
 paul@201   1116 
            self._time_point(point, endpoint)
 
 paul@162   1117 
            page.th.close()
 
 paul@162   1118 
 
 paul@162   1119 
            # Obtain slots for the time point from each group.
 
 paul@162   1120 
 
 paul@171   1121 
            for columns, slots, group_type in zip(group_columns, groups, group_types):
 
 paul@162   1122 
                active = slots and slots.get(point)
 
 paul@162   1123 
 
 paul@191   1124 
                # Where no periods exist for the given time interval, generate
 
 paul@191   1125 
                # an empty cell. Where a participant provides no periods at all,
 
 paul@191   1126 
                # the colspan is adjusted to be 1, not 0.
 
 paul@191   1127 
 
 paul@162   1128 
                if not active:
 
 paul@196   1129 
                    page.td(class_="empty container", colspan=max(columns, 1))
 
 paul@201   1130 
                    self._empty_slot(point, endpoint)
 
 paul@196   1131 
                    page.td.close()
 
 paul@162   1132 
                    continue
 
 paul@162   1133 
 
 paul@162   1134 
                slots = slots.items()
 
 paul@162   1135 
                slots.sort()
 
 paul@162   1136 
                spans = get_spans(slots)
 
 paul@162   1137 
 
 paul@162   1138 
                # Show a column for each active period.
 
 paul@117   1139 
 
 paul@153   1140 
                for t in active:
 
 paul@185   1141 
                    if t and len(t) >= 2:
 
 paul@185   1142 
                        start, end, uid, key = get_freebusy_details(t)
 
 paul@185   1143 
                        span = spans[key]
 
 paul@171   1144 
 
 paul@171   1145 
                        # Produce a table cell only at the start of the period
 
 paul@171   1146 
                        # or when continued at the start of a day.
 
 paul@171   1147 
 
 paul@153   1148 
                        if point == start or continuation:
 
 paul@153   1149 
 
 paul@275   1150 
                            obj = self._get_object(uid)
 
 paul@275   1151 
 
 paul@195   1152 
                            has_continued = continuation and point != start
 
 paul@244   1153 
                            will_continue = not ends_on_same_day(point, end, tzid)
 
 paul@275   1154 
                            is_organiser = obj.get_value("ORGANIZER") == self.user
 
 paul@275   1155 
 
 paul@195   1156 
                            css = " ".join(
 
 paul@195   1157 
                                ["event"] +
 
 paul@195   1158 
                                (has_continued and ["continued"] or []) +
 
 paul@275   1159 
                                (will_continue and ["continues"] or []) +
 
 paul@275   1160 
                                (is_organiser and ["organising"] or ["attending"])
 
 paul@195   1161 
                                )
 
 paul@195   1162 
 
 paul@189   1163 
                            # Only anchor the first cell of events.
 
 paul@189   1164 
 
 paul@189   1165 
                            if point == start:
 
 paul@195   1166 
                                page.td(class_=css, rowspan=span, id="%s-%s" % (group_type, uid))
 
 paul@189   1167 
                            else:
 
 paul@195   1168 
                                page.td(class_=css, rowspan=span)
 
 paul@171   1169 
 
 paul@185   1170 
                            if not obj:
 
 paul@185   1171 
                                page.span("")
 
 paul@185   1172 
                            else:
 
 paul@213   1173 
                                summary = obj.get_value("SUMMARY")
 
 paul@171   1174 
 
 paul@171   1175 
                                # Only link to events if they are not being
 
 paul@171   1176 
                                # updated by requests.
 
 paul@171   1177 
 
 paul@171   1178 
                                if uid in self._get_requests() and group_type != "request":
 
 paul@189   1179 
                                    page.span(summary)
 
 paul@164   1180 
                                else:
 
 paul@171   1181 
                                    href = "%s/%s" % (self.env.get_url().rstrip("/"), uid)
 
 paul@189   1182 
                                    page.a(summary, href=href)
 
 paul@171   1183 
 
 paul@153   1184 
                            page.td.close()
 
 paul@153   1185 
                    else:
 
 paul@196   1186 
                        page.td(class_="empty container")
 
 paul@201   1187 
                        self._empty_slot(point, endpoint)
 
 paul@196   1188 
                        page.td.close()
 
 paul@114   1189 
 
 paul@166   1190 
                # Pad with empty columns.
 
 paul@166   1191 
 
 paul@166   1192 
                i = columns - len(active)
 
 paul@166   1193 
                while i > 0:
 
 paul@166   1194 
                    i -= 1
 
 paul@196   1195 
                    page.td(class_="empty container")
 
 paul@201   1196 
                    self._empty_slot(point, endpoint)
 
 paul@196   1197 
                    page.td.close()
 
 paul@166   1198 
 
 paul@162   1199 
            page.tr.close()
 
 paul@114   1200 
 
 paul@239   1201 
    def _day_heading(self, day):
 
 paul@243   1202 
 
 paul@243   1203 
        """
 
 paul@243   1204 
        Generate a heading for 'day' of the following form:
 
 paul@243   1205 
 
 paul@243   1206 
        <label class="day day-20150203" for="day-20150203">Tuesday, 3 February 2015</label>
 
 paul@243   1207 
        """
 
 paul@243   1208 
 
 paul@239   1209 
        page = self.page
 
 paul@243   1210 
        daystr = format_datetime(day)
 
 paul@239   1211 
        value, identifier = self._day_value_and_identifier(day)
 
 paul@243   1212 
        page.label(self.format_date(day, "full"), class_="day day-%s" % daystr, for_=identifier)
 
 paul@239   1213 
 
 paul@201   1214 
    def _time_point(self, point, endpoint):
 
 paul@243   1215 
 
 paul@243   1216 
        """
 
 paul@243   1217 
        Generate headings for the 'point' to 'endpoint' period of the following
 
 paul@243   1218 
        form:
 
 paul@243   1219 
 
 paul@243   1220 
        <label class="timepoint day-20150203" for="slot-20150203T090000-20150203T100000">09:00:00 CET</label>
 
 paul@243   1221 
        <span class="endpoint">10:00:00 CET</span>
 
 paul@243   1222 
        """
 
 paul@243   1223 
 
 paul@201   1224 
        page = self.page
 
 paul@244   1225 
        tzid = self.get_tzid()
 
 paul@243   1226 
        daystr = format_datetime(point.date())
 
 paul@201   1227 
        value, identifier = self._slot_value_and_identifier(point, endpoint)
 
 paul@238   1228 
        slots = self.env.get_args().get("slot", [])
 
 paul@239   1229 
        self._slot_selector(value, identifier, slots)
 
 paul@243   1230 
        page.label(self.format_time(point, "long"), class_="timepoint day-%s" % daystr, for_=identifier)
 
 paul@244   1231 
        page.span(self.format_time(endpoint or get_end_of_day(point, tzid), "long"), class_="endpoint")
 
 paul@239   1232 
 
 paul@239   1233 
    def _slot_selector(self, value, identifier, slots):
 
 paul@258   1234 
        reset = self.env.get_args().has_key("reset")
 
 paul@239   1235 
        page = self.page
 
 paul@258   1236 
        if not reset and value in slots:
 
 paul@249   1237 
            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector", checked="checked")
 
 paul@202   1238 
        else:
 
 paul@249   1239 
            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector")
 
 paul@201   1240 
 
 paul@201   1241 
    def _empty_slot(self, point, endpoint):
 
 paul@197   1242 
        page = self.page
 
 paul@201   1243 
        value, identifier = self._slot_value_and_identifier(point, endpoint)
 
 paul@236   1244 
        page.label("Select/deselect period", class_="newevent popup", for_=identifier)
 
 paul@196   1245 
 
 paul@239   1246 
    def _day_value_and_identifier(self, day):
 
 paul@239   1247 
        value = "%s-" % format_datetime(day)
 
 paul@239   1248 
        identifier = "day-%s" % value
 
 paul@239   1249 
        return value, identifier
 
 paul@239   1250 
 
 paul@201   1251 
    def _slot_value_and_identifier(self, point, endpoint):
 
 paul@202   1252 
        value = "%s-%s" % (format_datetime(point), endpoint and format_datetime(endpoint) or "")
 
 paul@201   1253 
        identifier = "slot-%s" % value
 
 paul@201   1254 
        return value, identifier
 
 paul@196   1255 
 
 paul@257   1256 
    def _show_menu(self, name, value, items):
 
 paul@257   1257 
        page = self.page
 
 paul@257   1258 
        values = self.env.get_args().get(name, [value])
 
 paul@257   1259 
        page.select(name=name)
 
 paul@257   1260 
        for v, label in items:
 
 paul@257   1261 
            if v in values:
 
 paul@257   1262 
                page.option(label, value=v, selected="selected")
 
 paul@257   1263 
            else:
 
 paul@257   1264 
                page.option(label, value=v)
 
 paul@257   1265 
        page.select.close()
 
 paul@257   1266 
 
 paul@246   1267 
    # Incoming HTTP request direction.
 
 paul@246   1268 
 
 paul@69   1269 
    def select_action(self):
 
 paul@69   1270 
 
 paul@69   1271 
        "Select the desired action and show the result."
 
 paul@69   1272 
 
 paul@121   1273 
        path_info = self.env.get_path_info().strip("/")
 
 paul@121   1274 
 
 paul@69   1275 
        if not path_info:
 
 paul@114   1276 
            self.show_calendar()
 
 paul@121   1277 
        elif self.show_object(path_info):
 
 paul@70   1278 
            pass
 
 paul@70   1279 
        else:
 
 paul@70   1280 
            self.no_page()
 
 paul@69   1281 
 
 paul@82   1282 
    def __call__(self):
 
 paul@69   1283 
 
 paul@69   1284 
        "Interpret a request and show an appropriate response."
 
 paul@69   1285 
 
 paul@69   1286 
        if not self.user:
 
 paul@69   1287 
            self.no_user()
 
 paul@69   1288 
        else:
 
 paul@69   1289 
            self.select_action()
 
 paul@69   1290 
 
 paul@70   1291 
        # Write the headers and actual content.
 
 paul@70   1292 
 
 paul@69   1293 
        print >>self.out, "Content-Type: text/html; charset=%s" % self.encoding
 
 paul@69   1294 
        print >>self.out
 
 paul@69   1295 
        self.out.write(unicode(self.page).encode(self.encoding))
 
 paul@69   1296 
 
 paul@69   1297 
if __name__ == "__main__":
 
 paul@128   1298 
    Manager()()
 
 paul@69   1299 
 
 paul@69   1300 
# vim: tabstop=4 expandtab shiftwidth=4