#!/usr/bin/env python  """ Handlers for a person for whom scheduling is performed.  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, uri_item from imiptools.handlers import Handler from imiptools.handlers.common import CommonFreebusy, CommonEvent from imiptools.period import FreeBusyPeriod, Period, replace_overlapping  class PersonHandler(CommonEvent, Handler):      "Event handling mechanisms specific to people."      def _add(self, queue=True):          """         Add an event occurrence for the current object or produce a response         that requests the event details to be sent again.         """          # Obtain valid organiser and attendee details.          oa = self.require_organiser_and_attendees()         if not oa:             return False          (organiser, organiser_attr), attendees = oa          # Request details where configured, doing so for unknown objects anyway.          if self.will_refresh():             self.make_refresh()          # Record the event as a recurrence of the parent object.          self.update_recurrenceid()          # Update the recipient's record of the organiser's schedule.          self.update_freebusy_from_organiser(organiser)          # Stop if requesting the full event.          if self.will_refresh():             return          # Set the additional occurrence.          self.store.set_event(self.user, self.uid, self.recurrenceid, self.obj.to_node())          # Queue any request, if appropriate.          if queue:             self.store.queue_request(self.user, self.uid, self.recurrenceid)          return True      def _counter(self):          """         Record details from a counter-proposal, updating the stored object with         attendance information.         """          # Obtain valid organiser and attendee details.          oa = self.require_organiser_and_attendees(from_organiser=False)         if not oa:             return False          (organiser, organiser_attr), attendees = oa          # The responding attendee is regarded as not attending.          for attendee, attendee_attr in attendees.items():             attendee_attr["PARTSTAT"] = "DECLINED"          # Update this attendance.          if self.merge_attendance(attendees):             self.update_freebusy_from_attendees(attendees)          # Queue any counter-proposal for perusal.          for attendee in attendees.keys():             self.store.set_counter(self.user, attendee, self.obj.to_node(), self.uid, self.recurrenceid)         self.store.queue_request(self.user, self.uid, self.recurrenceid, "COUNTER")          return True      def _record(self, from_organiser=True, queue=False, cancel=False):          """         Record details from the current object given a message originating         from an organiser if 'from_organiser' is set to a true value, queuing a         request if 'queue' is set to a true value, or cancelling an event if         'cancel' is set to a true value.         """          # Obtain valid organiser and attendee details.          oa = self.require_organiser_and_attendees(from_organiser)         if not oa:             return False          (organiser, organiser_attr), attendees = oa          # Handle notifications and invitations.          if from_organiser:              # Process for the current user, an attendee.              if not self.have_new_object():                 return False              # Remove additional recurrences if handling a complete event.              if not self.recurrenceid:                 self.store.remove_recurrences(self.user, self.uid)              # Queue any request, if appropriate.              if queue:                 self.store.queue_request(self.user, self.uid, self.recurrenceid)              # Cancel complete events or particular occurrences in recurring             # events.              if cancel:                 self.store.cancel_event(self.user, self.uid, self.recurrenceid)                 self.store.dequeue_request(self.user, self.uid, self.recurrenceid)                  # Remove any associated request.                  self.store.dequeue_request(self.user, self.uid, self.recurrenceid)                  # No return message will occur to update the free/busy                 # information, so this is done here using outgoing message                 # functionality.                  self.remove_event_from_freebusy()                  # Update the recipient's record of the organiser's schedule.                  self.remove_freebusy_from_organiser(organiser)              else:                 self.update_freebusy_from_organiser(organiser)              # Set the complete event or an additional occurrence.              self.store.set_event(self.user, self.uid, self.recurrenceid, self.obj.to_node())          # As organiser, update attendance from valid attendees.          else:             if self.merge_attendance(attendees):                 self.update_freebusy_from_attendees(attendees)          return True      def _refresh(self):          """         Respond to a refresh message by providing complete event details to         attendees.         """          # Obtain valid organiser and attendee details.          oa = self.require_organiser_and_attendees(False)         if not oa:             return False          (organiser, organiser_attr), attendees = oa          # Filter by stored attendees.          obj = self.get_stored_object_version()         stored_attendees = set(obj.get_values("ATTENDEE"))         attendees = stored_attendees.intersection(attendees)          if not attendees:             return False          # Assume that the outcome will be a request. It would not seem         # completely bizarre to produce a publishing message instead if a         # refresh message was unprovoked.          method = "REQUEST"          for attendee in attendees:             responses = []              # Get the parent event, add SENT-BY details to the organiser.              obj = self.get_stored_object_version()              if self.is_participating(attendee, obj=obj):                 organiser, organiser_attr = uri_item(obj.get_item("ORGANIZER"))                 self.update_sender(organiser_attr)                 responses.append(obj.to_node())              # Get recurrences.              if not self.recurrenceid:                 for recurrenceid in self.store.get_active_recurrences(self.user, self.uid):                      # Get the recurrence, add SENT-BY details to the organiser.                      obj = self.get_stored_object(self.uid, recurrenceid)                      if self.is_participating(attendee, obj=obj):                         organiser, organiser_attr = uri_item(obj.get_item("ORGANIZER"))                         self.update_sender(organiser_attr)                         responses.append(obj.to_node())              self.add_result(method, [get_address(attendee)], to_part(method, responses))          return True  class Event(PersonHandler):      "An event handler."      def add(self):          "Queue a suggested additional recurrence for any active event."          if self.allow_add() and self._add(queue=True):             return self.wrap("An addition to an event has been received.")      def cancel(self):          "Queue a cancellation of any active event."          if self._record(from_organiser=True, queue=False, cancel=True):             return self.wrap("An event cancellation has been received.", link=False)      def counter(self):          "Record a counter-proposal to a proposed event."          # NOTE: Queue a suggested modification to any active event.          if self._counter():             return self.wrap("A counter proposal to an event invitation has been received.", link=False)      def declinecounter(self):          # NOTE: Queue a rejected modification to any active event.          return self.wrap("Your counter proposal to an event invitation has been declined.", link=False)      def publish(self):          "Register details of any relevant event."          if self._record(from_organiser=True, queue=False):             return self.wrap("Details of an event have been received.")      def refresh(self):          "Requests to refresh events are handled either here or by the client."          if self.is_refreshing():             return self._refresh()         else:             return self.wrap("A request for updated event details has been received.")      def reply(self):          "Record replies and notify the recipient."          if self._record(from_organiser=False, queue=False):             return self.wrap("A reply to an event invitation has been received.")      def request(self):          "Hold requests and notify the recipient."          if self._record(from_organiser=True, queue=True):             return self.wrap("An event invitation has been received.")  class PersonFreebusy(CommonFreebusy, Handler):      "Free/busy handling mechanisms specific to people."      def _record_freebusy(self, from_organiser=True):          """         Record free/busy information for a message originating from an organiser         if 'from_organiser' is set to a true value.         """          if from_organiser:             organiser_item = self.require_organiser(from_organiser)             if not organiser_item:                 return              senders = [organiser_item]         else:             oa = self.require_organiser_and_attendees(from_organiser)             if not oa:                 return              organiser_item, attendees = oa             senders = attendees.items()              if not senders:                 return          freebusy = [FreeBusyPeriod(p.get_start_point(), p.get_end_point()) for p in self.obj.get_period_values("FREEBUSY")]         dtstart = self.obj.get_datetime("DTSTART")         dtend = self.obj.get_datetime("DTEND")         period = Period(dtstart, dtend, self.get_tzid())          for sender, sender_attr in senders:             stored_freebusy = self.store.get_freebusy_for_other(self.user, sender)             replace_overlapping(stored_freebusy, period, freebusy)             self.store.set_freebusy_for_other(self.user, stored_freebusy, sender)  class Freebusy(PersonFreebusy):      "A free/busy handler."      def publish(self):          "Register free/busy information."          self._record_freebusy(from_organiser=True)          # Produce a message if configured to do so.          if self.is_notifying():             return self.wrap("A free/busy update has been received.", link=False)      def reply(self):          "Record replies and notify the recipient."          self._record_freebusy(from_organiser=False)          # Produce a message if configured to do so.          if self.is_notifying():             return self.wrap("A reply to a free/busy request has been received.", link=False)      def request(self):          """         Respond to a request by preparing a reply containing free/busy         information for the recipient.         """          # Produce a reply if configured to do so.          if self.is_sharing():             return CommonFreebusy.request(self)  # Handler registry.  handlers = [     ("VFREEBUSY",   Freebusy),     ("VEVENT",      Event),     ]  # vim: tabstop=4 expandtab shiftwidth=4