imip-agent

Annotated imip_manager.py

237:423eb08d06b9
2015-02-02 Paul Boddie Adjusted the colours associated with show/hide controls.
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@202 1098
        slot = self.env.get_args().get("slot", [None])[0]
paul@202 1099
        if slot == value:
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