#!/usr/bin/env python  """ Handlers for a resource.  Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from imiptools.data import get_address, to_part, uri_dict from imiptools.dates import ValidityError from imiptools.handlers import Handler from imiptools.handlers.common import CommonFreebusy, CommonEvent  class ResourceHandler(CommonEvent, Handler):      "Handling mechanisms specific to resources."      def _record_and_respond(self, handle_for_attendee):          """         Record details from the incoming message, using the given         'handle_for_attendee' callable to process any valid message         appropriately.         """          oa = self.require_organiser_and_attendees()         if not oa:             return None          organiser_item, attendees = oa          # Process for the current user, a resource as attendee.          if not self.have_new_object():             return None          # Collect response objects produced when handling the request.          handle_for_attendee()      def _add_for_attendee(self):          """         Attempt to add a recurrence to an existing object for the current user.         This does not request a response concerning participation, apparently.         """          # Request details where configured, doing so for unknown objects anyway.          if self.will_refresh():             self.make_refresh()             return          # Record the event as a recurrence of the parent object.          self.update_recurrenceid()         self.store.set_event(self.user, self.uid, self.recurrenceid, self.obj.to_node())          # Remove any previous cancellations involving this event.          self.store.remove_cancellation(self.user, self.uid, self.recurrenceid)          # Update free/busy information.          self.update_event_in_freebusy(for_organiser=False)      def _schedule_for_attendee(self):          "Attempt to schedule the current object for the current user."          method = "REPLY"         attendee_attr = uri_dict(self.obj.get_value_map("ATTENDEE"))[self.user]          # Check any constraints on the request.          try:             corrected = self.correct_object()          # Refuse to schedule obviously invalid requests.          except ValidityError:             attendee_attr = self.update_participation("DECLINED")          # With a valid request, determine whether the event can be scheduled.          else:             # Interpretation of periods can depend on the time zone.              tzid = self.get_tzid()              # If newer than any old version, discard old details from the             # free/busy record and check for suitability.              periods = self.obj.get_periods(tzid, self.get_window_end())              freebusy = self.store.get_freebusy(self.user)             offers = self.store.get_freebusy_offers(self.user)              # Check the periods against any scheduled events and against             # any outstanding offers.              scheduled = self.can_schedule(freebusy, periods)             scheduled = scheduled and self.can_schedule(offers, periods)              # Where the corrected object can be scheduled, issue a counter             # request.              if scheduled and corrected:                 method = "COUNTER"              # Find the next available slot if the event cannot be scheduled.              #elif not scheduled and len(periods) == 1:              #    # Find a free period, update the object with the details.              #    duration = periods[0].get_duration()             #    free = invert_freebusy(freebusy)              #    for found in periods_from(free, periods[0]):             #        # NOTE: Correct the found period first.             #        if found.get_duration() >= duration             #            scheduled = True             #            method = "COUNTER"             #            # NOTE: Set the period using the original duration.             #            break              # Update the participation of the resource in the object.             # Update free/busy information.              if method == "REPLY":                 attendee_attr = self.update_participation(scheduled and "ACCEPTED" or "DECLINED")                  self.update_event_in_freebusy(for_organiser=False)                 self.remove_event_from_freebusy_offers()              # For countered proposals, record the offer in the resource's             # free/busy collection.              elif method == "COUNTER":                 self.update_event_in_freebusy_offers()          # Set the complete event or an additional occurrence.          if method == "REPLY":             event = self.obj.to_node()             self.store.set_event(self.user, self.uid, self.recurrenceid, event)              # Remove additional recurrences if handling a complete event.             # Also remove any previous cancellations involving this event.              if not self.recurrenceid:                 self.store.remove_recurrences(self.user, self.uid)                 self.store.remove_cancellations(self.user, self.uid)             else:                 self.store.remove_cancellation(self.user, self.uid, self.recurrenceid)          # Make a version of the object with just this attendee, update the         # DTSTAMP in the response, and return the object for sending.          self.update_sender(attendee_attr)         self.obj["ATTENDEE"] = [(self.user, attendee_attr)]         self.update_dtstamp()         self.add_result(method, map(get_address, self.obj.get_values("ORGANIZER")), to_part(method, [self.obj.to_node()]))      def _cancel_for_attendee(self):          """         Cancel for the current user their attendance of the event described by         the current object.         """          # Update free/busy information.          self.remove_event_from_freebusy()          # Update the stored event and cancel it.          self.store.set_event(self.user, self.uid, self.recurrenceid, self.obj.to_node())         self.store.cancel_event(self.user, self.uid, self.recurrenceid)      def _revoke_for_attendee(self):          "Revoke any counter-proposal recorded as a free/busy offer."          self.remove_event_from_freebusy_offers()  class Event(ResourceHandler):      "An event handler."      def add(self):          "Add a new occurrence to an existing event."          self._record_and_respond(self._add_for_attendee)      def cancel(self):          "Cancel attendance for attendees."          self._record_and_respond(self._cancel_for_attendee)      def counter(self):          "Since this handler does not send requests, it will not handle replies."          pass      def declinecounter(self):          "Revoke any counter-proposal."          self._record_and_respond(self._revoke_for_attendee)      def publish(self):          """         Resources only consider events sent as requests, not generally published         events.         """          pass      def refresh(self):          """         Refresh messages are typically sent to event organisers, but resources         do not act as organisers themselves.         """          pass      def reply(self):          "Since this handler does not send requests, it will not handle replies."          pass      def request(self):          """         Respond to a request by preparing a reply containing accept/decline         information for the recipient.          No support for countering requests is implemented.         """          self._record_and_respond(self._schedule_for_attendee)  class Freebusy(CommonFreebusy, Handler):      "A free/busy handler."      def publish(self):          "Resources ignore generally published free/busy information."          pass      def reply(self):          "Since this handler does not send requests, it will not handle replies."          pass      # request provided by CommonFreeBusy.request  # Handler registry.  handlers = [     ("VFREEBUSY",   Freebusy),     ("VEVENT",      Event),     ]  # vim: tabstop=4 expandtab shiftwidth=4