#!/usr/bin/env python  """ Interpretation and preparation of iMIP content, together with a content handling mechanism employed by specific recipients.  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 datetime import datetime, timedelta from email.mime.text import MIMEText from imiptools.config import MANAGER_PATH, MANAGER_URL from imiptools.data import Object, parse_object, \                            get_address, get_uri, get_value, \                            is_new_object, uri_dict, uri_item from imiptools.dates import format_datetime, to_timezone from imiptools.period import can_schedule, insert_period, remove_period, \                              remove_from_freebusy, \                              remove_from_freebusy_for_other, \                              update_freebusy, update_freebusy_for_other from pytz import timezone from socket import gethostname import imip_store  try:     from cStringIO import StringIO except ImportError:     from StringIO import StringIO  # Handler mechanism objects.  def handle_itip_part(part, handlers):      """     Handle the given iTIP 'part' using the given 'handlers' dictionary.      Return a list of responses, each response being a tuple of the form     (outgoing-recipients, message-part).     """      method = part.get_param("method")      # Decode the data and parse it.      f = StringIO(part.get_payload(decode=True))      itip = parse_object(f, part.get_content_charset(), "VCALENDAR")      # Ignore the part if not a calendar object.      if not itip:         return      # Require consistency between declared and employed methods.      if get_value(itip, "METHOD") == method:          # Look for different kinds of sections.          all_results = []          for name, items in itip.items():              # Get a handler for the given section.              handler = handlers.get(name)             if not handler:                 continue              for item in items:                  # Dispatch to a handler and obtain any response.                  handler.set_object(Object({name : item}))                 methods[method](handler)()  # References to the Web interface.  def get_manager_url():     url_base = MANAGER_URL or "http://%s/" % gethostname()     return "%s/%s" % (url_base.rstrip("/"), MANAGER_PATH.lstrip("/"))  def get_object_url(uid):     return "%s/%s" % (get_manager_url().rstrip("/"), uid)  class Handler:      "General handler support."      def __init__(self, senders=None, recipient=None, messenger=None):          """         Initialise the handler with the calendar 'obj' and the 'senders' and         'recipient' of the object (if specifically indicated).         """          self.senders = senders and set(map(get_address, senders))         self.recipient = recipient and get_address(recipient)         self.messenger = messenger          self.results = []         self.outgoing_methods = set()          self.obj = None         self.uid = None         self.sequence = None         self.dtstamp = None          self.store = imip_store.FileStore()          try:             self.publisher = imip_store.FilePublisher()         except OSError:             self.publisher = None      def set_object(self, obj):         self.obj = obj         self.uid = self.obj.get_value("UID")         self.sequence = self.obj.get_value("SEQUENCE")         self.dtstamp = self.obj.get_value("DTSTAMP")      def wrap(self, text, link=True):          "Wrap any valid message for passing to the recipient."          texts = []         texts.append(text)         if link:             texts.append("If your mail program cannot handle this "                          "message, you may view the details here:\n\n%s" %                          get_object_url(self.uid))          return self.add_result(None, None, MIMEText("\n".join(texts)))      # Result registration.      def add_result(self, method, outgoing_recipients, part):          """         Record a result having the given 'method', 'outgoing_recipients' and         message part.         """          if outgoing_recipients:             self.outgoing_methods.add(method)         self.results.append((outgoing_recipients, part))      def get_results(self):         return self.results      def get_outgoing_methods(self):         return self.outgoing_methods      # Access to calendar structures and other data.      def remove_from_freebusy(self, freebusy, attendee):         remove_from_freebusy(freebusy, attendee, self.uid, self.store)      def remove_from_freebusy_for_other(self, freebusy, user, other):         remove_from_freebusy_for_other(freebusy, user, other, self.uid, self.store)      def update_freebusy(self, freebusy, attendee, periods):         return update_freebusy(freebusy, attendee, periods, self.obj.get_value("TRANSP"), self.uid, self.store)      def update_freebusy_from_organiser(self, attendee, organiser_item):          """         For the 'attendee', record free/busy information from the         'organiser_item' (a value plus attributes).         """          organiser, organiser_attr = organiser_item          if organiser != attendee:             freebusy = self.store.get_freebusy_for_other(attendee, organiser)              if organiser_attr.get("PARTSTAT") != "DECLINED":                 update_freebusy_for_other(freebusy, attendee, organiser,                     self.obj.get_periods(), self.obj.get_value("TRANSP"),                     self.uid, self.store)             else:                 self.remove_from_freebusy_for_other(freebusy, attendee, organiser)      def update_freebusy_from_attendees(self, organiser, attendees):          "For the 'organiser', record free/busy information from 'attendees'."          for attendee, attendee_attr in attendees.items():             if organiser != attendee:                 freebusy = self.store.get_freebusy_for_other(organiser, attendee)                  if attendee_attr.get("PARTSTAT") != "DECLINED":                     update_freebusy_for_other(freebusy, organiser, attendee,                         self.obj.get_periods(), self.obj.get_value("TRANSP"),                         self.uid, self.store)                 else:                     self.remove_from_freebusy_for_other(freebusy, organiser, attendee)      def can_schedule(self, freebusy, periods):         return can_schedule(freebusy, periods, self.uid)      def filter_by_senders(self, mapping):          """         Return a list of items from 'mapping' filtered using sender information.         """          if self.senders:              # Get a mapping from senders to identities.              identities = self.get_sender_identities(mapping)              # Find the senders that are valid.              senders = map(get_address, identities)             valid = self.senders.intersection(senders)              # Return the true identities.              return [identities[get_uri(address)] for address in valid]         else:             return mapping      def filter_by_recipient(self, mapping):          """         Return a list of items from 'mapping' filtered using recipient         information.         """          if self.recipient:             addresses = set(map(get_address, mapping))             return map(get_uri, addresses.intersection([self.recipient]))         else:             return mapping      def require_organiser_and_attendees(self, from_organiser=True):          """         Return the organiser and attendees for the current object, filtered for         the recipient of interest. Return None if no identities are eligible.          Organiser and attendee identities are provided as lower case values.         """          attendee_map = uri_dict(self.obj.get_value_map("ATTENDEE"))         organiser_item = uri_item(self.obj.get_item("ORGANIZER"))          # Only provide details for attendees who sent/receive the message.          attendee_filter_fn = from_organiser and self.filter_by_recipient or self.filter_by_senders          attendees = {}         for attendee in attendee_filter_fn(attendee_map):             attendees[attendee] = attendee_map[attendee]          if not attendees or not organiser_item:             return None          # Only provide details for an organiser who sent/receives the message.          organiser_filter_fn = from_organiser and self.filter_by_senders or self.filter_by_recipient          if not organiser_filter_fn(dict([organiser_item])):             return None          return organiser_item, attendees      def get_sender_identities(self, mapping):          """         Return a mapping from actual senders to the identities for which they         have provided data, extracting this information from the given         'mapping'.         """          senders = {}          for value, attr in mapping.items():             sent_by = attr.get("SENT-BY")             if sent_by:                 senders[get_uri(sent_by)] = value             else:                 senders[value] = value          return senders      def get_object(self, user):          """         Return the stored object to which the current object refers for the         given 'user' and for the given 'objtype'.         """          f = self.store.get_event(user, self.uid)         fragment = f and parse_object(f, "utf-8")         return fragment and Object(fragment)      def have_new_object(self, attendee, obj=None):          """         Return whether the current object is new to the 'attendee' (or if the         given 'obj' is new).         """          obj = obj or self.get_object(attendee)          # If found, compare SEQUENCE and potentially DTSTAMP.          if obj:             sequence = obj.get_value("SEQUENCE")             dtstamp = obj.get_value("DTSTAMP")              # If the request refers to an older version of the object, ignore             # it.              return is_new_object(sequence, self.sequence, dtstamp, self.dtstamp,                 self.is_partstat_updated(obj))          return True      def is_partstat_updated(self, obj):          """         Return whether the participant status has been updated in the current         object in comparison to the given 'obj'.          NOTE: Some clients like Claws Mail erase time information from DTSTAMP         NOTE: and make it invalid. Thus, such attendance information may also be         NOTE: incorporated into any new object assessment.         """          old_attendees = obj.get_value_map("ATTENDEE")         new_attendees = self.obj.get_value_map("ATTENDEE")          for attendee, attr in old_attendees.items():             old_partstat = attr.get("PARTSTAT")             new_attr = new_attendees.get(attendee)             new_partstat = new_attr and new_attr.get("PARTSTAT")              if old_partstat == "NEEDS-ACTION" and new_partstat and \                new_partstat != old_partstat:                  return True          return False      def merge_attendance(self, attendees, identity):          """         Merge attendance from the current object's 'attendees' into the version         stored for the given 'identity'.         """          obj = self.get_object(identity)          if not obj or not self.have_new_object(identity, obj=obj):             return False          # Get attendee details in a usable form.          attendee_map = uri_dict(obj.get_value_map("ATTENDEE"))          for attendee, attendee_attr in attendees.items():              # Update attendance in the loaded object.              attendee_map[attendee] = attendee_attr          # Set the new details and store the object.          obj["ATTENDEE"] = attendee_map.items()          self.store.set_event(identity, self.uid, obj.to_node())          return True      def update_dtstamp(self):          "Update the DTSTAMP in the current object."          dtstamp = self.obj.get_utc_datetime("DTSTAMP")         utcnow = to_timezone(datetime.utcnow(), "UTC")         self.obj["DTSTAMP"] = [(format_datetime(dtstamp > utcnow and dtstamp or utcnow), {})]      def set_sequence(self, increment=False):          "Update the SEQUENCE in the current object."          sequence = self.obj.get_value("SEQUENCE") or "0"         self.obj["SEQUENCE"] = [(str(int(sequence) + (increment and 1 or 0)), {})]  # Handler registry.  methods = {     "ADD"            : lambda handler: handler.add,     "CANCEL"         : lambda handler: handler.cancel,     "COUNTER"        : lambda handler: handler.counter,     "DECLINECOUNTER" : lambda handler: handler.declinecounter,     "PUBLISH"        : lambda handler: handler.publish,     "REFRESH"        : lambda handler: handler.refresh,     "REPLY"          : lambda handler: handler.reply,     "REQUEST"        : lambda handler: handler.request,     }  # vim: tabstop=4 expandtab shiftwidth=4