imip-agent

Annotated imip_manager.py

239:96006c733107
238:55be9e306c65
237:423eb08d06b9
2015-02-03 Paul Boddie file changeset files shortlog Preserved checkbox selections upon form submission.
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@153     36 
from imiptools.dates import format_datetime, get_datetime, get_start_of_day, \
 
 paul@222     37 
                            get_end_of_day, get_timestamp, ends_on_same_day, \
 
 paul@222     38 
                            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@207    127 
    def send_message(self, method, sender):
 
 paul@79    128 
 
 paul@79    129 
        """
 
 paul@207    130 
        Create a full calendar object employing the given 'method', and send it
 
 paul@207    131 
        to the appropriate recipients, also sending a copy to the 'sender'.
 
 paul@79    132 
        """
 
 paul@79    133 
 
 paul@219    134 
        parts = [self.obj.to_part(method)]
 
 paul@207    135 
 
 paul@222    136 
        if self.user == self.organiser:
 
 paul@207    137 
            recipients = map(get_address, self.attendees)
 
 paul@207    138 
        else:
 
 paul@207    139 
            recipients = [get_address(self.organiser)]
 
 paul@207    140 
 
 paul@219    141 
        # Bundle free/busy information if appropriate.
 
 paul@219    142 
 
 paul@219    143 
        preferences = Preferences(self.user)
 
 paul@219    144 
 
 paul@219    145 
        if preferences.get("freebusy_sharing") == "share" and \
 
 paul@219    146 
           preferences.get("freebusy_bundling") == "always":
 
 paul@219    147 
 
 paul@222    148 
            # Invent a unique identifier.
 
 paul@222    149 
 
 paul@222    150 
            utcnow = get_timestamp()
 
 paul@222    151 
            uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))
 
 paul@222    152 
 
 paul@222    153 
            freebusy = self.store.get_freebusy(self.user)
 
 paul@222    154 
            parts.append(to_part("PUBLISH", [make_freebusy(freebusy, uid, self.user)]))
 
 paul@219    155 
 
 paul@219    156 
        message = self.messenger.make_outgoing_message(parts, recipients, outgoing_bcc=sender)
 
 paul@207    157 
        self.messenger.sendmail(recipients, message.as_string(), outgoing_bcc=sender)
 
 paul@79    158 
 
 paul@79    159 
    # Action methods.
 
 paul@79    160 
 
 paul@207    161 
    def process_received_request(self, accept, update=False):
 
 paul@79    162 
 
 paul@79    163 
        """
 
 paul@79    164 
        Process the current request for the given 'user', accepting any request
 
 paul@79    165 
        when 'accept' is true, declining requests otherwise. Return whether any
 
 paul@79    166 
        action was taken.
 
 paul@155    167 
 
 paul@155    168 
        If 'update' is given, the sequence number will be incremented in order
 
 paul@155    169 
        to override any previous response.
 
 paul@79    170 
        """
 
 paul@79    171 
 
 paul@79    172 
        # When accepting or declining, do so only on behalf of this user,
 
 paul@79    173 
        # preserving any other attributes set as an attendee.
 
 paul@79    174 
 
 paul@213    175 
        for attendee, attendee_attr in self.obj.get_items("ATTENDEE"):
 
 paul@79    176 
 
 paul@79    177 
            if attendee == self.user:
 
 paul@79    178 
                attendee_attr["PARTSTAT"] = accept and "ACCEPTED" or "DECLINED"
 
 paul@128    179 
                if self.messenger and self.messenger.sender != get_address(attendee):
 
 paul@128    180 
                    attendee_attr["SENT-BY"] = get_uri(self.messenger.sender)
 
 paul@213    181 
                self.obj["ATTENDEE"] = [(attendee, attendee_attr)]
 
 paul@155    182 
                if update:
 
 paul@213    183 
                    sequence = self.obj.get_value("SEQUENCE") or "0"
 
 paul@213    184 
                    self.obj["SEQUENCE"] = [(str(int(sequence) + 1), {})]
 
 paul@158    185 
                self.update_dtstamp()
 
 paul@155    186 
 
 paul@207    187 
                self.send_message("REPLY", get_address(attendee))
 
 paul@79    188 
 
 paul@79    189 
                return True
 
 paul@79    190 
 
 paul@79    191 
        return False
 
 paul@79    192 
 
 paul@207    193 
    def process_created_request(self, update=False):
 
 paul@207    194 
 
 paul@207    195 
        """
 
 paul@207    196 
        Process the current request for the given 'user', sending a created
 
 paul@207    197 
        request to attendees. Return whether any action was taken.
 
 paul@207    198 
 
 paul@207    199 
        If 'update' is given, the sequence number will be incremented in order
 
 paul@207    200 
        to override any previous message.
 
 paul@207    201 
        """
 
 paul@207    202 
 
 paul@213    203 
        organiser, organiser_attr = self.obj.get_item("ORGANIZER")
 
 paul@213    204 
 
 paul@213    205 
        if self.messenger and self.messenger.sender != get_address(organiser):
 
 paul@213    206 
            organiser_attr["SENT-BY"] = get_uri(self.messenger.sender)
 
 paul@207    207 
        if update:
 
 paul@213    208 
            sequence = self.obj.get_value("SEQUENCE") or "0"
 
 paul@213    209 
            self.obj["SEQUENCE"] = [(str(int(sequence) + 1), {})]
 
 paul@207    210 
        self.update_dtstamp()
 
 paul@207    211 
 
 paul@207    212 
        self.send_message("REQUEST", get_address(self.organiser))
 
 paul@207    213 
 
 paul@207    214 
        return True
 
 paul@207    215 
 
 paul@69    216 
