#!/usr/bin/env python  """ Quota-related scheduling functionality.  Copyright (C) 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.dates import format_duration, get_duration from imiptools.data import get_uri from imiptools.period import Endless from datetime import timedelta  # Quota maintenance.  def check_quota(handler, args):      """     Check the current object of the given 'handler' against the applicable     quota.     """      quota, group = _get_quota_and_group(handler, args)      # Obtain the journal entries and check the balance.      journal = handler.get_journal()     entries = journal.get_entries(quota, group)     limits = journal.get_limits(quota)      # Obtain a limit for the group or any general limit.     # Decline invitations if no limit has been set.      limit = limits.get(group) or limits.get("*")     if not limit:         return "DECLINED"      # Decline events whose durations exceed the balance.      total = _get_duration(handler)      if total == Endless():         return "DECLINED"      balance = get_duration(limit) - _get_usage(entries)      if total > balance:         return "DECLINED"     else:         return "ACCEPTED"  def add_to_quota(handler, args):      """     Record details of the current object of the given 'handler' in the     applicable quota.     """      quota, group = _get_quota_and_group(handler, args)      total = _get_duration(handler)      # Obtain the journal entries and limits.      journal = handler.get_journal()     entries = journal.get_entries(quota, group)      if _add_to_entries(entries, handler.obj.get_uid(), handler.obj.get_recurrenceid(), format_duration(total)):         journal.set_entries(quota, group, entries)  def remove_from_quota(handler, args):      """     Remove details of the current object of the given 'handler' from the     applicable quota.     """      quota, group = _get_quota_and_group(handler, args)      total = _get_duration(handler)      # Obtain the journal entries and limits.      journal = handler.get_journal()     entries = journal.get_entries(quota, group)      if _remove_from_entries(entries, handler.obj.get_uid(), handler.obj.get_recurrenceid(), format_duration(total)):         journal.set_entries(quota, group, entries)  def _get_quota_and_group(handler, args):      """     Combine information about the current object from the 'handler' with the     given 'args' to return a tuple containing the quota group and the user     identity or group involved.     """      quota = args and args[0] or handler.user      # Obtain the identity to whom the quota will apply.      organiser = get_uri(handler.obj.get_value("ORGANIZER"))      # Obtain any user group to which the quota will apply instead.      journal = handler.get_journal()     groups = journal.get_groups(quota)      return quota, groups.get(organiser) or organiser  def _get_duration(handler):      "Return the duration of the current object provided by the 'handler'."      # Count only explicit periods.     # NOTE: Should reject indefinitely recurring events.      total = timedelta(0)      for period in handler.get_periods(handler.obj, explicit_only=True):         duration = period.get_duration()          # Decline events whose period durations are endless.          if duration == Endless():             return duration         else:             total += duration      return total  def _get_usage(entries):      "Return the usage total according to the given 'entries'."      total = timedelta(0)      for found_uid, found_recurrenceid, found_duration in entries:         retraction = found_duration.startswith("-")         multiplier = retraction and -1 or 1         total += multiplier * get_duration(found_duration[retraction and 1 or 0:])      return total  def _add_to_entries(entries, uid, recurrenceid, duration):      """     Add to 'entries' an entry for the event having the given 'uid' and     'recurrenceid' with the given 'duration'.     """      confirmed = _find_applicable_entry(entries, uid, recurrenceid, duration)      # Where a previous entry still applies, retract it if different.      if confirmed:         found_uid, found_recurrenceid, found_duration = confirmed         if found_duration != duration:             entries.append((found_uid, found_recurrenceid, "-%s" % found_duration))         else:             return False      # Without an applicable previous entry, add a new entry.      entries.append((uid, recurrenceid, duration))     return True  def _remove_from_entries(entries, uid, recurrenceid, duration):      """     Remove from the given 'entries' any entry for the event having the given     'uid' and 'recurrenceid' with the given 'duration'.     """      confirmed = _find_applicable_entry(entries, uid, recurrenceid, duration)      # Where a previous entry still applies, retract it.      if confirmed:         found_uid, found_recurrenceid, found_duration = confirmed         entries.append((found_uid, found_recurrenceid, "-%s" % found_duration))         return found_duration == duration      return False  def _find_applicable_entry(entries, uid, recurrenceid, duration):      """     Within 'entries', find any applicable previous entry for this event,     using the 'uid', 'recurrenceid' and 'duration'.     """      confirmed = None      for found_uid, found_recurrenceid, found_duration in entries:         if uid == found_uid and recurrenceid == found_recurrenceid:             if found_duration.startswith("-"):                 confirmed = None             else:                 confirmed = found_uid, found_recurrenceid, found_duration      return confirmed  # Collective free/busy maintenance.  def schedule_across_quota(handler, args):      """     Check the current object of the given 'handler' against the schedules     managed by the quota.     """      quota, organiser = _get_quota_and_identity(handler, args)      # If newer than any old version, discard old details from the     # free/busy record and check for suitability.      periods = handler.get_periods(handler.obj)     freebusy = handler.get_journal().get_freebusy(quota, organiser)     scheduled = handler.can_schedule(freebusy, periods)      return scheduled and "ACCEPTED" or "DECLINED"  def add_to_quota_freebusy(handler, args):      """     Record details of the current object of the 'handler' in the applicable     free/busy resource.     """      quota, organiser = _get_quota_and_identity(handler, args)      journal = handler.get_journal()     freebusy = journal.get_freebusy(quota, organiser)     handler.update_freebusy(freebusy, organiser, True)     journal.set_freebusy(quota, organiser, freebusy)  def remove_from_quota_freebusy(handler, args):      """     Remove details of the current object of the 'handler' from the applicable     free/busy resource.     """      quota, organiser = _get_quota_and_identity(handler, args)      journal = handler.get_journal()     freebusy = journal.get_freebusy(quota, organiser)     handler.remove_from_freebusy(freebusy)     journal.set_freebusy(quota, organiser, freebusy)  def _get_quota_and_identity(handler, args):      """     Combine information about the current object from the 'handler' with the     given 'args' to return a tuple containing the quota group and the user     identity involved.     """      quota = args and args[0] or handler.user      # Obtain the identity for whom the scheduling will apply.      organiser = get_uri(handler.obj.get_value("ORGANIZER"))      return quota, organiser  # Locking and unlocking.  def lock_journal(handler, args):      "Using the 'handler' and 'args', lock the journal for the quota."      handler.get_journal().acquire_lock(_get_quota(handler, args))  def unlock_journal(handler, args):      "Using the 'handler' and 'args', unlock the journal for the quota."      handler.get_journal().release_lock(_get_quota(handler, args))  def _get_quota(handler, args):      "Return the quota using the 'handler' and 'args'."      return args and args[0] or handler.user  # Registry of scheduling functions.  scheduling_functions = {     "check_quota" : check_quota,     "schedule_across_quota" : schedule_across_quota,     }  # Registries of locking and unlocking functions.  locking_functions = {     "check_quota" : lock_journal,     "schedule_across_quota" : lock_journal,     }  unlocking_functions = {     "check_quota" : unlock_journal,     "schedule_across_quota" : unlock_journal,     }  # Registries of listener functions.  confirmation_functions = {     "add_to_quota" : add_to_quota,     "add_to_quota_freebusy" : add_to_quota_freebusy,     }  retraction_functions = {     "remove_from_quota" : remove_from_quota,     "remove_from_quota_freebusy" : remove_from_quota_freebusy,     }  # vim: tabstop=4 expandtab shiftwidth=4