imip-agent

Annotated imip_manager.py

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