class Manager:
 
 paul@69    217 
 
 paul@69    218 
    "A simple manager application."
 
 paul@69    219 
 
 paul@82    220 
    def __init__(self, messenger=None):
 
 paul@82    221 
        self.messenger = messenger or Messenger()
 
 paul@82    222 
 
 paul@212    223 
        self.encoding = "utf-8"
 
 paul@212    224 
        self.env = CGIEnvironment(self.encoding)
 
 paul@212    225 
 
 paul@69    226 
        user = self.env.get_user()
 
 paul@77    227 
        self.user = user and get_uri(user) or None
 
 paul@147    228 
        self.preferences = None
 
 paul@149    229 
        self.locale = None
 
 paul@121    230 
        self.requests = None
 
 paul@121    231 
 
 paul@69    232 
        self.out = self.env.get_output()
 
 paul@69    233 
        self.page = markup.page()
 
 paul@69    234 
 
 paul@77    235 
        self.store = imip_store.FileStore()
 
 paul@162    236 
        self.objects = {}
 
 paul@77    237 
 
 paul@77    238 
        try:
 
 paul@77    239 
            self.publisher = imip_store.FilePublisher()
 
 paul@77    240 
        except OSError:
 
 paul@77    241 
            self.publisher = None
 
 paul@77    242 
 
 paul@121    243 
    def _get_uid(self, path_info):
 
 paul@121    244 
        return path_info.lstrip("/").split("/", 1)[0]
 
 paul@121    245 
 
 paul@117    246 
    def _get_object(self, uid):
 
 paul@162    247 
        if self.objects.has_key(uid):
 
 paul@162    248 
            return self.objects[uid]
 
 paul@162    249 
 
 paul@117    250 
        f = uid and self.store.get_event(self.user, uid) or None
 
 paul@117    251 
 
 paul@117    252 
        if not f:
 
 paul@117    253 
            return None
 
 paul@117    254 
 
 paul@213    255 
        fragment = parse_object(f, "utf-8")
 
 paul@213    256 
        obj = self.objects[uid] = fragment and Object(fragment)
 
 paul@117    257 
 
 paul@121    258 
        return obj
 
 paul@121    259 
 
 paul@121    260 
    def _get_requests(self):
 
 paul@121    261 
        if self.requests is None:
 
 paul@121    262 
            self.requests = self.store.get_requests(self.user)
 
 paul@121    263 
        return self.requests
 
 paul@117    264 
 
 paul@162    265 
    def _get_request_summary(self):
 
 paul@162    266 
        summary = []
 
 paul@162    267 
        for uid in self._get_requests():
 
 paul@162    268 
            obj = self._get_object(uid)
 
 paul@162    269 
            if obj:
 
 paul@162    270 
                summary.append((
 
 paul@213    271 
                    obj.get_value("DTSTART"),
 
 paul@213    272 
                    obj.get_value("DTEND"),
 
 paul@162    273 
                    uid
 
 paul@162    274 
                    ))
 
 paul@162    275 
        return summary
 
 paul@162    276 
 
 paul@147    277 
    # Preference methods.
 
 paul@147    278 
 
 paul@149    279 
    def get_user_locale(self):
 
 paul@149    280 
        if not self.locale:
 
 paul@149    281 
            self.locale = self.get_preferences().get("LANG", "C")
 
 paul@149    282 
        return self.locale
 
 paul@147    283 
 
 paul@147    284 
    def get_preferences(self):
 
 paul@147    285 
        if not self.preferences:
 
 paul@147    286 
            self.preferences = Preferences(self.user)
 
 paul@147    287 
        return self.preferences
 
 paul@147    288 
 
 paul@162    289 
    # Prettyprinting of dates and times.
 
 paul@162    290 
 
 paul@149    291 
    def format_date(self, dt, format):
 
 paul@149    292 
        return self._format_datetime(babel.dates.format_date, dt, format)
 
 paul@149    293 
 
 paul@149    294 
    def format_time(self, dt, format):
 
 paul@149    295 
        return self._format_datetime(babel.dates.format_time, dt, format)
 
 paul@149    296 
 
 paul@149    297 
    def format_datetime(self, dt, format):
 
 paul@232    298 
        return self._format_datetime(
 
 paul@232    299 
            isinstance(dt, datetime) and babel.dates.format_datetime or babel.dates.format_date,
 
 paul@232    300 
            dt, format)
 
 paul@232    301 
 
 paul@232    302 
    def format_end_datetime(self, dt, format):
 
 paul@235    303 
        if isinstance(dt, date) and not isinstance(dt, datetime):
 
 paul@232    304 
            dt = dt - timedelta(1)
 
 paul@232    305 
        return self.format_datetime(dt, format)
 
 paul@149    306 
 
 paul@149    307 
    def _format_datetime(self, fn, dt, format):
 
 paul@149    308 
        return fn(dt, format=format, locale=self.get_user_locale())
 
 paul@149    309 
 
 paul@78    310 
    # Data management methods.
 
 paul@78    311 
 
 paul@78    312 
    def remove_request(self, uid):
 
 paul@105    313 
        return self.store.dequeue_request(self.user, uid)
 
 paul@78    314 
 
 paul@234    315 
    def remove_event(self, uid):
 
 paul@234    316 
        return self.store.remove_event(self.user, uid)
 
 paul@234    317 
 
 paul@78    318 
    # Presentation methods.
 
 paul@78    319 
 
 paul@69    320 
    def new_page(self, title):
 
 paul@192    321 
        self.page.init(title=title, charset=self.encoding, css=self.env.new_url("styles.css"))
 
 paul@69    322 
 
 paul@69    323 
    def status(self, code, message):
 
 paul@123    324 
        self.header("Status", "%s %s" % (code, message))
 
 paul@123    325 
 
 paul@123    326 
    def header(self, header, value):
 
 paul@123    327 
        print >>self.out, "%s: %s" % (header, value)
 
 paul@69    328 
 
 paul@69    329 
    def no_user(self):
 
 paul@69    330 
        self.status(403, "Forbidden")
 
 paul@69    331 
        self.new_page(title="Forbidden")
 
 paul@69    332 
        self.page.p("You are not logged in and thus cannot access scheduling requests.")
 
 paul@69    333 
 
 paul@70    334 
    def no_page(self):
 
 paul@70    335 
        self.status(404, "Not Found")
 
 paul@70    336 
        self.new_page(title="Not Found")
 
 paul@70    337 
        self.page.p("No page is provided at the given address.")
 
 paul@70    338 
 
 paul@123    339 
    def redirect(self, url):
 
 paul@123    340 
        self.status(302, "Redirect")
 
 paul@123    341 
        self.header("Location", url)
 
 paul@123    342 
        self.new_page(title="Redirect")
 
 paul@123    343 
        self.page.p("Redirecting to: %s" % url)
 
 paul@123    344 
 
 paul@121    345 
    # Request logic and page fragment methods.
 
 paul@121    346 
 
 paul@202    347 
    def handle_newevent(self):
 
 paul@202    348 
 
 paul@207    349 
        """
 
 paul@207    350 
        Handle any new event operation, creating a new event and redirecting to
 
 paul@207    351 
        the event page for further activity.
 
 paul@207    352 
        """
 
 paul@202    353 
 
 paul@202    354 
        # Handle a submitted form.
 
 paul@202    355 
 
 paul@202    356 
        args = self.env.get_args()
 
 paul@202    357 
 
 paul@202    358 
        if not args.has_key("newevent"):
 
 paul@202    359 
            return
 
 paul@202    360 
 
 paul@202    361 
        # Create a new event using the available information.
 
 paul@202    362 
 
 paul@236    363 
        slots = args.get("slot", [])
 
 paul@202    364 
        participants = args.get("participants", [])
 
 paul@202    365 
 
 paul@236    366 
        if not slots:
 
 paul@202    367 
            return
 
 paul@202    368 
 
 paul@236    369 
        # Coalesce the selected slots.
 
 paul@236    370 
 
 paul@236    371 
        slots.sort()
 
 paul@236    372 
        coalesced = []
 
 paul@236    373 
        last = None
 
 paul@236    374 
 
 paul@236    375 
        for slot in slots:
 
 paul@236    376 
            start, end = slot.split("-")
 
 paul@236    377 
            if last:
 
 paul@236    378 
                if start == last[1]:
 
 paul@236    379 
                    last = last[0], end
 
 paul@236    380 
                    continue
 
 paul@236    381 
                else:
 
 paul@236    382 
                    coalesced.append(last)
 
 paul@236    383 
            last = start, end
 
 paul@236    384 
 
 paul@236    385 
        if last:
 
 paul@236    386 
            coalesced.append(last)
 
 paul@202    387 
 
 paul@202    388 
        # Obtain the user's timezone.
 
 paul@202    389 
 
 paul@202    390 
        prefs = self.get_preferences()
 
 paul@202    391 
        tzid = prefs.get("TZID", "UTC")
 
 paul@202    392 
 
 paul@202    393 
        # Invent a unique identifier.
 
 paul@202    394 
 
 paul@222    395 
        utcnow = get_timestamp()
 
 paul@202    396 
        uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))
 
 paul@202    397 
 
 paul@236    398 
        # Define a single occurrence if only one coalesced slot exists.
 
 paul@236    399 
        # Otherwise, many occurrences are defined.
 
 paul@202    400 
 
 paul@236    401 
        for i, (start, end) in enumerate(coalesced):
 
 paul@236    402 
            this_uid = "%s-%s" % (uid, i)
 
 paul@236    403 
 
 paul@236    404 
            # Create a calendar object and store it as a request.
 
 paul@236    405 
 
 paul@236    406 
            record = []
 
 paul@236    407 
            rwrite = record.append
 
 paul@202    408 
 
 paul@236    409 
            rwrite(("UID", {}, this_uid))
 
 paul@236    410 
            rwrite(("SUMMARY", {}, "New event at %s" % utcnow))
 
 paul@236    411 
            rwrite(("DTSTAMP", {}, utcnow))
 
 paul@236    412 
            rwrite(("DTSTART", {"VALUE" : "DATE-TIME", "TZID" : tzid}, start))
 
 paul@236    413 
            rwrite(("DTEND", {"VALUE" : "DATE-TIME", "TZID" : tzid}, end or
 
 paul@236    414 
                format_datetime(get_end_of_day(get_datetime(start, {"TZID" : tzid})))
 
 paul@236    415 
                ))
 
 paul@236    416 
            rwrite(("ORGANIZER", {}, self.user))
 
 paul@202    417 
 
 paul@236    418 
            for participant in participants:
 
 paul@236    419 
                if not participant:
 
 paul@236    420 
                    continue
 
 paul@236    421 
                participant = get_uri(participant)
 
 paul@236    422 
                if participant != self.user:
 
 paul@236    423 
                    rwrite(("ATTENDEE", {}, participant))
 
 paul@202    424 
 
 paul@236    425 
            obj = ("VEVENT", {}, record)
 
 paul@236    426 
 
 paul@236    427 
            self.store.set_event(self.user, this_uid, obj)
 
 paul@236    428 
            self.store.queue_request(self.user, this_uid)
 
 paul@202    429 
 
 paul@236    430 
        # Redirect to the object (or the first of the objects), where instead of
 
 paul@236    431 
        # attendee controls, there will be organiser controls.
 
 paul@236    432 
 
 paul@236    433 
        self.redirect(self.env.new_url("%s-0" % uid))
 
 paul@202    434 
 
 paul@212    435 
    def handle_request(self, uid, obj, queued):
 
 paul@121    436 
 
 paul@155    437 
        """
 
 paul@212    438 
        Handle actions involving the given 'uid' and 'obj' object, where
 
 paul@155    439 
        'queued' indicates that the object has not yet been handled.
 
 paul@155    440 
        """
 
 paul@121    441 
 
 paul@121    442 
        # Handle a submitted form.
 
 paul@121    443 
 
 paul@121    444 
        args = self.env.get_args()
 
 paul@123    445 
        handled = True
 
 paul@121    446 
 
 paul@212    447 
        # Update the object.
 
 paul@212    448 
 
 paul@212    449 
        if args.has_key("summary"):
 
 paul@213    450 
            obj["SUMMARY"] = [(args["summary"][0], {})]
 
 paul@212    451 
 
 paul@212    452 
        # Process any action.
 
 paul@212    453 
 
 paul@121    454 
        accept = args.has_key("accept")
 
 paul@121    455 
        decline = args.has_key("decline")
 
 paul@207    456 
        invite = args.has_key("invite")
 
 paul@155    457 
        update = not queued and args.has_key("update")
 
 paul@121    458 
 
 paul@207    459 
        if accept or decline or invite:
 
 paul@121    460 
 
 paul@212    461 
            handler = ManagerHandler(obj, self.user, self.messenger)
 
 paul@121    462 
 
 paul@212    463 
            # Process the object and remove it from the list of requests.
 
 paul@121    464 
 
 paul@207    465 
            if (accept or decline) and handler.process_received_request(accept, update) or \
 
 paul@207    466 
                invite and handler.process_created_request(update):
 
 paul@121    467 
 
 paul@121    468 
                self.remove_request(uid)
 
 paul@121    469 
 
 paul@207    470 
        elif args.has_key("discard"):
 
 paul@121    471 
 
 paul@234    472 
            # Remove the request and the object.
 
 paul@121    473 
 
 paul@234    474 
            self.remove_event(uid)
 
 paul@121    475 
            self.remove_request(uid)
 
 paul@121    476 
 
 paul@121    477 
        else:
 
 paul@123    478 
            handled = False
 
 paul@121    479 
 
 paul@212    480 
        # Upon handling an action, redirect to the main page.
 
 paul@212    481 
 
 paul@123    482 
        if handled:
 
 paul@123    483 
            self.redirect(self.env.get_path())
 
 paul@123    484 
 
 paul@123    485 
        return handled
 
 paul@121    486 
 
 paul@212    487 
    def show_request_controls(self, obj, needs_action):
 
 paul@155    488 
 
 paul@155    489 
        """
 
 paul@212    490 
        Show form controls for a request concerning 'obj', indicating whether
 
 paul@212    491 
        action is needed if 'needs_action' is specified as a true value.
 
 paul@155    492 
        """
 
 paul@155    493 
 
 paul@212    494 
        page = self.page
 
 paul@212    495 
 
 paul@213    496 
        is_organiser = obj.get_value("ORGANIZER") == self.user
 
 paul@207    497 
 
 paul@207    498 
        if not is_organiser:
 
 paul@213    499 
            attendees = obj.get_value_map("ATTENDEE")
 
 paul@207    500 
            attendee_attr = attendees.get(self.user)
 
 paul@121    501 
 
 paul@207    502 
            if attendee_attr:
 
 paul@207    503 
                partstat = attendee_attr.get("PARTSTAT")
 
 paul@207    504 
                if partstat == "ACCEPTED":
 
 paul@212    505 
                    page.p("This request has been accepted.")
 
 paul@207    506 
                elif partstat == "DECLINED":
 
 paul@212    507 
                    page.p("This request has been declined.")
 
 paul@207    508 
                else:
 
 paul@212    509 
                    page.p("This request has not yet been dealt with.")
 
 paul@121    510 
 
 paul@155    511 
        if needs_action:
 
 paul@212    512 
            page.p("An action is required for this request:")
 
 paul@155    513 
        else:
 
 paul@212    514 
            page.p("This request can be updated as follows:")
 
 paul@155    515 
 
 paul@212    516 
        page.p()
 
 paul@207    517 
 
 paul@207    518 
        # Show appropriate options depending on the role of the user.
 
 paul@207    519 
 
 paul@207    520 
        if is_organiser:
 
 paul@212    521 
            page.input(name="invite", type="submit", value="Invite")
 
 paul@207    522 
        else:
 
 paul@212    523 
            page.input(name="accept", type="submit", value="Accept")
 
 paul@212    524 
            page.add(" ")
 
 paul@212    525 
            page.input(name="decline", type="submit", value="Decline")
 
 paul@207    526 
 
 paul@212    527 
        page.add(" ")
 
 paul@212    528 
        page.input(name="discard", type="submit", value="Discard")
 
 paul@207    529 
 
 paul@207    530 
        # Updated objects need to have details updated upon sending.
 
 paul@207    531 
 
 paul@155    532 
        if not needs_action:
 
 paul@212    533 
            page.input(name="update", type="hidden", value="true")
 
 paul@207    534 
 
 paul@212    535 
        page.p.close()
 
 paul@121    536 
 
 paul@210    537 
    object_labels = {
 
 paul@210    538 
        "SUMMARY"   : "Summary",
 
 paul@210    539 
        "DTSTART"   : "Start",
 
 paul@210    540 
        "DTEND"     : "End",
 
 paul@210    541 
        "ORGANIZER" : "Organiser",
 
 paul@210    542 
        "ATTENDEE"  : "Attendee",
 
 paul@210    543 
        }
 
 paul@210    544 
 
 paul@212    545 
    def show_object_on_page(self, uid, obj, needs_action):
 
 paul@121    546 
 
 paul@121    547 
        """
 
 paul@121    548 
        Show the calendar object with the given 'uid' and representation 'obj'
 
 paul@121    549 
        on the current page.
 
 paul@121    550 
        """
 
 paul@121    551 
 
 paul@210    552 
        page = self.page
 
 paul@212    553 
        page.form(method="POST")
 
 paul@210    554 
 
 paul@154    555 
        # Obtain the user's timezone.
 
 paul@154    556 
 
 paul@154    557 
        prefs = self.get_preferences()
 
 paul@154    558 
        tzid = prefs.get("TZID", "UTC")
 
 paul@121    559 
 
 paul@121    560 
        # Provide a summary of the object.
 
 paul@121    561 
 
 paul@230    562 
        page.table(class_="object", cellspacing=5, cellpadding=5)
 
 paul@212    563 
        page.thead()
 
 paul@212    564 
        page.tr()
 
 paul@212    565 
        page.th("Event", class_="mainheading", colspan=2)
 
 paul@212    566 
        page.tr.close()
 
 paul@212    567 
        page.thead.close()
 
 paul@212    568 
        page.tbody()
 
 paul@121    569 
 
 paul@121    570 
        for name in ["SUMMARY", "DTSTART", "DTEND", "ORGANIZER", "ATTENDEE"]:
 
 paul@210    571 
            page.tr()
 
 paul@210    572 
 
 paul@210    573 
            label = self.object_labels.get(name, name)
 
 paul@210    574 
 
 paul@210    575 
            # Handle datetimes specially.
 
 paul@210    576 
 
 paul@147    577 
            if name in ["DTSTART", "DTEND"]:
 
 paul@213    578 
                value, attr = obj.get_item(name)
 
 paul@154    579 
                tzid = attr.get("TZID", tzid)
 
 paul@232    580 
                value = (
 
 paul@232    581 
                    name == "DTSTART" and self.format_datetime or self.format_end_datetime
 
 paul@232    582 
                    )(to_timezone(get_datetime(value), tzid), "full")
 
 paul@210    583 
                page.th(label, class_="objectheading")
 
 paul@210    584 
                page.td(value)
 
 paul@210    585 
                page.tr.close()
 
 paul@210    586 
 
 paul@212    587 
            # Handle the summary specially.
 
 paul@212    588 
 
 paul@212    589 
            elif name == "SUMMARY":
 
 paul@213    590 
                value = obj.get_value(name)
 
 paul@212    591 
                page.th(label, class_="objectheading")
 
 paul@212    592 
                page.td()
 
 paul@212    593 
                page.input(name="summary", type="text", value=value, size=80)
 
 paul@212    594 
                page.td.close()
 
 paul@212    595 
                page.tr.close()
 
 paul@212    596 
 
 paul@210    597 
            # Handle potentially many values.
 
 paul@210    598 
 
 paul@147    599 
            else:
 
 paul@213    600 
                items = obj.get_items(name)
 
 paul@233    601 
                if not items:
 
 paul@233    602 
                    continue
 
 paul@233    603 
 
 paul@210    604 
                page.th(label, class_="objectheading", rowspan=len(items))
 
 paul@210    605 
 
 paul@210    606 
                first = True
 
 paul@210    607 
 
 paul@210    608 
                for value, attr in items:
 
 paul@210    609 
                    if not first:
 
 paul@210    610 
                        page.tr()
 
 paul@210    611 
                    else:
 
 paul@210    612 
                        first = False
 
 paul@121    613 
 
 paul@210    614 
                    page.td()
 
 paul@210    615 
                    page.add(value)
 
 paul@210    616 
 
 paul@210    617 
                    if name == "ATTENDEE":
 
 paul@210    618 
                        partstat = attr.get("PARTSTAT")
 
 paul@210    619 
                        if partstat:
 
 paul@210    620 
                            page.add(" (%s)" % partstat)
 
 paul@210    621 
 
 paul@210    622 
                    page.td.close()
 
 paul@210    623 
                    page.tr.close()
 
 paul@210    624 
 
 paul@212    625 
        page.tbody.close()
 
 paul@210    626 
        page.table.close()
 
 paul@121    627 
 
 paul@213    628 
        dtstart = format_datetime(obj.get_utc_datetime("DTSTART"))
 
 paul@213    629 
        dtend = format_datetime(obj.get_utc_datetime("DTEND"))
 
 paul@121    630 
 
 paul@121    631 
        # Indicate whether there are conflicting events.
 
 paul@121    632 
 
 paul@121    633 
        freebusy = self.store.get_freebusy(self.user)
 
 paul@121    634 
 
 paul@121    635 
        if freebusy:
 
 paul@121    636 
 
 paul@121    637 
            # Obtain any time zone details from the suggested event.
 
 paul@121    638 
 
 paul@213    639 
            _dtstart, attr = obj.get_item("DTSTART")
 
 paul@154    640 
            tzid = attr.get("TZID", tzid)
 
 paul@121    641 
 
 paul@121    642 
            # Show any conflicts.
 
 paul@121    643 
 
 paul@121    644 
            for t in have_conflict(freebusy, [(dtstart, dtend)], True):
 
 paul@121    645 
                start, end, found_uid = t[:3]
 
 paul@154    646 
 
 paul@154    647 
                # Provide details of any conflicting event.
 
 paul@154    648 
 
 paul@121    649 
                if uid != found_uid:
 
 paul@149    650 
                    start = self.format_datetime(to_timezone(get_datetime(start), tzid), "full")
 
 paul@149    651 
                    end = self.format_datetime(to_timezone(get_datetime(end), tzid), "full")
 
 paul@210    652 
                    page.p("Event conflicts with another from %s to %s: " % (start, end))
 
 paul@154    653 
 
 paul@154    654 
                    # Show the event summary for the conflicting event.
 
 paul@154    655 
 
 paul@154    656 
                    found_obj = self._get_object(found_uid)
 
 paul@154    657 
                    if found_obj:
 
 paul@213    658 
                        page.a(found_obj.get_value("SUMMARY"), href=self.env.new_url(found_uid))
 
 paul@121    659 
 
 paul@212    660 
        self.show_request_controls(obj, needs_action)
 
 paul@212    661 
        page.form.close()
 
 paul@212    662 
 
 paul@121    663 
    def show_requests_on_page(self):
 
 paul@69    664 
 
 paul@69    665 
        "Show requests for the current user."
 
 paul@69    666 
 
 paul@69    667 
        # NOTE: This list could be more informative, but it is envisaged that
 
 paul@69    668 
        # NOTE: the requests would be visited directly anyway.
 
 paul@69    669 
 
 paul@121    670 
        requests = self._get_requests()
 
 paul@70    671 
 
 paul@185    672 
        self.page.div(id="pending-requests")
 
 paul@185    673 
 
 paul@80    674 
        if requests:
 
 paul@114    675 
            self.page.p("Pending requests:")
 
 paul@114    676 
 
 paul@80    677 
            self.page.ul()
 
 paul@69    678 
 
 paul@80    679 
            for request in requests:
 
 paul@165    680 
                obj = self._get_object(request)
 
 paul@165    681 
                if obj:
 
 paul@165    682 
                    self.page.li()
 
 paul@213    683 
                    self.page.a(obj.get_value("SUMMARY"), href="#request-%s" % request)
 
 paul@165    684 
                    self.page.li.close()
 
 paul@80    685 
 
 paul@80    686 
            self.page.ul.close()
 
 paul@80    687 
 
 paul@80    688 
        else:
 
 paul@80    689 
            self.page.p("There are no pending requests.")
 
 paul@69    690 
 
 paul@185    691 
        self.page.div.close()
 
 paul@185    692 
 
 paul@185    693 
    def show_participants_on_page(self):
 
 paul@185    694 
 
 paul@185    695 
        "Show participants for scheduling purposes."
 
 paul@185    696 
 
 paul@185    697 
        args = self.env.get_args()
 
 paul@185    698 
        participants = args.get("participants", [])
 
 paul@185    699 
 
 paul@185    700 
        try:
 
 paul@185    701 
            for name, value in args.items():
 
 paul@185    702 
                if name.startswith("remove-participant-"):
 
 paul@185    703 
                    i = int(name[len("remove-participant-"):])
 
 paul@185    704 
                    del participants[i]
 
 paul@185    705 
                    break
 
 paul@185    706 
        except ValueError:
 
 paul@185    707 
            pass
 
 paul@185    708 
 
 paul@185    709 
        # Trim empty participants.
 
 paul@185    710 
 
 paul@185    711 
        while participants and not participants[-1].strip():
 
 paul@185    712 
            participants.pop()
 
 paul@185    713 
 
 paul@185    714 
        # Show any specified participants together with controls to remove and
 
 paul@185    715 
        # add participants.
 
 paul@185    716 
 
 paul@185    717 
        self.page.div(id="participants")
 
 paul@185    718 
 
 paul@185    719 
        self.page.p("Participants for scheduling:")
 
 paul@185    720 
 
 paul@185    721 
        for i, participant in enumerate(participants):
 
 paul@185    722 
            self.page.p()
 
 paul@185    723 
            self.page.input(name="participants", type="text", value=participant)
 
 paul@185    724 
            self.page.input(name="remove-participant-%d" % i, type="submit", value="Remove")
 
 paul@185    725 
            self.page.p.close()
 
 paul@185    726 
 
 paul@185    727 
        self.page.p()
 
 paul@185    728 
        self.page.input(name="participants", type="text")
 
 paul@185    729 
        self.page.input(name="add-participant", type="submit", value="Add")
 
 paul@185    730 
        self.page.p.close()
 
 paul@185    731 
 
 paul@185    732 
        self.page.div.close()
 
 paul@185    733 
 
 paul@185    734 
        return participants
 
 paul@185    735 
 
 paul@121    736 
    # Full page output methods.
 
 paul@70    737 
 
 paul@121    738 
    def show_object(self, path_info):
 
 paul@70    739 
 
 paul@121    740 
        "Show an object request using the given 'path_info' for the current user."
 
 paul@70    741 
 
 paul@121    742 
        uid = self._get_uid(path_info)
 
 paul@121    743 
        obj = self._get_object(uid)
 
 paul@121    744 
 
 paul@121    745 
        if not obj:
 
 paul@70    746 
            return False
 
 paul@70    747 
 
 paul@123    748 
        is_request = uid in self._get_requests()
 
 paul@155    749 
        handled = self.handle_request(uid, obj, is_request)
 
 paul@77    750 
 
 paul@123    751 
        if handled:
 
 paul@123    752 
            return True
 
 paul@73    753 
 
 paul@123    754 
        self.new_page(title="Event")
 
 paul@212    755 
        self.show_object_on_page(uid, obj, is_request and not handled)
 
 paul@73    756 
 
 paul@70    757 
        return True
 
 paul@70    758 
 
 paul@114    759 
    def show_calendar(self):
 
 paul@114    760 
 
 paul@114    761 
        "Show the calendar for the current user."
 
 paul@114    762 
 
 paul@202    763 
        handled = self.handle_newevent()
 
 paul@202    764 
 
 paul@114    765 
        self.new_page(title="Calendar")
 
 paul@162    766 
        page = self.page
 
 paul@162    767 
 
 paul@196    768 
        # Form controls are used in various places on the calendar page.
 
 paul@196    769 
 
 paul@196    770 
        page.form(method="POST")
 
 paul@196    771 
 
 paul@121    772 
        self.show_requests_on_page()
 
 paul@185    773 
        participants = self.show_participants_on_page()
 
 paul@114    774 
 
 paul@196    775 
        # Show a button for scheduling a new event.
 
 paul@196    776 
 
 paul@230    777 
        page.p(class_="controls")
 
 paul@196    778 
        page.input(name="newevent", type="submit", value="New event", id="newevent")
 
 paul@196    779 
        page.p.close()
 
 paul@196    780 
 
 paul@231    781 
        # Show controls for hiding empty and busy slots.
 
 paul@203    782 
        # The positioning of the control, paragraph and table are important here.
 
 paul@203    783 
 
 paul@203    784 
        page.input(name="hideslots", type="checkbox", value="hide", id="hideslots")
 
 paul@231    785 
        page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy")
 
 paul@203    786 
 
 paul@230    787 
        page.p(class_="controls")
 
 paul@237    788 
        page.label("Hide busy time periods", for_="hidebusy", class_="hidebusy enable")
 
 paul@237    789 
        page.label("Show busy time periods", for_="hidebusy", class_="hidebusy disable")
 
 paul@237    790 
        page.label("Hide unused time periods", for_="hideslots", class_="hideslots enable")
 
 paul@237    791 
        page.label("Show unused time periods", for_="hideslots", class_="hideslots disable")
 
 paul@203    792 
        page.p.close()
 
 paul@203    793 
 
 paul@114    794 
        freebusy = self.store.get_freebusy(self.user)
 
 paul@114    795 
 
 paul@114    796 
        if not freebusy:
 
 paul@114    797 
            page.p("No events scheduled.")
 
 paul@114    798 
            return
 
 paul@114    799 
 
 paul@154    800 
        # Obtain the user's timezone.
 
 paul@147    801 
 
 paul@147    802 
        prefs = self.get_preferences()
 
 paul@153    803 
        tzid = prefs.get("TZID", "UTC")
 
 paul@147    804 
 
 paul@114    805 
        # Day view: start at the earliest known day and produce days until the
 
 paul@114    806 
        # latest known day, perhaps with expandable sections of empty days.
 
 paul@114    807 
 
 paul@114    808 
        # Month view: start at the earliest known month and produce months until
 
 paul@114    809 
        # the latest known month, perhaps with expandable sections of empty
 
 paul@114    810 
        # months.
 
 paul@114    811 
 
 paul@114    812 
        # Details of users to invite to new events could be superimposed on the
 
 paul@114    813 
        # calendar.
 
 paul@114    814 
 
 paul@185    815 
        # Requests are listed and linked to their tentative positions in the
 
 paul@185    816 
        # calendar. Other participants are also shown.
 
 paul@185    817 
 
 paul@185    818 
        request_summary = self._get_request_summary()
 
 paul@185    819 
 
 paul@185    820 
        period_groups = [request_summary, freebusy]
 
 paul@185    821 
        period_group_types = ["request", "freebusy"]
 
 paul@185    822 
        period_group_sources = ["Pending requests", "Your schedule"]
 
 paul@185    823 
 
 paul@187    824 
        for i, participant in enumerate(participants):
 
 paul@185    825 
            period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))
 
 paul@187    826 
            period_group_types.append("freebusy-part%d" % i)
 
 paul@185    827 
            period_group_sources.append(participant)
 
 paul@114    828 
 
 paul@162    829 
        groups = []
 
 paul@162    830 
        group_columns = []
 
 paul@185    831 
        group_types = period_group_types
 
 paul@185    832 
        group_sources = period_group_sources
 
 paul@162    833 
        all_points = set()
 
 paul@162    834 
 
 paul@162    835 
        # Obtain time point information for each group of periods.
 
 paul@162    836 
 
 paul@185    837 
        for periods in period_groups:
 
 paul@162    838 
            periods = convert_periods(periods, tzid)
 
 paul@162    839 
 
 paul@162    840 
            # Get the time scale with start and end points.
 
 paul@162    841 
 
 paul@162    842 
            scale = get_scale(periods)
 
 paul@162    843 
 
 paul@162    844 
            # Get the time slots for the periods.
 
 paul@162    845 
 
 paul@162    846 
            slots = get_slots(scale)
 
 paul@162    847 
 
 paul@162    848 
            # Add start of day time points for multi-day periods.
 
 paul@162    849 
 
 paul@162    850 
            add_day_start_points(slots)
 
 paul@162    851 
 
 paul@162    852 
            # Record the slots and all time points employed.
 
 paul@162    853 
 
 paul@162    854 
            groups.append(slots)
 
 paul@201    855 
            all_points.update([point for point, active in slots])
 
 paul@162    856 
 
 paul@162    857 
        # Partition the groups into days.
 
 paul@162    858 
 
 paul@162    859 
        days = {}
 
 paul@162    860 
        partitioned_groups = []
 
 paul@171    861 
        partitioned_group_types = []
 
 paul@185    862 
        partitioned_group_sources = []
 
 paul@162    863 
 
 paul@185    864 
        for slots, group_type, group_source in zip(groups, group_types, group_sources):
 
 paul@162    865 
 
 paul@162    866 
            # Propagate time points to all groups of time slots.
 
 paul@162    867 
 
 paul@162    868 
            add_slots(slots, all_points)
 
 paul@162    869 
 
 paul@162    870 
            # Count the number of columns employed by the group.
 
 paul@162    871 
 
 paul@162    872 
            columns = 0
 
 paul@162    873 
 
 paul@162    874 
            # Partition the time slots by day.
 
 paul@162    875 
 
 paul@162    876 
            partitioned = {}
 
 paul@162    877 
 
 paul@162    878 
            for day, day_slots in partition_by_day(slots).items():
 
 paul@201    879 
                intervals = []
 
 paul@201    880 
                last = None
 
 paul@201    881 
 
 paul@201    882 
                for point, active in day_slots:
 
 paul@201    883 
                    columns = max(columns, len(active))
 
 paul@201    884 
                    if last:
 
 paul@201    885 
                        intervals.append((last, point))
 
 paul@201    886 
                    last = point
 
 paul@201    887 
 
 paul@201    888 
                if last:
 
 paul@201    889 
                    intervals.append((last, None))
 
 paul@162    890 
 
 paul@162    891 
                if not days.has_key(day):
 
 paul@162    892 
                    days[day] = set()
 
 paul@162    893 
 
 paul@162    894 
                # Convert each partition to a mapping from points to active
 
 paul@162    895 
                # periods.
 
 paul@162    896 
 
 paul@201    897 
                partitioned[day] = dict(day_slots)
 
 paul@201    898 
 
 paul@201    899 
                # Record the divisions or intervals within each day.
 
 paul@201    900 
 
 paul@201    901 
                days[day].update(intervals)
 
 paul@162    902 
 
 paul@194    903 
            if group_type != "request" or columns:
 
 paul@194    904 
                group_columns.append(columns)
 
 paul@194    905 
                partitioned_groups.append(partitioned)
 
 paul@194    906 
                partitioned_group_types.append(group_type)
 
 paul@194    907 
                partitioned_group_sources.append(group_source)
 
 paul@114    908 
 
 paul@230    909 
        page.table(cellspacing=5, cellpadding=5, class_="calendar")
 
 paul@188    910 
        self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)
 
 paul@171    911 
        self.show_calendar_days(days, partitioned_groups, partitioned_group_types, group_columns)
 
 paul@162    912 
        page.table.close()
 
 paul@114    913 
 
 paul@196    914 
        # End the form region.
 
 paul@196    915 
 
 paul@196    916 
        page.form.close()
 
 paul@196    917 
 
 paul@188    918 
    def show_calendar_participant_headings(self, group_types, group_sources, group_columns):
 
 paul@186    919 
 
 paul@186    920 
        """
 
 paul@186    921 
        Show headings for the participants and other scheduling contributors,
 
 paul@188    922 
        defined by 'group_types', 'group_sources' and 'group_columns'.
 
 paul@186    923 
        """
 
 paul@186    924 
 
 paul@185    925 
        page = self.page
 
 paul@185    926 
 
 paul@188    927 
        page.colgroup(span=1, id="columns-timeslot")
 
 paul@186    928 
 
 paul@188    929 
        for group_type, columns in zip(group_types, group_columns):
 
 paul@191    930 
            page.colgroup(span=max(columns, 1), id="columns-%s" % group_type)
 
 paul@186    931 
 
 paul@185    932 
        page.thead()
 
 paul@185    933 
        page.tr()
 
 paul@185    934 
        page.th("", class_="emptyheading")
 
 paul@185    935 
 
 paul@193    936 
        for group_type, source, columns in zip(group_types, group_sources, group_columns):
 
 paul@193    937 
            page.th(source,
 
 paul@193    938 
                class_=(group_type == "request" and "requestheading" or "participantheading"),
 
 paul@193    939 
                colspan=max(columns, 1))
 
 paul@185    940 
 
 paul@185    941 
        page.tr.close()
 
 paul@185    942 
        page.thead.close()
 
 paul@185    943 
 
 paul@171    944 
    def show_calendar_days(self, days, partitioned_groups, partitioned_group_types, group_columns):
 
 paul@186    945 
 
 paul@186    946 
        """
 
 paul@186    947 
        Show calendar days, defined by a collection of 'days', the contributing
 
 paul@186    948 
        period information as 'partitioned_groups' (partitioned by day), the
 
 paul@186    949 
        'partitioned_group_types' indicating the kind of contribution involved,
 
 paul@186    950 
        and the 'group_columns' defining the number of columns in each group.
 
 paul@186    951 
        """
 
 paul@186    952 
 
 paul@162    953 
        page = self.page
 
 paul@162    954 
 
 paul@191    955 
        # Determine the number of columns required. Where participants provide
 
 paul@191    956 
        # no columns for events, one still needs to be provided for the
 
 paul@191    957 
        # participant itself.
 
 paul@147    958 
 
 paul@191    959 
        all_columns = sum([max(columns, 1) for columns in group_columns])
 
 paul@191    960 
 
 paul@191    961 
        # Determine the days providing time slots.
 
 paul@191    962 
 
 paul@162    963 
        all_days = days.items()
 
 paul@162    964 
        all_days.sort()
 
 paul@162    965 
 
 paul@162    966 
        # Produce a heading and time points for each day.
 
 paul@162    967 
 
 paul@201    968 
        for day, intervals in all_days:
 
 paul@186    969 
            page.thead()
 
 paul@114    970 
            page.tr()
 
 paul@171    971 
            page.th(class_="dayheading", colspan=all_columns+1)
 
 paul@153    972 
            page.add(self.format_date(day, "full"))
 
 paul@114    973 
            page.th.close()
 
 paul@153    974 
            page.tr.close()
 
 paul@186    975 
            page.thead.close()
 
 paul@114    976 
 
 paul@162    977 
            groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]
 
 paul@162    978 
 
 paul@186    979 
            page.tbody()
 
 paul@201    980 
            self.show_calendar_points(intervals, groups_for_day, partitioned_group_types, group_columns)
 
 paul@186    981 
            page.tbody.close()
 
 paul@185    982 
 
 paul@201    983 
    def show_calendar_points(self, intervals, groups, group_types, group_columns):
 
 paul@186    984 
 
 paul@186    985 
        """
 
 paul@201    986 
        Show the time 'intervals' along with period information from the given
 
 paul@186    987 
        'groups', having the indicated 'group_types', each with the number of
 
 paul@186    988 
        columns given by 'group_columns'.
 
 paul@186    989 
        """
 
 paul@186    990 
 
 paul@162    991 
        page = self.page
 
 paul@162    992 
 
 paul@203    993 
        # Produce a row for each interval.
 
 paul@162    994 
 
 paul@201    995 
        intervals = list(intervals)
 
 paul@201    996 
        intervals.sort()
 
 paul@162    997 
 
 paul@201    998 
        for point, endpoint in intervals:
 
 paul@162    999 
            continuation = point == get_start_of_day(point)
 
 paul@153   1000 
 
 paul@203   1001 
            # Some rows contain no period details and are marked as such.
 
 paul@203   1002 
 
 paul@203   1003 
            have_active = reduce(lambda x, y: x or y, [slots.get(point) for slots in groups], None)
 
 paul@203   1004 
 
 paul@203   1005 
            css = " ".join(
 
 paul@203   1006 
                ["slot"] +
 
 paul@231   1007 
                (have_active and ["busy"] or ["empty"]) +
 
 paul@203   1008 
                (continuation and ["daystart"] or [])
 
 paul@203   1009 
                )
 
 paul@203   1010 
 
 paul@203   1011 
            page.tr(class_=css)
 
 paul@162   1012 
            page.th(class_="timeslot")
 
 paul@201   1013 
            self._time_point(point, endpoint)
 
 paul@162   1014 
            page.th.close()
 
 paul@162   1015 
 
 paul@162   1016 
            # Obtain slots for the time point from each group.
 
 paul@162   1017 
 
 paul@171   1018 
            for columns, slots, group_type in zip(group_columns, groups, group_types):
 
 paul@162   1019 
                active = slots and slots.get(point)
 
 paul@162   1020 
 
 paul@191   1021 
                # Where no periods exist for the given time interval, generate
 
 paul@191   1022 
                # an empty cell. Where a participant provides no periods at all,
 
 paul@191   1023 
                # the colspan is adjusted to be 1, not 0.
 
 paul@191   1024 
 
 paul@162   1025 
                if not active:
 
 paul@196   1026 
                    page.td(class_="empty container", colspan=max(columns, 1))
 
 paul@201   1027 
                    self._empty_slot(point, endpoint)
 
 paul@196   1028 
                    page.td.close()
 
 paul@162   1029 
                    continue
 
 paul@162   1030 
 
 paul@162   1031 
                slots = slots.items()
 
 paul@162   1032 
                slots.sort()
 
 paul@162   1033 
                spans = get_spans(slots)
 
 paul@162   1034 
 
 paul@162   1035 
                # Show a column for each active period.
 
 paul@117   1036 
 
 paul@153   1037 
                for t in active:
 
 paul@185   1038 
                    if t and len(t) >= 2:
 
 paul@185   1039 
                        start, end, uid, key = get_freebusy_details(t)
 
 paul@185   1040 
                        span = spans[key]
 
 paul@171   1041 
 
 paul@171   1042 
                        # Produce a table cell only at the start of the period
 
 paul@171   1043 
                        # or when continued at the start of a day.
 
 paul@171   1044 
 
 paul@153   1045 
                        if point == start or continuation:
 
 paul@153   1046 
 
 paul@195   1047 
                            has_continued = continuation and point != start
 
 paul@195   1048 
                            will_continue = not ends_on_same_day(point, end)
 
 paul@195   1049 
                            css = " ".join(
 
 paul@195   1050 
                                ["event"] +
 
 paul@195   1051 
                                (has_continued and ["continued"] or []) +
 
 paul@195   1052 
                                (will_continue and ["continues"] or [])
 
 paul@195   1053 
                                )
 
 paul@195   1054 
 
 paul@189   1055 
                            # Only anchor the first cell of events.
 
 paul@189   1056 
 
 paul@189   1057 
                            if point == start:
 
 paul@195   1058 
                                page.td(class_=css, rowspan=span, id="%s-%s" % (group_type, uid))
 
 paul@189   1059 
                            else:
 
 paul@195   1060 
                                page.td(class_=css, rowspan=span)
 
 paul@171   1061 
 
 paul@153   1062 
                            obj = self._get_object(uid)
 
 paul@185   1063 
 
 paul@185   1064 
                            if not obj:
 
 paul@185   1065 
                                page.span("")
 
 paul@185   1066 
                            else:
 
 paul@213   1067 
                                summary = obj.get_value("SUMMARY")
 
 paul@171   1068 
 
 paul@171   1069 
                                # Only link to events if they are not being
 
 paul@171   1070 
                                # updated by requests.
 
 paul@171   1071 
 
 paul@171   1072 
                                if uid in self._get_requests() and group_type != "request":
 
 paul@189   1073 
                                    page.span(summary)
 
 paul@164   1074 
                                else:
 
 paul@171   1075 
                                    href = "%s/%s" % (self.env.get_url().rstrip("/"), uid)
 
 paul@189   1076 
                                    page.a(summary, href=href)
 
 paul@171   1077 
 
 paul@153   1078 
                            page.td.close()
 
 paul@153   1079 
                    else:
 
 paul@196   1080 
                        page.td(class_="empty container")
 
 paul@201   1081 
                        self._empty_slot(point, endpoint)
 
 paul@196   1082 
                        page.td.close()
 
 paul@114   1083 
 
 paul@166   1084 
                # Pad with empty columns.
 
 paul@166   1085 
 
 paul@166   1086 
                i = columns - len(active)
 
 paul@166   1087 
                while i > 0:
 
 paul@166   1088 
                    i -= 1
 
 paul@196   1089 
                    page.td(class_="empty container")
 
 paul@201   1090 
                    self._empty_slot(point, endpoint)
 
 paul@196   1091 
                    page.td.close()
 
 paul@166   1092 
 
 paul@162   1093 
            page.tr.close()
 
 paul@114   1094 
 
 paul@201   1095 
    def _time_point(self, point, endpoint):
 
 paul@201   1096 
        page = self.page
 
 paul@201   1097 
        value, identifier = self._slot_value_and_identifier(point, endpoint)
 
 paul@238   1098 
        slots = self.env.get_args().get("slot", [])
 
 paul@238   1099 
        if value in slots:
 
 paul@236   1100 
            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent", checked="checked")
 
 paul@202   1101 
        else:
 
 paul@236   1102 
            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent")
 
 paul@201   1103 
        page.label(self.format_time(point, "long"), class_="timepoint", for_=identifier)
 
 paul@201   1104 
 
 paul@201   1105 
    def _empty_slot(self, point, endpoint):
 
 paul@197   1106 
        page = self.page
 
 paul@201   1107 
        value, identifier = self._slot_value_and_identifier(point, endpoint)
 
 paul@236   1108 
        page.label("Select/deselect period", class_="newevent popup", for_=identifier)
 
 paul@196   1109 
 
 paul@201   1110 
    def _slot_value_and_identifier(self, point, endpoint):
 
 paul@202   1111 
        value = "%s-%s" % (format_datetime(point), endpoint and format_datetime(endpoint) or "")
 
 paul@201   1112 
        identifier = "slot-%s" % value
 
 paul@201   1113 
        return value, identifier
 
 paul@196   1114 
 
 paul@69   1115 
    def select_action(self):
 
 paul@69   1116 
 
 paul@69   1117 
        "Select the desired action and show the result."
 
 paul@69   1118 
 
 paul@121   1119 
        path_info = self.env.get_path_info().strip("/")
 
 paul@121   1120 
 
 paul@69   1121 
        if not path_info:
 
 paul@114   1122 
            self.show_calendar()
 
 paul@121   1123 
        elif self.show_object(path_info):
 
 paul@70   1124 
            pass
 
 paul@70   1125 
        else:
 
 paul@70   1126 
            self.no_page()
 
 paul@69   1127 
 
 paul@82   1128 
    def __call__(self):
 
 paul@69   1129 
 
 paul@69   1130 
        "Interpret a request and show an appropriate response."
 
 paul@69   1131 
 
 paul@69   1132 
        if not self.user:
 
 paul@69   1133 
            self.no_user()
 
 paul@69   1134 
        else:
 
 paul@69   1135 
            self.select_action()
 
 paul@69   1136 
 
 paul@70   1137 
        # Write the headers and actual content.
 
 paul@70   1138 
 
 paul@69   1139 
        print >>self.out, "Content-Type: text/html; charset=%s" % self.encoding
 
 paul@69   1140 
        print >>self.out
 
 paul@69   1141 
        self.out.write(unicode(self.page).encode(self.encoding))
 
 paul@69   1142 
 
 paul@69   1143 
if __name__ == "__main__":
 
 paul@128   1144 
    Manager()()
 
 paul@69   1145 
 
 paul@69   1146 
# vim: tabstop=4 expandtab shiftwidth=4