#!/usr/bin/env python  """ Handlers for a resource.  Copyright (C) 2014, 2015, 2016 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.handlers import Handler from imiptools.handlers.common import CommonFreebusy, CommonEvent from imiptools.handlers.scheduling import apply_scheduling_functions, \                                           confirm_scheduling, \                                           finish_scheduling, \                                           retract_scheduling  class ResourceHandler(CommonEvent, Handler):      "Handling mechanisms specific to resources."      def _process(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)          # Confirm the scheduling of the recurrence.          self.confirm_scheduling()      def _schedule_for_attendee(self):          "Attempt to schedule the current object for the current user."          attendee_attr = uri_dict(self.obj.get_value_map("ATTENDEE"))[self.user]          # Attempt to schedule the event.          scheduled = self.schedule()          try:             # Update the participation of the resource in the object.             # Update free/busy information.              if scheduled in ("ACCEPTED", "DECLINED"):                 method = "REPLY"                 attendee_attr = self.update_participation(scheduled)                  self.update_event_in_freebusy(for_organiser=False)                 self.remove_event_from_freebusy_offers()                  # Set the complete event or an additional occurrence.                  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)                  if scheduled == "ACCEPTED":                     self.confirm_scheduling()              # For countered proposals, record the offer in the resource's             # free/busy collection.              elif scheduled == "COUNTER":                 method = "COUNTER"                 self.update_event_in_freebusy_offers()              # For inappropriate periods, reply declining participation.              else:                 method = "REPLY"                 attendee_attr = self.update_participation("DECLINED")          # Confirm any scheduling.          finally:             self.finish_scheduling()          # 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)          # Retract the scheduling of the event.          self.retract_scheduling()      def _revoke_for_attendee(self):          "Revoke any counter-proposal recorded as a free/busy offer."          self.remove_event_from_freebusy_offers()      # Scheduling details.      def schedule(self):          """         Attempt to schedule the current object, returning an indication of the         kind of response to be returned: "COUNTER" for counter-proposals,         "ACCEPTED" for acceptances, "DECLINED" for rejections, and None for         invalid requests.         """          # Obtain a list of scheduling functions.          functions = self.get_preferences().get("scheduling_function",             "schedule_in_freebusy").split("\n")          return apply_scheduling_functions(functions, self)      def confirm_scheduling(self):          "Confirm that this event has been scheduled."          functions = self.get_preferences().get("confirmation_function")          if functions:             confirm_scheduling(functions.split("\n"), self)      def finish_scheduling(self):          "Finish the scheduling, unlocking resources where appropriate."          functions = self.get_preferences().get("scheduling_function",             "schedule_in_freebusy").split("\n")          finish_scheduling(functions, self)      def retract_scheduling(self):          "Retract this event from scheduling records."          functions = self.get_preferences().get("retraction_function")          if functions:             retract_scheduling(functions.split("\n"), self)  class Event(ResourceHandler):      "An event handler."      def add(self):          "Add a new occurrence to an existing event."          self._process(self._add_for_attendee)      def cancel(self):          "Cancel attendance for attendees."          self._process(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._process(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._process(self._schedule_for_attendee)  class Freebusy(CommonFreebusy, Handler):      "A free/busy handler."      def publish(self):          "Resources ignore generally published free/busy information."          self._record_freebusy(from_organiser=True)      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