git.tine20.org Git - tine20/blob - tine20/Calendar/Controller/Event.php

   1 <?php
   2 /**
   3  * Tine 2.0
   4  *
   5  * @package     Calendar
   6  * @license     http://www.gnu.org/licenses/agpl.html AGPL Version 3
   7  * @author      Cornelius Weiss <c.weiss@metaways.de>
   8  * @copyright   Copyright (c) 2010-2012 Metaways Infosystems GmbH (http://www.metaways.de)
   9  */
  10
  11 /**
  12  * Calendar Event Controller
  13  *
  14  * In the calendar application, the container grants concept is slightly extended:
  15  *  1. GRANTS for events are not only based on the events "calendar" (technically
  16  *     a container) but additionally a USER gets implicit grants for an event if
  17  *     he is ATTENDER (+READ GRANT) or ORGANIZER (+READ,EDIT GRANT).
  18  *  2. ATTENDER which are invited to a certain "event" can assign the "event" to
  19  *     one of their personal calenders as "display calendar" (technically personal
  20  *     containers they are admin of). The "display calendar" of an ATTENDER is
  21  *     stored in the attendee table.  Each USER has a default calendar, as
  22  *     PREFERENCE,  all invitations are assigned to.
  23  *  3. The "effective GRANT" a USER has on an event (read/update/delete/...) is the
  24  *     maximum GRANT of the following sources:
  25  *      - container: GRANT the USER has to the calender of the event
  26  *      - implicit:  Additional READ GRANT for an attender and READ,EDIT
  27  *                   GRANT for the organizer.
  28 *       - inherited: FREEBUSY, READ, PRIVATE, SYNC, EXPORT can be inherited
  29 *                    from the GRANTS USER has to the a display calendar
  30  *
  31  * When Applying/Asuring grants, we have to deal with two differnt situations:
  32  *  A: Check: Check individual grants on a event (record) basis.
  33  *            This is required for create/update/delete actions and done by
  34  *            this controllers _checkGrant method.
  35  *  B: Seach: From the grants perspective this is a multi step process
  36  *            1. fetch all records with appropriate grants from backend
  37  *            2. cleanup records user has only free/busy grant for
  38  *
  39  *  NOTE: To empower the client for enabling/disabling of actions based on the
  40  *        grants a user has to an event, we need to compute the "effective GRANT"
  41  *        for read/search operations.
  42  *
  43  * Case A is not critical, as the amount of data is low.
  44  * Case B however is the hard one, as lots of events and calendars may be
  45  * involved.
  46  *
  47  * NOTE: the backend always fetches full records for grant calculations.
  48  *       searching ids only does not hlep with performance
  49  *
  50  * @package Calendar
  51  */
  52 class Calendar_Controller_Event extends Tinebase_Controller_Record_Abstract implements Tinebase_Controller_Alarm_Interface
  53 {
  54     /**
  55      * @var boolean
  56      *
  57      * just set is_delete=1 if record is going to be deleted
  58      */
  59     protected $_purgeRecords = FALSE;
  60
  61     /**
  62      * send notifications?
  63      *
  64      * @var boolean
  65      */
  66     protected $_sendNotifications = TRUE;
  67
  68     /**
  69      * @see Tinebase_Controller_Record_Abstract
  70      *
  71      * @var boolean
  72      */
  73     protected $_resolveCustomFields = TRUE;
  74
  75     /**
  76      * @var Calendar_Model_Attender
  77      */
  78     protected $_calendarUser = NULL;
  79
  80     /**
  81      * @var Calendar_Controller_Event
  82      */
  83     private static $_instance = NULL;
  84
  85     /**
  86      * the constructor
  87      *
  88      * don't use the constructor. use the singleton
  89      */
  90     private function __construct()
  91     {
  92         $this->_applicationName = 'Calendar';
  93         $this->_modelName       = 'Calendar_Model_Event';
  94         $this->_backend         = new Calendar_Backend_Sql();
  95
  96         // set default CU
  97         $this->setCalendarUser(new Calendar_Model_Attender(array(
  98             'user_type' => Calendar_Model_Attender::USERTYPE_USER,
  99             'user_id'   => Calendar_Controller_MSEventFacade::getCurrentUserContactId()
 100         )));
 101     }
 102
 103     /**
 104      * don't clone. Use the singleton.
 105      */
 106     private function __clone()
 107     {
 108
 109     }
 110
 111     /**
 112      * singleton
 113      *
 114      * @return Calendar_Controller_Event
 115      */
 116     public static function getInstance()
 117     {
 118         if (self::$_instance === NULL) {
 119             self::$_instance = new Calendar_Controller_Event();
 120         }
 121         return self::$_instance;
 122     }
 123
 124     /**
 125      * sets current calendar user
 126      *
 127      * @param Calendar_Model_Attender $_calUser
 128      * @return Calendar_Model_Attender oldUser
 129      */
 130     public function setCalendarUser(Calendar_Model_Attender $_calUser)
 131     {
 132         if (! in_array($_calUser->user_type, array(Calendar_Model_Attender::USERTYPE_USER, Calendar_Model_Attender::USERTYPE_GROUPMEMBER))) {
 133             throw new Tinebase_Exception_UnexpectedValue('Calendar user must be a contact');
 134         }
 135         $oldUser = $this->_calendarUser;
 136         $this->_calendarUser = $_calUser;
 137
 138         return $oldUser;
 139     }
 140
 141     /**
 142      * get current calendar user
 143      *
 144      * @return Calendar_Model_Attender
 145      */
 146     public function getCalendarUser()
 147     {
 148         return $this->_calendarUser;
 149     }
 150
 151     /**
 152      * checks if all attendee of given event are not busy for given event
 153      *
 154      * @param Calendar_Model_Event $_event
 155      * @return void
 156      * @throws Calendar_Exception_AttendeeBusy
 157      */
 158     public function checkBusyConflicts($_event)
 159     {
 160         $ignoreUIDs = !empty($_event->uid) ? array($_event->uid) : array();
 161
 162         if ($_event->transp == Calendar_Model_Event::TRANSP_TRANSP || count($_event->attendee) < 1) {
 163             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 164                 . " Skipping free/busy check because event is transparent");
 165             return;
 166         }
 167
 168         $eventSet = new Tinebase_Record_RecordSet('Calendar_Model_Event', array($_event));
 169
 170         if (! empty($_event->rrule)) {
 171             $checkUntil = clone $_event->dtstart;
 172             $checkUntil->add(1, Tinebase_DateTime::MODIFIER_MONTH);
 173             Calendar_Model_Rrule::mergeRecurrenceSet($eventSet, $_event->dtstart, $checkUntil);
 174         }
 175
 176         $periods = array();
 177         foreach ($eventSet as $event) {
 178             $periods[] = array('from' => $event->dtstart, 'until' => $event->dtend);
 179         }
 180
 181         $fbInfo = $this->getFreeBusyInfo($periods, $_event->attendee, $ignoreUIDs);
 182
 183         if (count($fbInfo) > 0) {
 184             $busyException = new Calendar_Exception_AttendeeBusy();
 185             $busyException->setFreeBusyInfo($fbInfo);
 186
 187             Calendar_Model_Attender::resolveAttendee($_event->attendee, /* resolve_display_containers = */ false);
 188             $busyException->setEvent($_event);
 189
 190             throw $busyException;
 191         }
 192
 193         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 194             . " Free/busy check: no conflict found");
 195     }
 196
 197     /**
 198      * add one record
 199      *
 200      * @param   Tinebase_Record_Interface $_record
 201      * @param   bool                      $_checkBusyConflicts
 202      * @return  Tinebase_Record_Interface
 203      * @throws  Tinebase_Exception_AccessDenied
 204      * @throws  Tinebase_Exception_Record_Validation
 205      */
 206     public function create(Tinebase_Record_Interface $_record, $_checkBusyConflicts = FALSE)
 207     {
 208         try {
 209             $db = $this->_backend->getAdapter();
 210             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($db);
 211
 212             $this->_inspectEvent($_record);
 213
 214             // we need to resolve groupmembers before free/busy checking
 215             Calendar_Model_Attender::resolveGroupMembers($_record->attendee);
 216
 217             if ($_checkBusyConflicts) {
 218                 // ensure that all attendee are free
 219                 $this->checkBusyConflicts($_record);
 220             }
 221
 222             $sendNotifications = $this->_sendNotifications;
 223             $this->_sendNotifications = FALSE;
 224
 225             $createdEvent = parent::create($_record);
 226
 227             $this->_sendNotifications = $sendNotifications;
 228
 229             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
 230         } catch (Exception $e) {
 231             Tinebase_TransactionManager::getInstance()->rollBack();
 232             throw $e;
 233         }
 234
 235         // send notifications
 236         if ($this->_sendNotifications && $_record->mute != 1) {
 237             $this->doSendNotifications($createdEvent, Tinebase_Core::getUser(), 'created');
 238         }
 239
 240         return $createdEvent;
 241     }
 242
 243     /**
 244      * inspect creation of one record (after create)
 245      *
 246      * @param   Tinebase_Record_Interface $_createdRecord
 247      * @param   Tinebase_Record_Interface $_record
 248      * @return  void
 249      */
 250     protected function _inspectAfterCreate($_createdRecord, Tinebase_Record_Interface $_record)
 251     {
 252         $this->_saveAttendee($_record, $_createdRecord);
 253     }
 254
 255     /**
 256      * deletes a recur series
 257      *
 258      * @param  Calendar_Model_Event $_recurInstance
 259      * @return void
 260      */
 261     public function deleteRecurSeries($_recurInstance)
 262     {
 263         $baseEvent = $this->getRecurBaseEvent($_recurInstance);
 264         $this->delete($baseEvent->getId());
 265     }
 266
 267     /**
 268      * Gets all entries
 269      *
 270      * @param string $_orderBy Order result by
 271      * @param string $_orderDirection Order direction - allowed are ASC and DESC
 272      * @throws Tinebase_Exception_InvalidArgument
 273      * @return Tinebase_Record_RecordSet
 274      */
 275     public function getAll($_orderBy = 'id', $_orderDirection = 'ASC')
 276     {
 277         throw new Tinebase_Exception_NotImplemented('not implemented');
 278     }
 279
 280     /**
 281      * returns freebusy information for given period and given attendee
 282      *
 283      * @todo merge overlapping events to one freebusy entry
 284      *
 285      * @param  array of array with from and until                   $_periods
 286      * @param  Tinebase_Record_RecordSet of Calendar_Model_Attender $_attendee
 287      * @param  array of UIDs                                        $_ignoreUIDs
 288      * @return Tinebase_Record_RecordSet of Calendar_Model_FreeBusy
 289      */
 290     public function getFreeBusyInfo($_periods, $_attendee, $_ignoreUIDs = array())
 291     {
 292         $fbInfoSet = new Tinebase_Record_RecordSet('Calendar_Model_FreeBusy');
 293
 294         // map groupmembers to users
 295         $attendee = clone $_attendee;
 296         $attendee->addIndices(array('user_type'));
 297         $groupmembers = $attendee->filter('user_type', Calendar_Model_Attender::USERTYPE_GROUPMEMBER);
 298         $groupmembers->user_type = Calendar_Model_Attender::USERTYPE_USER;
 299
 300         // base filter data
 301         $filterData = array(
 302             array('field' => 'attender', 'operator' => 'in',     'value' => $_attendee),
 303             array('field' => 'transp',   'operator' => 'equals', 'value' => Calendar_Model_Event::TRANSP_OPAQUE)
 304         );
 305
 306         // add all periods to filterdata
 307         $periodFilters = array();
 308         foreach ($_periods as $period) {
 309             $periodFilters[] = array(
 310                 'field' => 'period',
 311                 'operator' => 'within',
 312                 'value' => array(
 313                     'from' => $period['from'],
 314                     'until' => $period['until']
 315             ));
 316         }
 317         $filterData[] = array('condition' => 'OR', 'filters' => $periodFilters);
 318
 319         // finaly create filter
 320         $filter = new Calendar_Model_EventFilter($filterData);
 321
 322         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . ' ' . __LINE__
 323             . ' free/busy filter: ' . print_r($filter->toArray(), true));
 324
 325         $events = $this->search($filter, new Tinebase_Model_Pagination(), FALSE, FALSE);
 326
 327         foreach ($_periods as $period) {
 328             Calendar_Model_Rrule::mergeRecurrenceSet($events, $period['from'], $period['until']);
 329         }
 330
 331         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . ' ' . __LINE__
 332             . ' value: ' . print_r($events->toArray(), true));
 333
 334         // create a typemap
 335         $typeMap = array();
 336         foreach ($attendee as $attender) {
 337             if (! (isset($typeMap[$attender['user_type']]) || array_key_exists($attender['user_type'], $typeMap))) {
 338                 $typeMap[$attender['user_type']] = array();
 339             }
 340
 341             $typeMap[$attender['user_type']][$attender['user_id']] = array();
 342         }
 343         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . ' ' . __LINE__
 344             . ' value: ' . print_r($typeMap, true));
 345
 346         // generate freeBusyInfos
 347         foreach ($events as $event) {
 348             // skip events with ignoreUID
 349             if (in_array($event->uid, $_ignoreUIDs)) {
 350                 continue;
 351             }
 352
 353             // check if event is conflicting one of the given periods
 354             $conflicts = FALSE;
 355             foreach($_periods as $period) {
 356                 if ($event->dtstart->isEarlier($period['until']) && $event->dtend->isLater($period['from'])) {
 357                     $conflicts = TRUE;
 358                     break;
 359                 }
 360             }
 361             if (! $conflicts) {
 362                 continue;
 363             }
 364
 365             // map groupmembers to users
 366             $event->attendee->addIndices(array('user_type'));
 367             $groupmembers = $event->attendee->filter('user_type', Calendar_Model_Attender::USERTYPE_GROUPMEMBER);
 368             $groupmembers->user_type = Calendar_Model_Attender::USERTYPE_USER;
 369
 370             foreach ($event->attendee as $attender) {
 371                 // skip declined/transp events
 372                 if ($attender->status == Calendar_Model_Attender::STATUS_DECLINED ||
 373                     $attender->transp == Calendar_Model_Event::TRANSP_TRANSP) {
 374                     continue;
 375                 }
 376
 377                 if ((isset($typeMap[$attender->user_type]) || array_key_exists($attender->user_type, $typeMap)) && (isset($typeMap[$attender->user_type][$attender->user_id]) || array_key_exists($attender->user_id, $typeMap[$attender->user_type]))) {
 378                     $fbInfo = new Calendar_Model_FreeBusy(array(
 379                         'user_type' => $attender->user_type,
 380                         'user_id'   => $attender->user_id,
 381                         'dtstart'   => clone $event->dtstart,
 382                         'dtend'     => clone $event->dtend,
 383                         'type'      => Calendar_Model_FreeBusy::FREEBUSY_BUSY,
 384                     ), true);
 385
 386                     if ($event->{Tinebase_Model_Grants::GRANT_READ}) {
 387                         $fbInfo->event = clone $event;
 388                         unset($fbInfo->event->attendee);
 389                     }
 390
 391                     //$typeMap[$attender->user_type][$attender->user_id][] = $fbInfo;
 392                     $fbInfoSet->addRecord($fbInfo);
 393                 }
 394             }
 395         }
 396
 397         return $fbInfoSet;
 398     }
 399
 400     /**
 401      * get list of records
 402      *
 403      * @param Tinebase_Model_Filter_FilterGroup|optional    $_filter
 404      * @param Tinebase_Model_Pagination|optional            $_pagination
 405      * @param bool                                          $_getRelations
 406      * @param boolean                                       $_onlyIds
 407      * @param string                                        $_action for right/acl check
 408      * @return Tinebase_Record_RecordSet|array
 409      */
 410     public function search(Tinebase_Model_Filter_FilterGroup $_filter = NULL, Tinebase_Record_Interface $_pagination = NULL, $_getRelations = FALSE, $_onlyIds = FALSE, $_action = 'get')
 411     {
 412         $events = parent::search($_filter, $_pagination, $_getRelations, $_onlyIds, $_action);
 413         if (! $_onlyIds) {
 414             $this->_freeBusyCleanup($events, $_action);
 415         }
 416
 417         return $events;
 418     }
 419
 420     /**
 421      * Returns a set of records identified by their id's
 422      *
 423      * @param   array $_ids       array of record identifiers
 424      * @param   bool  $_ignoreACL don't check acl grants
 425      * @return  Tinebase_Record_RecordSet of $this->_modelName
 426      */
 427     public function getMultiple($_ids, $_ignoreACL = false)
 428     {
 429         $events = parent::getMultiple($_ids, $_ignoreACL = false);
 430         if ($_ignoreACL !== true) {
 431             $this->_freeBusyCleanup($events, 'get');
 432         }
 433
 434         return $events;
 435     }
 436
 437     /**
 438      * cleanup search results (freebusy)
 439      *
 440      * @param Tinebase_Record_RecordSet $_events
 441      * @param string $_action
 442      */
 443     protected function _freeBusyCleanup(Tinebase_Record_RecordSet $_events, $_action)
 444     {
 445         foreach ($_events as $event) {
 446             $doFreeBusyCleanup = $event->doFreeBusyCleanup();
 447             if ($doFreeBusyCleanup && $_action !== 'get') {
 448                 $_events->removeRecord($event);
 449             }
 450         }
 451     }
 452
 453     /**
 454      * returns freeTime (suggestions) for given period of given attendee
 455      *
 456      * @param  Tinebase_DateTime                                            $_from
 457      * @param  Tinebase_DateTime                                            $_until
 458      * @param  Tinebase_Record_RecordSet of Calendar_Model_Attender $_attendee
 459      *
 460      * ...
 461      */
 462     public function searchFreeTime($_from, $_until, $_attendee/*, $_constains, $_mode*/)
 463     {
 464         $fbInfoSet = $this->getFreeBusyInfo(array(array('from' => $_from, 'until' => $_until)), $_attendee);
 465
 466 //        $fromTs = $_from->getTimestamp();
 467 //        $untilTs = $_until->getTimestamp();
 468 //        $granularity = 1800;
 469 //
 470 //        // init registry of granularity
 471 //        $eventRegistry = array_combine(range($fromTs, $untilTs, $granularity), array_fill(0, ceil(($untilTs - $fromTs)/$granularity)+1, ''));
 472 //
 473 //        foreach ($fbInfoSet as $fbInfo) {
 474 //            $startIdx = $fromTs + $granularity * floor(($fbInfo->dtstart->getTimestamp() - $fromTs) / $granularity);
 475 //            $endIdx = $fromTs + $granularity * ceil(($fbInfo->dtend->getTimestamp() - $fromTs) / $granularity);
 476 //
 477 //            for ($idx=$startIdx; $idx<=$endIdx; $idx+=$granularity) {
 478 //                //$eventRegistry[$idx][] = $fbInfo;
 479 //                $eventRegistry[$idx] .= '.';
 480 //            }
 481 //        }
 482
 483         //print_r($eventRegistry);
 484     }
 485
 486     /**
 487      * update one record
 488      *
 489      * @param   Tinebase_Record_Interface $_record
 490      * @param   bool                      $_checkBusyConflicts
 491      * @param   string                    $range
 492      * @return  Tinebase_Record_Interface
 493      * @throws  Tinebase_Exception_AccessDenied
 494      * @throws  Tinebase_Exception_Record_Validation
 495      */
 496     public function update(Tinebase_Record_Interface $_record, $_checkBusyConflicts = FALSE, $range = Calendar_Model_Event::RANGE_THIS)
 497     {
 498         try {
 499             $db = $this->_backend->getAdapter();
 500             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($db);
 501
 502             $sendNotifications = $this->sendNotifications(FALSE);
 503
 504             $event = $this->get($_record->getId());
 505             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 506                     .' Going to update the following event. rawdata: ' . print_r($event->toArray(), true));
 507
 508             //NOTE we check via get(full rights) here whereas _updateACLCheck later checks limited rights from search
 509             if ($this->_doContainerACLChecks === FALSE || $event->hasGrant(Tinebase_Model_Grants::GRANT_EDIT)) {
 510                 Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__ . " updating event: {$_record->id} (range: {$range})");
 511
 512                 // we need to resolve groupmembers before free/busy checking
 513                 Calendar_Model_Attender::resolveGroupMembers($_record->attendee);
 514                 $this->_inspectEvent($_record);
 515
 516                 if ($_checkBusyConflicts) {
 517                     if ($event->isRescheduled($_record) ||
 518                            count(array_diff($_record->attendee->user_id, $event->attendee->user_id)) > 0
 519                        ) {
 520                         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 521                             . " Ensure that all attendee are free with free/busy check ... ");
 522                         $this->checkBusyConflicts($_record);
 523                     } else {
 524                         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 525                             . " Skipping free/busy check because event has not been rescheduled and no new attender has been added");
 526                     }
 527                 }
 528
 529                 parent::update($_record);
 530
 531             } else if ($_record->attendee instanceof Tinebase_Record_RecordSet) {
 532                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 533                     . " user has no editGrant for event: {$_record->id}, updating attendee status with valid authKey only");
 534                 foreach ($_record->attendee as $attender) {
 535                     if ($attender->status_authkey) {
 536                         $this->attenderStatusUpdate($_record, $attender, $attender->status_authkey);
 537                     }
 538                 }
 539             }
 540
 541             if ($_record->isRecurException() && in_array($range, array(Calendar_Model_Event::RANGE_ALL, Calendar_Model_Event::RANGE_THISANDFUTURE))) {
 542                 $this->_updateExdateRange($_record, $range, $event);
 543             }
 544
 545             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
 546         } catch (Exception $e) {
 547             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' Rolling back because: ' . $e);
 548             Tinebase_TransactionManager::getInstance()->rollBack();
 549             $this->sendNotifications($sendNotifications);
 550             throw $e;
 551         }
 552
 553         $updatedEvent = $this->get($event->getId());
 554
 555         // send notifications
 556         $this->sendNotifications($sendNotifications);
 557         if ($this->_sendNotifications && $_record->mute != 1) {
 558             $this->doSendNotifications($updatedEvent, Tinebase_Core::getUser(), 'changed', $event);
 559         }
 560         return $updatedEvent;
 561     }
 562
 563     /**
 564      * inspect update of one record (after update)
 565      *
 566      * @param   Tinebase_Record_Interface $updatedRecord   the just updated record
 567      * @param   Tinebase_Record_Interface $record          the update record
 568      * @param   Tinebase_Record_Interface $currentRecord   the current record (before update)
 569      * @return  void
 570      */
 571     protected function _inspectAfterUpdate($updatedRecord, $record, $currentRecord)
 572     {
 573         $this->_saveAttendee($record, $currentRecord, $record->isRescheduled($currentRecord));
 574         // need to save new attendee set in $updatedRecord for modlog
 575         $updatedRecord->attendee = clone($record->attendee);
 576     }
 577
 578     /**
 579      * update range of events starting with given recur exception
 580      *
 581      * @param Calendar_Model_Event $exdate
 582      * @param string $range
 583      */
 584     protected function _updateExdateRange($exdate, $range, $oldExdate)
 585     {
 586         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 587             . ' Updating events (range: ' . $range . ') belonging to recur exception event ' . $exdate->getId());
 588
 589         $baseEvent = $this->getRecurBaseEvent($exdate);
 590         $diff = $oldExdate->diff($exdate);
 591
 592         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 593             . ' Exdate diff: ' . print_r($diff->toArray(), TRUE));
 594
 595         if ($range === Calendar_Model_Event::RANGE_ALL) {
 596             $events = $this->getRecurExceptions($baseEvent);
 597             $events->addRecord($baseEvent);
 598             $this->_applyExdateDiffToRecordSet($exdate, $diff, $events);
 599         } else if ($range === Calendar_Model_Event::RANGE_THISANDFUTURE) {
 600             $nextRegularRecurEvent = Calendar_Model_Rrule::computeNextOccurrence($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $exdate->dtstart);
 601
 602             if ($nextRegularRecurEvent == $baseEvent) {
 603                 // NOTE if a fist instance exception takes place before the
 604                 //      series would start normally, $nextOccurence is the
 605                 //      baseEvent of the series. As createRecurException can't
 606                 //      deal with this situation we update whole series here
 607                 $this->_updateExdateRange($exdate, Calendar_Model_Event::RANGE_ALL, $oldExdate);
 608             } else if ($nextRegularRecurEvent !== NULL && ! $nextRegularRecurEvent->dtstart->isEarlier($exdate->dtstart)) {
 609                 $this->_applyDiff($nextRegularRecurEvent, $diff, $exdate, FALSE);
 610
 611                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 612                     . ' Next recur exception event at: ' . $nextRegularRecurEvent->dtstart->toString());
 613                 if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 614                     . ' ' . print_r($nextRegularRecurEvent->toArray(), TRUE));
 615
 616                 $nextRegularRecurEvent->mute = $exdate->mute;
 617                 $newBaseEvent = $this->createRecurException($nextRegularRecurEvent, FALSE, TRUE);
 618                 // @todo this should be done by createRecurException
 619                 $exdatesOfNewBaseEvent = $this->getRecurExceptions($newBaseEvent);
 620                 $this->_applyExdateDiffToRecordSet($exdate, $diff, $exdatesOfNewBaseEvent);
 621             } else {
 622                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 623                     . ' No upcoming occurrences found.');
 624             }
 625         }
 626     }
 627
 628     /**
 629      * apply exdate diff to a recordset of events
 630      *
 631      * @param Calendar_Model_Event $exdate
 632      * @param Tinebase_Record_Diff $diff
 633      * @param Tinebase_Record_RecordSet $events
 634      */
 635     protected function _applyExdateDiffToRecordSet($exdate, $diff, $events)
 636     {
 637         // make sure baseEvent gets updated first to circumvent concurrency conflicts
 638         $events->sort('recurdid', 'ASC');
 639
 640         foreach ($events as $event) {
 641             if ($event->getId() === $exdate->getId()) {
 642                 // skip the exdate
 643                 continue;
 644             }
 645             $this->_applyDiff($event, $diff, $exdate, FALSE);
 646             $this->update($event);
 647         }
 648     }
 649
 650     /**
 651      * merge updates from exdate into event
 652      *
 653      * @param Calendar_Model_Event $event
 654      * @param Tinebase_Record_Diff $diff
 655      * @param Calendar_Model_Event $exdate
 656      * @param boolean $overwriteMods
 657      *
 658      * @todo is $overwriteMods needed?
 659      */
 660     protected function _applyDiff($event, $diff, $exdate, $overwriteMods = TRUE)
 661     {
 662         if (! $overwriteMods) {
 663             $recentChanges = Tinebase_Timemachine_ModificationLog::getInstance()->getModifications('Calendar', $event, NULL, 'Sql', $exdate->creation_time);
 664             if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 665                 . ' Recent changes (since ' . $exdate->creation_time->toString() . '): ' . print_r($recentChanges->toArray(), TRUE));
 666         } else {
 667             $recentChanges = new Tinebase_Record_RecordSet('Tinebase_Model_ModificationLog');
 668         }
 669
 670         $diffIgnore = array('organizer', 'seq', 'last_modified_by', 'last_modified_time', 'dtstart', 'dtend');
 671         foreach ($diff->diff as $key => $newValue) {
 672             if ($key === 'attendee') {
 673                 if (in_array($key, $recentChanges->modified_attribute)) {
 674                     $attendeeDiff = $diff->diff['attendee'];
 675                     if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 676                         . ' Attendee diff: ' . print_r($attendeeDiff->toArray(), TRUE));
 677                     foreach ($attendeeDiff['added'] as $attenderToAdd) {
 678                         $attenderToAdd->setId(NULL);
 679                         $event->attendee->addRecord($attenderToAdd);
 680                     }
 681                     foreach ($attendeeDiff['removed'] as $attenderToRemove) {
 682                         $attenderInCurrentSet = Calendar_Model_Attender::getAttendee($event->attendee, $attenderToRemove);
 683                         if ($attenderInCurrentSet) {
 684                             $event->attendee->removeRecord($attenderInCurrentSet);
 685                         }
 686                     }
 687                 } else {
 688                     // remove ids of new attendee
 689                     $attendee = clone($exdate->attendee);
 690                     foreach ($attendee as $attender) {
 691                         if (! $event->attendee->getById($attender->getId())) {
 692                             $attender->setId(NULL);
 693                         }
 694                     }
 695                     $event->attendee = $attendee;
 696                 }
 697             } else if (! in_array($key, $diffIgnore) && ! in_array($key, $recentChanges->modified_attribute)) {
 698                 $event->{$key} = $exdate->{$key};
 699             } else {
 700                 if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 701                     . ' Ignore / recently changed: ' . $key);
 702             }
 703         }
 704
 705         if ((isset($diff->diff['dtstart']) || array_key_exists('dtstart', $diff->diff)) || (isset($diff->diff['dtend']) || array_key_exists('dtend', $diff->diff))) {
 706             $this->_applyTimeDiff($event, $exdate);
 707         }
 708     }
 709
 710     /**
 711      * update multiple records
 712      *
 713      * @param   Tinebase_Model_Filter_FilterGroup $_filter
 714      * @param   array $_data
 715      * @return  integer number of updated records
 716      */
 717     public function updateMultiple($_filter, $_data)
 718     {
 719         $this->_checkRight('update');
 720         $this->checkFilterACL($_filter, 'update');
 721
 722         // get only ids
 723         $ids = $this->_backend->search($_filter, NULL, TRUE);
 724
 725         foreach ($ids as $eventId) {
 726             $event = $this->get($eventId);
 727             foreach ($_data as $field => $value) {
 728                 $event->$field = $value;
 729             }
 730
 731             $this->update($event);
 732         }
 733
 734         return count($ids);
 735     }
 736
 737     /**
 738      * Deletes a set of records.
 739      *
 740      * If one of the records could not be deleted, no record is deleted
 741      *
 742      * @param   array $_ids array of record identifiers
 743      * @param   string $range
 744      * @return  NULL
 745      * @throws Tinebase_Exception_NotFound|Tinebase_Exception
 746      */
 747     public function delete($_ids, $range = Calendar_Model_Event::RANGE_THIS)
 748     {
 749         if ($_ids instanceof $this->_modelName) {
 750             $_ids = (array)$_ids->getId();
 751         }
 752
 753         $records = $this->_backend->getMultiple((array) $_ids);
 754
 755         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 756             . " Deleting " . count($records) . ' with range ' . $range . ' ...');
 757
 758         foreach ($records as $record) {
 759             if ($record->isRecurException() && in_array($range, array(Calendar_Model_Event::RANGE_ALL, Calendar_Model_Event::RANGE_THISANDFUTURE))) {
 760                 $this->_deleteExdateRange($record, $range);
 761             }
 762
 763             try {
 764                 $db = $this->_backend->getAdapter();
 765                 $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($db);
 766
 767                 // delete if delete grant is present
 768                 if ($this->_doContainerACLChecks === FALSE || $record->hasGrant(Tinebase_Model_Grants::GRANT_DELETE)) {
 769                     // NOTE delete needs to update sequence otherwise iTIP based protocolls ignore the delete
 770                     $record->status = Calendar_Model_Event::STATUS_CANCELED;
 771                     $this->_touch($record);
 772                     if ($record->isRecurException()) {
 773                         try {
 774                             $baseEvent = $this->getRecurBaseEvent($record);
 775                             $this->_touch($baseEvent);
 776                         } catch (Tinebase_Exception_NotFound $tnfe) {
 777                             // base Event might be gone already
 778                             if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
 779                                 . " BaseEvent of exdate {$record->uid} to delete not found ");
 780
 781                         }
 782                     }
 783                     parent::delete($record);
 784                 }
 785
 786                 // otherwise update status for user to DECLINED
 787                 else if ($record->attendee instanceof Tinebase_Record_RecordSet) {
 788                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " user has no deleteGrant for event: " . $record->id . ", updating own status to DECLINED only");
 789                     $ownContact = Tinebase_Core::getUser()->contact_id;
 790                     foreach ($record->attendee as $attender) {
 791                         if ($attender->user_id == $ownContact && in_array($attender->user_type, array(Calendar_Model_Attender::USERTYPE_USER, Calendar_Model_Attender::USERTYPE_GROUPMEMBER))) {
 792                             $attender->status = Calendar_Model_Attender::STATUS_DECLINED;
 793                             $this->attenderStatusUpdate($record, $attender, $attender->status_authkey);
 794                         }
 795                     }
 796                 }
 797
 798                 // increase display container content sequence for all attendee of deleted event
 799                 if ($record->attendee instanceof Tinebase_Record_RecordSet) {
 800                     foreach ($record->attendee as $attender) {
 801                         $this->_increaseDisplayContainerContentSequence($attender, $record, Tinebase_Model_ContainerContent::ACTION_DELETE);
 802                     }
 803                 }
 804
 805                 Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
 806             } catch (Exception $e) {
 807                 Tinebase_TransactionManager::getInstance()->rollBack();
 808                 throw $e;
 809             }
 810         }
 811     }
 812
 813     /**
 814      * delete range of events starting with given recur exception
 815      *
 816      * NOTE: if exdate is persistent, it will not be deleted by this function
 817      *       but by the original call of delete
 818      *
 819      * @param Calendar_Model_Event $exdate
 820      * @param string $range
 821      */
 822     protected function _deleteExdateRange($exdate, $range)
 823     {
 824         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 825             . ' Deleting events (range: ' . $range . ') belonging to recur exception event ' . $exdate->getId());
 826
 827         $baseEvent = $this->getRecurBaseEvent($exdate);
 828
 829         if ($range === Calendar_Model_Event::RANGE_ALL) {
 830             $this->deleteRecurSeries($exdate);
 831         } else if ($range === Calendar_Model_Event::RANGE_THISANDFUTURE) {
 832             $nextRegularRecurEvent = Calendar_Model_Rrule::computeNextOccurrence($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $exdate->dtstart);
 833
 834             if ($nextRegularRecurEvent == $baseEvent) {
 835                 // NOTE if a fist instance exception takes place before the
 836                 //      series would start normally, $nextOccurence is the
 837                 //      baseEvent of the series. As createRecurException can't
 838                 //      deal with this situation we delete whole series here
 839                 $this->_deleteExdateRange($exdate, Calendar_Model_Event::RANGE_ALL);
 840             } else {
 841                 $this->createRecurException($nextRegularRecurEvent, TRUE, TRUE);
 842             }
 843         }
 844     }
 845
 846     /**
 847      * updates a recur series
 848      *
 849      * @param  Calendar_Model_Event $_recurInstance
 850      * @param  bool                 $_checkBusyConflicts
 851      * @return Calendar_Model_Event
 852      */
 853     public function updateRecurSeries($_recurInstance, $_checkBusyConflicts = FALSE)
 854     {
 855         $baseEvent = $this->getRecurBaseEvent($_recurInstance);
 856
 857         // replace baseEvent with adopted instance
 858         $newBaseEvent = clone $_recurInstance;
 859         $newBaseEvent->setId($baseEvent->getId());
 860         unset($newBaseEvent->recurid);
 861         $newBaseEvent->exdate = $baseEvent->exdate;
 862
 863         $this->_applyTimeDiff($newBaseEvent, $_recurInstance, $baseEvent);
 864
 865         return $this->update($newBaseEvent, $_checkBusyConflicts);
 866     }
 867
 868     /**
 869      * apply time diff
 870      *
 871      * @param Calendar_Model_Event $newEvent
 872      * @param Calendar_Model_Event $fromEvent
 873      * @param Calendar_Model_Event $baseEvent
 874      */
 875     protected function _applyTimeDiff($newEvent, $fromEvent, $baseEvent = NULL)
 876     {
 877         if (! $baseEvent) {
 878             $baseEvent = $newEvent;
 879         }
 880
 881         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 882             . ' New event: ' . print_r($newEvent->toArray(), TRUE));
 883         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 884             . ' From event: ' . print_r($fromEvent->toArray(), TRUE));
 885
 886         // compute time diff (NOTE: if the $fromEvent is the baseEvent, it has no recurid)
 887         $originalDtStart = $fromEvent->recurid ? new Tinebase_DateTime(substr($fromEvent->recurid, -19), 'UTC') : clone $baseEvent->dtstart;
 888
 889         $dtstartDiff = $originalDtStart->diff($fromEvent->dtstart);
 890         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 891             . " Dtstart diff: " . $dtstartDiff->format('%H:%M:%i'));
 892         $eventDuration = $fromEvent->dtstart->diff($fromEvent->dtend);
 893         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 894             . " Duration diff: " . $dtstartDiff->format('%H:%M:%i'));
 895
 896         $newEvent->dtstart = clone $baseEvent->dtstart;
 897         $newEvent->dtstart->add($dtstartDiff);
 898
 899         $newEvent->dtend = clone $newEvent->dtstart;
 900         $newEvent->dtend->add($eventDuration);
 901     }
 902
 903     /**
 904      * creates an exception instance of a recurring event
 905      *
 906      * NOTE: deleting persistent exceptions is done via a normal delete action
 907      *       and handled in the deleteInspection
 908      *
 909      * @param  Calendar_Model_Event  $_event
 910      * @param  bool                  $_deleteInstance
 911      * @param  bool                  $_allFollowing
 912      * @param  bool                  $_checkBusyConflicts
 913      * @return Calendar_Model_Event  exception Event | updated baseEvent
 914      *
 915      * @todo replace $_allFollowing param with $range
 916      * @deprecated replace with create/update/delete
 917      */
 918     public function createRecurException($_event, $_deleteInstance = FALSE, $_allFollowing = FALSE, $_checkBusyConflicts = FALSE)
 919     {
 920         $baseEvent = $this->getRecurBaseEvent($_event);
 921
 922         if ($baseEvent->last_modified_time != $_event->last_modified_time) {
 923             if (Tinebase_Core::isLogLevel(Zend_Log::WARN)) Tinebase_Core::getLogger()->warn(__METHOD__ . '::' . __LINE__
 924                 . " It is not allowed to create recur instance if it is clone of base event");
 925             throw new Tinebase_Timemachine_Exception_ConcurrencyConflict('concurrency conflict!');
 926         }
 927
 928 //        // Maybe Later
 929 //        // exdates needs to stay in baseEvents container
 930 //        if ($_event->container_id != $baseEvent->container_id) {
 931 //            throw new Calendar_Exception_ExdateContainer();
 932 //        }
 933
 934         // check if this is an exception to the first occurence
 935         if ($baseEvent->getId() == $_event->getId()) {
 936             if ($_allFollowing) {
 937                 throw new Exception('please edit or delete complete series!');
 938             }
 939             // NOTE: if the baseEvent gets a time change, we can't compute the recurdid w.o. knowing the original dtstart
 940             $recurid = $baseEvent->setRecurId($baseEvent->getId());
 941             unset($baseEvent->recurid);
 942             $_event->recurid = $recurid;
 943         }
 944
 945         // just do attender status update if user has no edit grant
 946         if ($this->_doContainerACLChecks && !$baseEvent->{Tinebase_Model_Grants::GRANT_EDIT}) {
 947             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 948                 . " user has no editGrant for event: '{$baseEvent->getId()}'. Only creating exception for attendee status");
 949             if ($_event->attendee instanceof Tinebase_Record_RecordSet) {
 950                 foreach ($_event->attendee as $attender) {
 951                     if ($attender->status_authkey) {
 952                         $exceptionAttender = $this->attenderStatusCreateRecurException($_event, $attender, $attender->status_authkey, $_allFollowing);
 953                     }
 954                 }
 955             }
 956
 957             if (! isset($exceptionAttender)) {
 958                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG) && $_event->attendee instanceof Tinebase_Record_RecordSet) {
 959                     Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " Failed to update attendee: " . print_r($_event->attendee->toArray(), true));
 960                 }
 961                 throw new Tinebase_Exception_AccessDenied('Failed to update attendee, status authkey might be missing');
 962             }
 963
 964             return $this->get($exceptionAttender->cal_event_id);
 965         }
 966
 967         // NOTE: recurid is computed by rrule recur computations and therefore is already part of the event.
 968         if (empty($_event->recurid)) {
 969             throw new Exception('recurid must be present to create exceptions!');
 970         }
 971
 972         // we do notifications ourself
 973         $sendNotifications = $this->sendNotifications(FALSE);
 974
 975         // EDIT for baseEvent is checked above, CREATE, DELETE for recur exceptions is implied with it
 976         $doContainerACLChecks = $this->doContainerACLChecks(FALSE);
 977
 978         $db = $this->_backend->getAdapter();
 979         $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($db);
 980
 981         $exdate = new Tinebase_DateTime(substr($_event->recurid, -19));
 982         $exdates = is_array($baseEvent->exdate) ? $baseEvent->exdate : array();
 983         $originalDtstart = $_event->getOriginalDtStart();
 984         $originalEvent = Calendar_Model_Rrule::computeNextOccurrence($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $originalDtstart);
 985
 986         if ($_allFollowing != TRUE) {
 987             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 988                 . " Adding exdate for: '{$_event->recurid}'");
 989
 990             array_push($exdates, $exdate);
 991             $baseEvent->exdate = $exdates;
 992             $updatedBaseEvent = $this->update($baseEvent, FALSE);
 993
 994             if ($_deleteInstance == FALSE) {
 995                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
 996                     . " Creating persistent exception for: '{$_event->recurid}'");
 997                 if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
 998                     . " Recur exception: " . print_r($_event->toArray(), TRUE));
 999
1000                 $_event->base_event_id = $baseEvent->getId();
1001                 $_event->setId(NULL);
1002                 unset($_event->rrule);
1003                 unset($_event->exdate);
1004
1005                 foreach (array('attendee', 'notes', 'alarms') as $prop) {
1006                     if ($_event->{$prop} instanceof Tinebase_Record_RecordSet) {
1007                         $_event->{$prop}->setId(NULL);
1008                     }
1009                 }
1010
1011                 $originalDtstart = $_event->getOriginalDtStart();
1012                 $dtStartHasDiff = $originalDtstart->compare($_event->dtstart) != 0; // php52 compat
1013
1014                 if (! $dtStartHasDiff) {
1015                     $attendees = $_event->attendee;
1016                     unset($_event->attendee);
1017                 }
1018                 $note = $_event->notes;
1019                 unset($_event->notes);
1020                 $persistentExceptionEvent = $this->create($_event, $_checkBusyConflicts);
1021
1022                 if (! $dtStartHasDiff) {
1023                     // we save attendee seperatly to preserve their attributes
1024                     if ($attendees instanceof Tinebase_Record_RecordSet) {
1025                         $attendees->cal_event_id = $persistentExceptionEvent->getId();
1026                         $calendar = Tinebase_Container::getInstance()->getContainerById($_event->container_id);
1027                         foreach ($attendees as $attendee) {
1028                             $this->_createAttender($attendee, $_event, TRUE, $calendar);
1029                             $this->_increaseDisplayContainerContentSequence($attendee, $persistentExceptionEvent, Tinebase_Model_ContainerContent::ACTION_CREATE);
1030                         }
1031                     }
1032                 }
1033
1034                 // @todo save notes and add a update note -> what was updated? -> modlog is also missing
1035                 $persistentExceptionEvent = $this->get($persistentExceptionEvent->getId());
1036             }
1037
1038         } else {
1039             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " shorten recur series for/to: '{$_event->recurid}'");
1040
1041             // split past/future exceptions
1042             $pastExdates = array();
1043             $futureExdates = array();
1044             foreach($exdates as $exdate) {
1045                 $exdate->isLater($_event->dtstart) ? $futureExdates[] = $exdate : $pastExdates[] = $exdate;
1046             }
1047
1048             $persistentExceptionEvents = $this->getRecurExceptions($_event);
1049             $pastPersistentExceptionEvents = new Tinebase_Record_RecordSet('Calendar_Model_Event');
1050             $futurePersistentExceptionEvents = new Tinebase_Record_RecordSet('Calendar_Model_Event');
1051             foreach ($persistentExceptionEvents as $persistentExceptionEvent) {
1052                 $persistentExceptionEvent->dtstart->isLater($_event->dtstart) ? $futurePersistentExceptionEvents->addRecord($persistentExceptionEvent) : $pastPersistentExceptionEvents->addRecord($persistentExceptionEvent);
1053             }
1054
1055             // update baseEvent
1056             $rrule = Calendar_Model_Rrule::getRruleFromString($baseEvent->rrule);
1057             if (isset($rrule->count)) {
1058                 // get all occurences and find the split
1059
1060                 $exdate = $baseEvent->exdate;
1061                 $baseEvent->exdate = NULL;
1062                     //$baseCountOccurrence = Calendar_Model_Rrule::computeNextOccurrence($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $baseEvent->rrule_until, $baseCount);
1063                 $recurSet = Calendar_Model_Rrule::computeRecurrenceSet($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $baseEvent->dtstart, $baseEvent->rrule_until);
1064                 $baseEvent->exdate = $exdate;
1065
1066                 $originalDtstart = $_event->getOriginalDtStart();
1067                 foreach($recurSet as $idx => $rInstance) {
1068                     if ($rInstance->dtstart >= $originalDtstart) break;
1069                 }
1070
1071                 $rrule->count = $idx+1;
1072             } else {
1073                 $lastBaseOccurence = Calendar_Model_Rrule::computeNextOccurrence($baseEvent, new Tinebase_Record_RecordSet('Calendar_Model_Event'), $_event->getOriginalDtStart()->subSecond(1), -1);
1074                 $rrule->until = $lastBaseOccurence ? $lastBaseOccurence->getOriginalDtStart() : $baseEvent->dtstart;
1075             }
1076             $baseEvent->rrule = (string) $rrule;
1077             $baseEvent->exdate = $pastExdates;
1078
1079             // NOTE: we don't want implicit attendee updates
1080             //$updatedBaseEvent = $this->update($baseEvent, FALSE);
1081             $this->_inspectEvent($baseEvent);
1082             $updatedBaseEvent = parent::update($baseEvent);
1083
1084             if ($_deleteInstance == TRUE) {
1085                 // delete all future persistent events
1086                 $this->delete($futurePersistentExceptionEvents->getId());
1087             } else {
1088                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " create new recur series for/at: '{$_event->recurid}'");
1089
1090                 // NOTE: in order to move exceptions correctly in time we need to find out the original dtstart
1091                 //       and create the new baseEvent with this time. A following update also updates its exceptions
1092                 $originalDtstart = new Tinebase_DateTime(substr($_event->recurid, -19));
1093                 $adoptedDtstart = clone $_event->dtstart;
1094                 $dtStartHasDiff = $adoptedDtstart->compare($originalDtstart) != 0; // php52 compat
1095                 $eventLength = $_event->dtstart->diff($_event->dtend);
1096
1097                 $_event->dtstart = clone $originalDtstart;
1098                 $_event->dtend = clone $originalDtstart;
1099                 $_event->dtend->add($eventLength);
1100
1101                 // adopt count
1102                 if (isset($rrule->count)) {
1103                     $baseCount = $rrule->count;
1104                     $rrule = Calendar_Model_Rrule::getRruleFromString($_event->rrule);
1105                     $rrule->count = $rrule->count - $baseCount;
1106                     $_event->rrule = (string) $rrule;
1107                 }
1108
1109                 $_event->setId(Tinebase_Record_Abstract::generateUID());
1110                 $_event->uid = $futurePersistentExceptionEvents->uid = Tinebase_Record_Abstract::generateUID();
1111                 $_event->setId(Tinebase_Record_Abstract::generateUID());
1112                 $futurePersistentExceptionEvents->setRecurId($_event->getId());
1113                 unset($_event->recurid);
1114                 unset($_event->base_event_id);
1115                 foreach(array('attendee', 'notes', 'alarms') as $prop) {
1116                     if ($_event->{$prop} instanceof Tinebase_Record_RecordSet) {
1117                         $_event->{$prop}->setId(NULL);
1118                     }
1119                 }
1120                 $_event->exdate = $futureExdates;
1121
1122                 $attendees = $_event->attendee; unset($_event->attendee);
1123                 $note = $_event->notes; unset($_event->notes);
1124                 $persistentExceptionEvent = $this->create($_event, $_checkBusyConflicts && $dtStartHasDiff);
1125
1126                 // we save attendee separately to preserve their attributes
1127                 if ($attendees instanceof Tinebase_Record_RecordSet) {
1128                     foreach($attendees as $attendee) {
1129                         $this->_createAttender($attendee, $persistentExceptionEvent, true);
1130                     }
1131                 }
1132
1133                 // @todo save notes and add a update note -> what was updated? -> modlog is also missing
1134
1135                 $persistentExceptionEvent = $this->get($persistentExceptionEvent->getId());
1136
1137                 foreach($futurePersistentExceptionEvents as $futurePersistentExceptionEvent) {
1138                     $this->update($futurePersistentExceptionEvent, FALSE);
1139                 }
1140
1141                 if ($dtStartHasDiff) {
1142                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " new recur series has adpted dtstart -> update to adopt exceptions'");
1143                     $persistentExceptionEvent->dtstart = clone $adoptedDtstart;
1144                     $persistentExceptionEvent->dtend = clone $adoptedDtstart;
1145                     $persistentExceptionEvent->dtend->add($eventLength);
1146
1147                     $persistentExceptionEvent = $this->update($persistentExceptionEvent, $_checkBusyConflicts);
1148                 }
1149             }
1150         }
1151
1152         Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1153
1154         // restore original notification handling
1155         $this->sendNotifications($sendNotifications);
1156         $notificationAction = $_deleteInstance ? 'deleted' : 'changed';
1157         $notificationEvent = $_deleteInstance ? $_event : $persistentExceptionEvent;
1158
1159         // restore acl
1160         $this->doContainerACLChecks($doContainerACLChecks);
1161
1162         // send notifications
1163         if ($this->_sendNotifications && $_event->mute != 1) {
1164             // NOTE: recur exception is a fake event from client.
1165             //       this might lead to problems, so we wrap the calls
1166             try {
1167                 if (count($_event->attendee) > 0) {
1168                     $_event->attendee->bypassFilters = TRUE;
1169                 }
1170                 $_event->created_by = $baseEvent->created_by;
1171
1172                 $this->doSendNotifications($notificationEvent, Tinebase_Core::getUser(), $notificationAction, $originalEvent);
1173             } catch (Exception $e) {
1174                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " " . $e->getTraceAsString());
1175                 Tinebase_Core::getLogger()->warn(__METHOD__ . '::' . __LINE__ . " could not send notification {$e->getMessage()}");
1176             }
1177         }
1178
1179         return $_deleteInstance ? $updatedBaseEvent : $persistentExceptionEvent;
1180     }
1181
1182     /**
1183      * (non-PHPdoc)
1184      * @see Tinebase_Controller_Record_Abstract::get()
1185      */
1186     public function get($_id, $_containerId = NULL, $_getRelatedData = TRUE)
1187     {
1188         if (preg_match('/^fakeid/', $_id)) {
1189             // get base event when trying to fetch a non-persistent recur instance
1190             return $this->getRecurBaseEvent(new Calendar_Model_Event(array('uid' => substr(str_replace('fakeid', '', $_id), 0, 40))), TRUE);
1191         } else {
1192             return parent::get($_id, $_containerId, $_getRelatedData);
1193         }
1194     }
1195
1196     /**
1197      * returns base event of a recurring series
1198      *
1199      * @param  Calendar_Model_Event $_event
1200      * @return Calendar_Model_Event
1201      */
1202     public function getRecurBaseEvent($_event)
1203     {
1204         $baseEventId = $_event->base_event_id ?: $_event->id;
1205
1206         if (! $baseEventId) {
1207             throw new Tinebase_Exception_NotFound('base event of a recurring series not found');
1208         }
1209
1210         // make sure we have a 'fully featured' event
1211         return $this->get($baseEventId);
1212     }
1213
1214     /**
1215      * returns all persistent recur exceptions of recur series identified by uid of given event
1216      *
1217      * NOTE: deleted instances are saved in the base events exception property
1218      * NOTE: returns all exceptions regardless of current filters and access restrictions
1219      *
1220      * @param  Calendar_Model_Event        $_event
1221      * @param  boolean                     $_fakeDeletedInstances
1222      * @param  Calendar_Model_EventFilter  $_eventFilter
1223      * @return Tinebase_Record_RecordSet of Calendar_Model_Event
1224      */
1225     public function getRecurExceptions($_event, $_fakeDeletedInstances = FALSE, $_eventFilter = NULL)
1226     {
1227         $baseEventId = $_event->base_event_id ?: $_event->id;
1228
1229         $exceptionFilter = new Calendar_Model_EventFilter(array(
1230             array('field' => 'base_event_id', 'operator' => 'equals',  'value' => $baseEventId),
1231         ));
1232
1233         if ($_eventFilter instanceof Calendar_Model_EventFilter) {
1234             $exceptionFilter->addFilterGroup($_eventFilter);
1235         }
1236
1237         $exceptions = $this->_backend->search($exceptionFilter);
1238
1239         if ($_fakeDeletedInstances) {
1240             $baseEvent = $this->getRecurBaseEvent($_event);
1241             $this->fakeDeletedExceptions($baseEvent, $exceptions);
1242         }
1243
1244         $exceptions->exdate = NULL;
1245         $exceptions->rrule = NULL;
1246         $exceptions->rrule_until = NULL;
1247
1248         return $exceptions;
1249     }
1250
1251     /**
1252      * add exceptions events for deleted instances
1253      *
1254      * @param Calendar_Model_Event $baseEvent
1255      * @param Tinebase_Record_RecordSet $exceptions
1256      */
1257     public function fakeDeletedExceptions($baseEvent, $exceptions)
1258     {
1259         $eventLength = $baseEvent->dtstart->diff($baseEvent->dtend);
1260
1261         // compute remaining exdates
1262         $deletedInstanceDtStarts = array_diff(array_unique((array) $baseEvent->exdate), $exceptions->getOriginalDtStart());
1263
1264         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ .
1265             ' Faking ' . count($deletedInstanceDtStarts) . ' deleted exceptions');
1266
1267         foreach((array) $deletedInstanceDtStarts as $deletedInstanceDtStart) {
1268             $fakeEvent = clone $baseEvent;
1269             $fakeEvent->setId(NULL);
1270
1271             $fakeEvent->dtstart = clone $deletedInstanceDtStart;
1272             $fakeEvent->dtend = clone $deletedInstanceDtStart;
1273             $fakeEvent->dtend->add($eventLength);
1274             $fakeEvent->is_deleted = TRUE;
1275             $fakeEvent->setRecurId($baseEvent->getId());
1276             $fakeEvent->rrule = null;
1277
1278             $exceptions->addRecord($fakeEvent);
1279         }
1280     }
1281
1282    /**
1283     * adopt alarm time to next occurrence for recurring events
1284     *
1285     * @param Tinebase_Record_Abstract $_record
1286     * @param Tinebase_Model_Alarm $_alarm
1287     * @param bool $_nextBy {instance|time} set recurr alarm to next from given instance or next by current time
1288     * @return void
1289     */
1290     public function adoptAlarmTime(Tinebase_Record_Abstract $_record, Tinebase_Model_Alarm $_alarm, $_nextBy = 'time')
1291     {
1292         if ($_record->rrule) {
1293             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ .
1294                  ' Adopting alarm time for next recur occurrence (by ' . $_nextBy . ')');
1295             if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ .
1296                  ' ' . print_r($_record->toArray(), TRUE));
1297
1298             if ($_nextBy == 'time') {
1299                 // NOTE: this also finds instances running right now
1300                 $from = Tinebase_DateTime::now();
1301
1302             } else {
1303                 $recurid = $_alarm->getOption('recurid');
1304                 $instanceStart = $recurid ? new Tinebase_DateTime(substr($recurid, -19)) : clone $_record->dtstart;
1305                 $eventLength = $_record->dtstart->diff($_record->dtend);
1306
1307                 $instanceStart->setTimezone($_record->originator_tz);
1308                 $from = $instanceStart->add($eventLength);
1309                 $from->setTimezone('UTC');
1310             }
1311
1312             // compute next
1313             $exceptions = $this->getRecurExceptions($_record);
1314             $nextOccurrence = Calendar_Model_Rrule::computeNextOccurrence($_record, $exceptions, $from);
1315
1316             if ($nextOccurrence === NULL) {
1317                 if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__ .
1318                     ' Recur series is over, no more alarms pending');
1319             } else {
1320                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ .
1321                     ' Found next occurrence, adopting alarm to dtstart ' . $nextOccurrence->dtstart->toString());
1322             }
1323
1324             // save recurid so we know for which recurrance the alarm is for
1325             $_alarm->setOption('recurid', isset($nextOccurrence) ? $nextOccurrence->recurid : NULL);
1326
1327             $_alarm->sent_status = $nextOccurrence ? Tinebase_Model_Alarm::STATUS_PENDING : Tinebase_Model_Alarm::STATUS_SUCCESS;
1328             $_alarm->sent_message = $nextOccurrence ?  '' : 'Nothing to send, series is over';
1329
1330             $eventStart = $nextOccurrence ? clone $nextOccurrence->dtstart : clone $_record->dtstart;
1331         } else {
1332             $eventStart = clone $_record->dtstart;
1333         }
1334
1335         // save minutes before / compute it for custom alarms
1336         $minutesBefore = $_alarm->minutes_before == Tinebase_Model_Alarm::OPTION_CUSTOM
1337             ? ($_record->dtstart->getTimestamp() - $_alarm->alarm_time->getTimestamp()) / 60
1338             : $_alarm->minutes_before;
1339         $minutesBefore = round($minutesBefore);
1340
1341         $_alarm->setOption('minutes_before', $minutesBefore);
1342         $_alarm->alarm_time = $eventStart->subMinute($minutesBefore);
1343
1344         if ($_record->rrule && $_alarm->sent_status == Tinebase_Model_Alarm::STATUS_PENDING && $_alarm->alarm_time < $_alarm->sent_time) {
1345             $this->adoptAlarmTime($_record, $_alarm, 'instance');
1346         }
1347
1348         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ .
1349             ' alarm: ' . print_r($_alarm->toArray(), true));
1350     }
1351
1352     /****************************** overwritten functions ************************/
1353
1354     /**
1355      * restore original alarm time of recurring events
1356      *
1357      * @param Tinebase_Record_Abstract $_record
1358      * @return void
1359      */
1360     protected function _inspectAlarmGet(Tinebase_Record_Abstract $_record)
1361     {
1362         foreach ($_record->alarms as $alarm) {
1363             if ($recurid = $alarm->getOption('recurid')) {
1364                 $alarm->alarm_time = clone $_record->dtstart;
1365                 $alarm->alarm_time->subMinute((int) $alarm->getOption('minutes_before'));
1366             }
1367         }
1368
1369         parent::_inspectAlarmGet($_record);
1370     }
1371
1372     /**
1373      * adopt alarm time to next occurance for recurring events
1374      *
1375      * @param Tinebase_Record_Abstract $_record
1376      * @param Tinebase_Model_Alarm $_alarm
1377      * @param bool $_nextBy {instance|time} set recurr alarm to next from given instance or next by current time
1378      * @return void
1379      * @throws Tinebase_Exception_InvalidArgument
1380      */
1381     protected function _inspectAlarmSet(Tinebase_Record_Abstract $_record, Tinebase_Model_Alarm $_alarm, $_nextBy = 'time')
1382     {
1383         parent::_inspectAlarmSet($_record, $_alarm);
1384         $this->adoptAlarmTime($_record, $_alarm, 'time');
1385     }
1386
1387     /**
1388      * inspect update of one record
1389      *
1390      * @param   Tinebase_Record_Interface $_record      the update record
1391      * @param   Tinebase_Record_Interface $_oldRecord   the current persistent record
1392      * @return  void
1393      */
1394     protected function _inspectBeforeUpdate($_record, $_oldRecord)
1395     {
1396         // if dtstart of an event changes, we update the originator_tz, alarm times
1397         if (! $_oldRecord->dtstart->equals($_record->dtstart)) {
1398             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' dtstart changed -> adopting organizer_tz');
1399             $_record->originator_tz = Tinebase_Core::getUserTimezone();
1400             if (! empty($_record->rrule)) {
1401                 $diff = $_oldRecord->dtstart->diff($_record->dtstart);
1402                 $this->_updateRecurIdOfExdates($_record, $diff);
1403             }
1404         }
1405
1406         // delete recur exceptions if update is no longer a recur series
1407         if (! empty($_oldRecord->rrule) && empty($_record->rrule)) {
1408             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' deleting recur exceptions as event is no longer a recur series');
1409             $this->_backend->delete($this->getRecurExceptions($_record));
1410         }
1411
1412         // touch base event of a recur series if an persistent exception changes
1413         if ($_record->recurid) {
1414             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' touch base event of a persistent exception');
1415             $baseEvent = $this->getRecurBaseEvent($_record);
1416             $this->_touch($baseEvent, TRUE);
1417         }
1418     }
1419
1420     /**
1421      * update exdates and recurids if dtstart of an recurevent changes
1422      *
1423      * @param Calendar_Model_Event $_record
1424      * @param DateInterval $diff
1425      */
1426     protected function _updateRecurIdOfExdates($_record, $diff)
1427     {
1428         // update exceptions
1429         $exceptions = $this->getRecurExceptions($_record);
1430         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' dtstart of a series changed -> adopting '. count($exceptions) . ' recurid(s)');
1431         $exdates = array();
1432         foreach ($exceptions as $exception) {
1433             $exception->recurid = new Tinebase_DateTime(substr($exception->recurid, -19));
1434             Calendar_Model_Rrule::addUTCDateDstFix($exception->recurid, $diff, $_record->originator_tz);
1435             $exdates[] = $exception->recurid;
1436
1437             $exception->setRecurId($_record->getId());
1438             $this->_backend->update($exception);
1439         }
1440
1441         $_record->exdate = $exdates;
1442     }
1443
1444     /**
1445      * inspect before create/update
1446      *
1447      * @TODO move stuff from other places here
1448      * @param   Calendar_Model_Event $_record      the record to inspect
1449      */
1450     protected function _inspectEvent($_record)
1451     {
1452         $_record->uid = $_record->uid ? $_record->uid : Tinebase_Record_Abstract::generateUID();
1453         $_record->organizer = $_record->organizer ? $_record->organizer : Tinebase_Core::getUser()->contact_id;
1454         $_record->transp = $_record->transp ? $_record->transp : Calendar_Model_Event::TRANSP_OPAQUE;
1455
1456         $this->_inspectOriginatorTZ($_record);
1457
1458         if ($_record->hasExternalOrganizer()) {
1459             // assert calendarUser as attendee. This is important to keep the event in the loop via its displaycontianer(s)
1460             try {
1461                 $container = Tinebase_Container::getInstance()->getContainerById($_record->container_id);
1462                 $owner = $container->getOwner();
1463                 $calendarUserId = Addressbook_Controller_Contact::getInstance()->getContactByUserId($owner, true)->getId();
1464             } catch (Exception $e) {
1465                 $container = NULL;
1466                 $calendarUserId = Tinebase_Core::getUser()->contact_id;
1467             }
1468
1469             $attendee = $_record->assertAttendee(new Calendar_Model_Attender(array(
1470                 'user_type'    => Calendar_Model_Attender::USERTYPE_USER,
1471                 'user_id'      => $calendarUserId
1472             )), false, false, true);
1473
1474             if ($attendee && $container instanceof Tinebase_Model_Container) {
1475                 $attendee->displaycontainer_id = $container->getId();
1476             }
1477
1478             if (! $container instanceof Tinebase_Model_Container || $container->type == Tinebase_Model_Container::TYPE_PERSONAL) {
1479                 // move into special (external users) container
1480                 $container = Calendar_Controller::getInstance()->getInvitationContainer($_record->resolveOrganizer());
1481                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1482                     . ' Setting container_id to ' . $container->getId() . ' for external organizer ' . $_record->organizer->email);
1483                 $_record->container_id = $container->getId();
1484             }
1485
1486         }
1487
1488         if ($_record->is_all_day_event) {
1489             // harmonize datetimes of all day events
1490             $_record->setTimezone($_record->originator_tz);
1491             if (! $_record->dtend) {
1492                 $_record->dtend = clone $_record->dtstart;
1493                 $_record->dtend->setTime(23,59,59);
1494             }
1495             $_record->dtstart->setTime(0,0,0);
1496             $_record->dtend->setTime(23,59,59);
1497             $_record->setTimezone('UTC');
1498         }
1499         $_record->setRruleUntil();
1500
1501         if ($_record->rrule instanceof Calendar_Model_Rrule) {
1502             $_record->rrule->normalize($_record);
1503         }
1504
1505         if ($_record->isRecurException()) {
1506             $baseEvent = $this->getRecurBaseEvent($_record);
1507
1508             // remove invalid rrules
1509             if ($_record->rrule !== NULL) {
1510                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1511                     . ' Removing invalid rrule from recur exception: ' . $_record->rrule);
1512                 $_record->rrule = NULL;
1513             }
1514
1515 //            // Maybe Later
1516 //            // exdates needs to stay in baseEvents container
1517 //            if($_record->container_id != $baseEvent->container_id) {
1518 //                throw new Calendar_Exception_ExdateContainer();
1519 //            }
1520         }
1521     }
1522
1523     /**
1524      * checks/sets originator timezone
1525      *
1526      * @param $record
1527      * @throws Tinebase_Exception_Record_Validation
1528      */
1529     protected function _inspectOriginatorTZ($record)
1530     {
1531         $record->originator_tz = $record->originator_tz ? $record->originator_tz : Tinebase_Core::getUserTimezone();
1532
1533         try {
1534             new DateTimeZone($record->originator_tz);
1535         } catch (Exception $e) {
1536             throw new Tinebase_Exception_Record_Validation('Bad Timezone: ' . $record->originator_tz);
1537         }
1538     }
1539
1540     /**
1541      * inspects delete action
1542      *
1543      * @param array $_ids
1544      * @return array of ids to actually delete
1545      */
1546     protected function _inspectDelete(array $_ids) {
1547         $events = $this->_backend->getMultiple($_ids);
1548
1549         foreach ($events as $event) {
1550
1551             // implicitly delete persistent recur instances of series
1552             if (! empty($event->rrule)) {
1553                 $exceptionIds = $this->getRecurExceptions($event)->getId();
1554                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1555                     . ' Implicitly deleting ' . (count($exceptionIds) - 1 ) . ' persistent exception(s) for recurring series with uid' . $event->uid);
1556                 $_ids = array_merge($_ids, $exceptionIds);
1557             }
1558         }
1559
1560         $this->_deleteAlarmsForIds($_ids);
1561
1562         return array_unique($_ids);
1563     }
1564
1565     /**
1566      * redefine required grants for get actions
1567      *
1568      * @param Tinebase_Model_Filter_FilterGroup $_filter
1569      * @param string $_action get|update
1570      */
1571     public function checkFilterACL(Tinebase_Model_Filter_FilterGroup $_filter, $_action = 'get')
1572     {
1573         $hasGrantsFilter = FALSE;
1574         foreach($_filter->getAclFilters() as $aclFilter) {
1575             if ($aclFilter instanceof Calendar_Model_GrantFilter) {
1576                 $hasGrantsFilter = TRUE;
1577                 break;
1578             }
1579         }
1580
1581         if (! $hasGrantsFilter) {
1582             // force a grant filter
1583             // NOTE: actual grants are set via setRequiredGrants later
1584             $grantsFilter = $_filter->createFilter('grants', 'in', '@setRequiredGrants');
1585             $_filter->addFilter($grantsFilter);
1586         }
1587
1588         parent::checkFilterACL($_filter, $_action);
1589
1590         if ($_action == 'get') {
1591             $_filter->setRequiredGrants(array(
1592                 Tinebase_Model_Grants::GRANT_FREEBUSY,
1593                 Tinebase_Model_Grants::GRANT_READ,
1594                 Tinebase_Model_Grants::GRANT_ADMIN,
1595             ));
1596         }
1597     }
1598
1599     /**
1600      * check grant for action (CRUD)
1601      *
1602      * @param Tinebase_Record_Interface $_record
1603      * @param string $_action
1604      * @param boolean $_throw
1605      * @param string $_errorMessage
1606      * @param Tinebase_Record_Interface $_oldRecord
1607      * @return boolean
1608      * @throws Tinebase_Exception_AccessDenied
1609      *
1610      * @todo use this function in other create + update functions
1611      * @todo invent concept for simple adding of grants (plugins?)
1612      */
1613     protected function _checkGrant($_record, $_action, $_throw = TRUE, $_errorMessage = 'No Permission.', $_oldRecord = NULL)
1614     {
1615         if (    ! $this->_doContainerACLChecks
1616             // admin grant includes all others (only if class is PUBLIC)
1617             ||  (! empty($this->class) && $this->class === Calendar_Model_Event::CLASS_PUBLIC
1618                 && $_record->container_id && Tinebase_Core::getUser()->hasGrant($_record->container_id, Tinebase_Model_Grants::GRANT_ADMIN))
1619             // external invitations are in a spechial invitaion calendar. only attendee can see it via displaycal
1620             ||  $_record->hasExternalOrganizer()
1621         ) {
1622             return true;
1623         }
1624
1625         switch ($_action) {
1626             case 'get':
1627                 // NOTE: free/busy is not a read grant!
1628                 $hasGrant = $_record->hasGrant(Tinebase_Model_Grants::GRANT_READ);
1629                 if (! $hasGrant) {
1630                     $_record->doFreeBusyCleanup();
1631                 }
1632                 break;
1633             case 'create':
1634                 $hasGrant = Tinebase_Core::getUser()->hasGrant($_record->container_id, Tinebase_Model_Grants::GRANT_ADD);
1635                 break;
1636             case 'update':
1637                 $hasGrant = (bool) $_oldRecord->hasGrant(Tinebase_Model_Grants::GRANT_EDIT);
1638
1639                 if ($_oldRecord->container_id != $_record->container_id) {
1640                     $hasGrant &= Tinebase_Core::getUser()->hasGrant($_record->container_id, Tinebase_Model_Grants::GRANT_ADD)
1641                                  && $_oldRecord->hasGrant(Tinebase_Model_Grants::GRANT_DELETE);
1642                 }
1643                 break;
1644             case 'delete':
1645                 $hasGrant = (bool) $_record->hasGrant(Tinebase_Model_Grants::GRANT_DELETE);
1646                 break;
1647             case 'sync':
1648                 $hasGrant = (bool) $_record->hasGrant(Tinebase_Model_Grants::GRANT_SYNC);
1649                 break;
1650             case 'export':
1651                 $hasGrant = (bool) $_record->hasGrant(Tinebase_Model_Grants::GRANT_EXPORT);
1652                 break;
1653         }
1654
1655         if (! $hasGrant) {
1656             if ($_throw) {
1657                 throw new Tinebase_Exception_AccessDenied($_errorMessage);
1658             } else {
1659                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1660                     . ' No permissions to ' . $_action . ' in container ' . $_record->container_id);
1661             }
1662         }
1663
1664         return $hasGrant;
1665     }
1666
1667     /**
1668      * touches (sets seq, last_modified_time and container content sequence) given event
1669      *
1670      * @param  $_event
1671      * @return void
1672      */
1673     protected function _touch($_event, $_setModifier = FALSE)
1674     {
1675         $_event->last_modified_time = Tinebase_DateTime::now();
1676         $_event->seq = (int)$_event->seq + 1;
1677         if ($_setModifier) {
1678             $_event->last_modified_by = Tinebase_Core::getUser()->getId();
1679         }
1680
1681         $this->_backend->update($_event);
1682
1683         $this->_increaseContainerContentSequence($_event, Tinebase_Model_ContainerContent::ACTION_UPDATE);
1684     }
1685
1686     /**
1687      * increase container content sequence
1688      *
1689      * @param Tinebase_Record_Interface $_record
1690      * @param string $action
1691      */
1692     protected function _increaseContainerContentSequence(Tinebase_Record_Interface $record, $action = NULL)
1693     {
1694         parent::_increaseContainerContentSequence($record, $action);
1695
1696         if ($record->attendee instanceof Tinebase_Record_RecordSet) {
1697             $updatedContainerIds = array($record->container_id);
1698             foreach ($record->attendee as $attender) {
1699                 if (isset($attender->displaycontainer_id) && ! in_array($attender->displaycontainer_id, $updatedContainerIds)) {
1700                     Tinebase_Container::getInstance()->increaseContentSequence($attender->displaycontainer_id, $action, $record->getId());
1701                     $updatedContainerIds[] = $attender->displaycontainer_id;
1702                 }
1703             }
1704         }
1705     }
1706
1707
1708     /****************************** attendee functions ************************/
1709
1710     /**
1711      * creates an attender status exception of a recurring event series
1712      *
1713      * NOTE: Recur exceptions are implicitly created
1714      *
1715      * @param  Calendar_Model_Event    $_recurInstance
1716      * @param  Calendar_Model_Attender $_attender
1717      * @param  string                  $_authKey
1718      * @param  bool                    $_allFollowing
1719      * @return Calendar_Model_Attender updated attender
1720      */
1721     public function attenderStatusCreateRecurException($_recurInstance, $_attender, $_authKey, $_allFollowing = FALSE)
1722     {
1723         try {
1724             $db = $this->_backend->getAdapter();
1725             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction($db);
1726
1727             $baseEvent = $this->getRecurBaseEvent($_recurInstance);
1728             $baseEventAttendee = Calendar_Model_Attender::getAttendee($baseEvent->attendee, $_attender);
1729
1730             if ($baseEvent->getId() == $_recurInstance->getId()) {
1731                 // exception to the first occurence
1732                 $_recurInstance->setRecurId($baseEvent->getId());
1733             }
1734
1735             // NOTE: recurid is computed by rrule recur computations and therefore is already part of the event.
1736             if (empty($_recurInstance->recurid)) {
1737                 throw new Exception('recurid must be present to create exceptions!');
1738             }
1739
1740             try {
1741                 // check if we already have a persistent exception for this event
1742                 $eventInstance = $this->_backend->getByProperty($_recurInstance->recurid, $_property = 'recurid');
1743
1744                 // NOTE: the user must exist (added by someone with appropriate rights by createRecurException)
1745                 $exceptionAttender = Calendar_Model_Attender::getAttendee($eventInstance->attendee, $_attender);
1746                 if (! $exceptionAttender) {
1747                     throw new Tinebase_Exception_AccessDenied('not an attendee');
1748                 }
1749
1750
1751                 if ($exceptionAttender->status_authkey != $_authKey) {
1752                     // NOTE: it might happen, that the user set her status from the base event without knowing about
1753                     //       an existing exception. In this case the base event authkey is also valid
1754                     if (! $baseEventAttendee || $baseEventAttendee->status_authkey != $_authKey) {
1755                         throw new Tinebase_Exception_AccessDenied('Attender authkey mismatch');
1756                     }
1757                 }
1758
1759             } catch (Tinebase_Exception_NotFound $e) {
1760                 // otherwise create it implicilty
1761
1762                 // check if this intance takes place
1763                 if (in_array($_recurInstance->dtstart, (array)$baseEvent->exdate)) {
1764                     throw new Tinebase_Exception_AccessDenied('Event instance is deleted and may not be recreated via status setting!');
1765                 }
1766
1767                 if (! $baseEventAttendee) {
1768                     throw new Tinebase_Exception_AccessDenied('not an attendee');
1769                 }
1770
1771                 if ($baseEventAttendee->status_authkey != $_authKey) {
1772                     throw new Tinebase_Exception_AccessDenied('Attender authkey mismatch');
1773                 }
1774
1775                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " creating recur exception for a exceptional attendee status");
1776
1777                 $doContainerAclChecks = $this->doContainerACLChecks(FALSE);
1778                 $sendNotifications = $this->sendNotifications(FALSE);
1779
1780                 // NOTE: the user might have no edit grants, so let's be carefull
1781                 $diff = $baseEvent->dtstart->diff($baseEvent->dtend);
1782
1783                 $baseEvent->dtstart = new Tinebase_DateTime(substr($_recurInstance->recurid, -19), 'UTC');
1784                 $baseEvent->dtend   = clone $baseEvent->dtstart;
1785                 $baseEvent->dtend->add($diff);
1786
1787                 $baseEvent->base_event_id = $baseEvent->id;
1788                 $baseEvent->id = $_recurInstance->id;
1789                 $baseEvent->recurid = $_recurInstance->recurid;
1790
1791                 $attendee = $baseEvent->attendee;
1792                 unset($baseEvent->attendee);
1793
1794                 $eventInstance = $this->createRecurException($baseEvent, FALSE, $_allFollowing);
1795                 $eventInstance->attendee = new Tinebase_Record_RecordSet('Calendar_Model_Attender');
1796                 $this->doContainerACLChecks($doContainerAclChecks);
1797                 $this->sendNotifications($sendNotifications);
1798
1799                 foreach ($attendee as $attender) {
1800                     $attender->setId(NULL);
1801                     $attender->cal_event_id = $eventInstance->getId();
1802
1803                     $attender = $this->_backend->createAttendee($attender);
1804                     $eventInstance->attendee->addRecord($attender);
1805                     $this->_increaseDisplayContainerContentSequence($attender, $eventInstance, Tinebase_Model_ContainerContent::ACTION_CREATE);
1806                 }
1807
1808                 $exceptionAttender = Calendar_Model_Attender::getAttendee($eventInstance->attendee, $_attender);
1809             }
1810
1811             $exceptionAttender->status = $_attender->status;
1812             $exceptionAttender->transp = $_attender->transp;
1813             $eventInstance->alarms     = clone $_recurInstance->alarms;
1814             $eventInstance->alarms->setId(NULL);
1815
1816             $updatedAttender = $this->attenderStatusUpdate($eventInstance, $exceptionAttender, $exceptionAttender->status_authkey);
1817
1818             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1819         } catch (Exception $e) {
1820             Tinebase_TransactionManager::getInstance()->rollBack();
1821             throw $e;
1822         }
1823
1824         return $updatedAttender;
1825     }
1826
1827     /**
1828      * updates an attender status of a event
1829      *
1830      * @param  Calendar_Model_Event    $_event
1831      * @param  Calendar_Model_Attender $_attender
1832      * @param  string                  $_authKey
1833      * @return Calendar_Model_Attender updated attender
1834      */
1835     public function attenderStatusUpdate(Calendar_Model_Event $_event, Calendar_Model_Attender $_attender, $_authKey)
1836     {
1837         try {
1838             $event = $this->get($_event->getId());
1839
1840             if (! $event->attendee) {
1841                 throw new Tinebase_Exception_NotFound('Could not find any attendee of event.');
1842             }
1843
1844             if (($currentAttender = Calendar_Model_Attender::getAttendee($event->attendee, $_attender)) == null) {
1845                 throw new Tinebase_Exception_NotFound('Could not find attender in event.');
1846             }
1847
1848             $updatedAttender = clone $currentAttender;
1849
1850             if ($currentAttender->status_authkey !== $_authKey) {
1851                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG))
1852                     Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " no permissions to update status for {$currentAttender->user_type} {$currentAttender->user_id}");
1853                 return $updatedAttender;
1854             }
1855
1856             Calendar_Controller_Alarm::enforceACL($_event, $event);
1857
1858             $currentAttenderDisplayContainerId = $currentAttender->displaycontainer_id instanceof Tinebase_Model_Container ?
1859                 $currentAttender->displaycontainer_id->getId() :
1860                 $currentAttender->displaycontainer_id;
1861
1862             $attenderDisplayContainerId = $_attender->displaycontainer_id instanceof Tinebase_Model_Container ?
1863                 $_attender->displaycontainer_id->getId() :
1864                 $_attender->displaycontainer_id;
1865
1866             // check if something what can be set as user has changed
1867             if ($currentAttender->status == $_attender->status &&
1868                 $currentAttenderDisplayContainerId  == $attenderDisplayContainerId   &&
1869                 $currentAttender->transp            == $_attender->transp            &&
1870                 ! Calendar_Controller_Alarm::hasUpdates($_event, $event)
1871             ) {
1872                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG))
1873                     Tinebase_Core::getLogger()->DEBUG(__METHOD__ . '::' . __LINE__ . "no status change -> do nothing");
1874                 return $updatedAttender;
1875             }
1876
1877             $updatedAttender->status              = $_attender->status;
1878             $updatedAttender->displaycontainer_id = isset($_attender->displaycontainer_id) ? $_attender->displaycontainer_id : $updatedAttender->displaycontainer_id;
1879             $updatedAttender->transp              = isset($_attender->transp) ? $_attender->transp : Calendar_Model_Event::TRANSP_OPAQUE;
1880
1881             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) {
1882                 Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1883                     . " update attender status to {$_attender->status} for {$currentAttender->user_type} {$currentAttender->user_id}");
1884                 Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
1885                     . ' set alarm_ack_time / alarm_snooze_time: ' . $updatedAttender->alarm_ack_time . ' / ' . $updatedAttender->alarm_snooze_time);
1886             }
1887
1888             $transactionId = Tinebase_TransactionManager::getInstance()->startTransaction(Tinebase_Core::getDb());
1889
1890             $updatedAttender = $this->_backend->updateAttendee($updatedAttender);
1891             if ($_event->alarms instanceof Tinebase_Record_RecordSet) {
1892                 foreach($_event->alarms as $alarm) {
1893                     $this->_inspectAlarmSet($event, $alarm);
1894                 }
1895
1896                 Tinebase_Alarm::getInstance()->setAlarmsOfRecord($_event);
1897             }
1898
1899             $this->_increaseDisplayContainerContentSequence($updatedAttender, $event);
1900
1901             if ($currentAttender->status != $updatedAttender->status) {
1902                 $this->_touch($event, TRUE);
1903             }
1904
1905             Tinebase_TransactionManager::getInstance()->commitTransaction($transactionId);
1906         } catch (Exception $e) {
1907             Tinebase_TransactionManager::getInstance()->rollBack();
1908             throw $e;
1909         }
1910
1911         // send notifications
1912         if ($currentAttender->status != $updatedAttender->status && $this->_sendNotifications && $_event->mute != 1) {
1913             $updatedEvent = $this->get($event->getId());
1914             $this->doSendNotifications($updatedEvent, Tinebase_Core::getUser(), 'changed', $event);
1915         }
1916
1917         return $updatedAttender;
1918     }
1919
1920     /**
1921      * saves all attendee of given event
1922      *
1923      * NOTE: This function is executed in a create/update context. As such the user
1924      *       has edit/update the event and can do anything besides status settings of attendee
1925      *
1926      * @todo add support for resources
1927      *
1928      * @param Calendar_Model_Event $_event
1929      * @param Calendar_Model_Event $_currentEvent
1930      * @param bool                 $_isRescheduled event got rescheduled reset all attendee status
1931      */
1932     protected function _saveAttendee($_event, $_currentEvent = NULL, $_isRescheduled = FALSE)
1933     {
1934         if (! $_event->attendee instanceof Tinebase_Record_RecordSet) {
1935             $_event->attendee = new Tinebase_Record_RecordSet('Calendar_Model_Attender');
1936         }
1937
1938         Calendar_Model_Attender::resolveEmailOnlyAttendee($_event);
1939
1940         $_event->attendee->cal_event_id = $_event->getId();
1941
1942         Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__ . " About to save attendee for event {$_event->id} ");
1943
1944         $currentAttendee = $_currentEvent->attendee;
1945
1946         $diff = $currentAttendee->getMigration($_event->attendee->getArrayOfIds());
1947
1948         $calendar = Tinebase_Container::getInstance()->getContainerById($_event->container_id);
1949
1950         // delete attendee
1951         $this->_backend->deleteAttendee($diff['toDeleteIds']);
1952         foreach ($diff['toDeleteIds'] as $deleteAttenderId) {
1953             $idx = $currentAttendee->getIndexById($deleteAttenderId);
1954             if ($idx !== FALSE) {
1955                 $currentAttenderToDelete = $currentAttendee[$idx];
1956                 $this->_increaseDisplayContainerContentSequence($currentAttenderToDelete, $_event, Tinebase_Model_ContainerContent::ACTION_DELETE);
1957             }
1958         }
1959
1960         // create/update attendee
1961         foreach ($_event->attendee as $attender) {
1962             $attenderId = $attender->getId();
1963             $idx = ($attenderId) ? $currentAttendee->getIndexById($attenderId) : FALSE;
1964
1965             if ($idx !== FALSE) {
1966                 $currentAttender = $currentAttendee[$idx];
1967                 $this->_updateAttender($attender, $currentAttender, $_event, $_isRescheduled, $calendar);
1968             } else {
1969                 $this->_createAttender($attender, $_event, FALSE, $calendar);
1970             }
1971         }
1972     }
1973
1974     /**
1975      * creates a new attender
1976      *
1977      * @param Calendar_Model_Attender  $attender
1978      * @param Tinebase_Model_Container $_calendar
1979      * @param boolean $preserveStatus
1980      * @param Tinebase_Model_Container $calendar
1981      */
1982     protected function _createAttender(Calendar_Model_Attender $attender, Calendar_Model_Event $event, $preserveStatus = FALSE, Tinebase_Model_Container $calendar = NULL)
1983     {
1984         // apply defaults
1985         $attender->user_type         = isset($attender->user_type) ? $attender->user_type : Calendar_Model_Attender::USERTYPE_USER;
1986         $attender->cal_event_id      =  $event->getId();
1987         $calendar = ($calendar) ? $calendar : Tinebase_Container::getInstance()->getContainerById($event->container_id);
1988
1989         $userAccountId = $attender->getUserAccountId();
1990
1991         // generate auth key
1992         if (! $attender->status_authkey) {
1993             $attender->status_authkey = Tinebase_Record_Abstract::generateUID();
1994         }
1995
1996         // attach to display calendar if attender has/is a useraccount
1997         if ($userAccountId) {
1998             if ($calendar->type == Tinebase_Model_Container::TYPE_PERSONAL && Tinebase_Container::getInstance()->hasGrant($userAccountId, $calendar, Tinebase_Model_Grants::GRANT_ADMIN)) {
1999                 // if attender has admin grant to personal physical container, this phys. cal also gets displ. cal
2000                 $attender->displaycontainer_id = $calendar->getId();
2001             } else if ($attender->displaycontainer_id && $userAccountId == Tinebase_Core::getUser()->getId() && Tinebase_Container::getInstance()->hasGrant($userAccountId, $attender->displaycontainer_id, Tinebase_Model_Grants::GRANT_ADMIN)) {
2002                 // allow user to set his own displ. cal
2003                 $attender->displaycontainer_id = $attender->displaycontainer_id;
2004             } else {
2005                 $displayCalId = self::getDefaultDisplayContainerId($userAccountId);
2006                 $attender->displaycontainer_id = $displayCalId;
2007             }
2008
2009         } else if ($attender->user_type === Calendar_Model_Attender::USERTYPE_RESOURCE) {
2010             $resource = Calendar_Controller_Resource::getInstance()->get($attender->user_id);
2011             $attender->displaycontainer_id = $resource->container_id;
2012         }
2013
2014         if ($attender->displaycontainer_id) {
2015             // check if user is allowed to set status
2016             if (! $preserveStatus && ! Tinebase_Core::getUser()->hasGrant($attender->displaycontainer_id, Tinebase_Model_Grants::GRANT_EDIT)) {
2017                 $attender->status = Calendar_Model_Attender::STATUS_NEEDSACTION;
2018             }
2019         }
2020
2021         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ . " New attender: " . print_r($attender->toArray(), TRUE));
2022
2023         Tinebase_Timemachine_ModificationLog::getInstance()->setRecordMetaData($attender, 'create');
2024         $this->_backend->createAttendee($attender);
2025         $this->_increaseDisplayContainerContentSequence($attender, $event, Tinebase_Model_ContainerContent::ACTION_CREATE);
2026     }
2027
2028
2029     /**
2030      * returns the default calendar
2031      *
2032      * @return Tinebase_Model_Container
2033      */
2034     public function getDefaultCalendar()
2035     {
2036         return Tinebase_Container::getInstance()->getDefaultContainer($this->_applicationName, NULL, Calendar_Preference::DEFAULTCALENDAR);
2037     }
2038
2039     /**
2040      * returns default displayContainer id of given attendee
2041      *
2042      * @param string $userAccountId
2043      */
2044     public static function getDefaultDisplayContainerId($userAccountId)
2045     {
2046         $userAccountId = Tinebase_Model_User::convertUserIdToInt($userAccountId);
2047         $displayCalId = Tinebase_Core::getPreference('Calendar')->getValueForUser(Calendar_Preference::DEFAULTCALENDAR, $userAccountId);
2048
2049         try {
2050             // assert that displaycal is of type personal
2051             $container = Tinebase_Container::getInstance()->getContainerById($displayCalId);
2052             if ($container->type != Tinebase_Model_Container::TYPE_PERSONAL) {
2053                 $displayCalId = NULL;
2054             }
2055         } catch (Exception $e) {
2056             $displayCalId = NULL;
2057         }
2058
2059         if (! isset($displayCalId)) {
2060             $containers = Tinebase_Container::getInstance()->getPersonalContainer($userAccountId, 'Calendar_Model_Event', $userAccountId, 0, true);
2061             if ($containers->count() > 0) {
2062                 $displayCalId = $containers->getFirstRecord()->getId();
2063             }
2064         }
2065
2066         return $displayCalId;
2067     }
2068
2069     /**
2070      * increases content sequence of attender display container
2071      *
2072      * @param Calendar_Model_Attender $attender
2073      * @param Calendar_Model_Event $event
2074      * @param string $action
2075      */
2076     protected function _increaseDisplayContainerContentSequence($attender, $event, $action = Tinebase_Model_ContainerContent::ACTION_UPDATE)
2077     {
2078         if ($event->container_id === $attender->displaycontainer_id || empty($attender->displaycontainer_id)) {
2079             // no need to increase sequence
2080             return;
2081         }
2082
2083         Tinebase_Container::getInstance()->increaseContentSequence($attender->displaycontainer_id, $action, $event->getId());
2084     }
2085
2086     /**
2087      * updates an attender
2088      *
2089      * @param Calendar_Model_Attender  $attender
2090      * @param Calendar_Model_Attender  $currentAttender
2091      * @param Calendar_Model_Event     $event
2092      * @param bool                     $isRescheduled event got rescheduled reset all attendee status
2093      * @param Tinebase_Model_Container $calendar
2094      */
2095     protected function _updateAttender($attender, $currentAttender, $event, $isRescheduled, $calendar = NULL)
2096     {
2097         $userAccountId = $currentAttender->getUserAccountId();
2098
2099         // update display calendar if attender has/is a useraccount
2100         if ($userAccountId) {
2101             if ($calendar->type == Tinebase_Model_Container::TYPE_PERSONAL && Tinebase_Container::getInstance()->hasGrant($userAccountId, $calendar, Tinebase_Model_Grants::GRANT_ADMIN)) {
2102                 // if attender has admin grant to personal physical container, this phys. cal also gets displ. cal
2103                 $attender->displaycontainer_id = $calendar->getId();
2104             } else if ($userAccountId == Tinebase_Core::getUser()->getId() && Tinebase_Container::getInstance()->hasGrant($userAccountId, $attender->displaycontainer_id, Tinebase_Model_Grants::GRANT_ADMIN)) {
2105                 // allow user to set his own displ. cal
2106                 $attender->displaycontainer_id = $attender->displaycontainer_id;
2107             } else {
2108                 $attender->displaycontainer_id = $currentAttender->displaycontainer_id;
2109             }
2110         }
2111
2112         // reset status if user has no right and authkey is wrong
2113         if ($attender->displaycontainer_id) {
2114             if (! Tinebase_Core::getUser()->hasGrant($attender->displaycontainer_id, Tinebase_Model_Grants::GRANT_EDIT)
2115                     && $attender->status_authkey != $currentAttender->status_authkey) {
2116
2117                 if (Tinebase_Core::isLogLevel(Zend_Log::NOTICE)) Tinebase_Core::getLogger()->notice(__METHOD__ . '::' . __LINE__
2118                     . ' Wrong authkey, resetting status (' . $attender->status . ' -> ' . $currentAttender->status . ')');
2119                 $attender->status = $currentAttender->status;
2120             }
2121         }
2122
2123         // reset all status but calUser on reschedule
2124         if ($isRescheduled && !$attender->isSame($this->getCalendarUser())) {
2125             $attender->status = Calendar_Model_Attender::STATUS_NEEDSACTION;
2126             $attender->transp = null;
2127         }
2128
2129         // preserve old authkey
2130         $attender->status_authkey = $currentAttender->status_authkey;
2131
2132         if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__
2133             . " Updating attender: " . print_r($attender->toArray(), TRUE));
2134
2135
2136         Tinebase_Timemachine_ModificationLog::getInstance()->setRecordMetaData($attender, 'update', $currentAttender);
2137         Tinebase_Timemachine_ModificationLog::getInstance()->writeModLog($attender, $currentAttender, get_class($attender), $this->_getBackendType(), $attender->getId());
2138         $this->_backend->updateAttendee($attender);
2139
2140         if ($attender->displaycontainer_id !== $currentAttender->displaycontainer_id) {
2141             $this->_increaseDisplayContainerContentSequence($currentAttender, $event, Tinebase_Model_ContainerContent::ACTION_DELETE);
2142             $this->_increaseDisplayContainerContentSequence($attender, $event, Tinebase_Model_ContainerContent::ACTION_CREATE);
2143         } else {
2144             $this->_increaseDisplayContainerContentSequence($attender, $event);
2145         }
2146     }
2147
2148     /**
2149      * event handler for group updates
2150      *
2151      * @param Tinebase_Model_Group $_group
2152      * @return void
2153      */
2154     public function onUpdateGroup($_groupId)
2155     {
2156         $doContainerACLChecks = $this->doContainerACLChecks(FALSE);
2157
2158         $filter = new Calendar_Model_EventFilter(array(
2159             array('field' => 'attender', 'operator' => 'equals', 'value' => array(
2160                 'user_type' => Calendar_Model_Attender::USERTYPE_GROUP,
2161                 'user_id'   => $_groupId
2162             )),
2163             array('field' => 'period', 'operator' => 'within', 'value' => array(
2164                 'from'  => Tinebase_DateTime::now()->get(Tinebase_Record_Abstract::ISO8601LONG),
2165                 'until' => Tinebase_DateTime::now()->addYear(100)->get(Tinebase_Record_Abstract::ISO8601LONG))
2166             )
2167         ));
2168         $events = $this->search($filter, new Tinebase_Model_Pagination(), FALSE, FALSE);
2169
2170         foreach($events as $event) {
2171             try {
2172                 if (! $event->rrule) {
2173                     // update non recurring futrue events
2174                     Calendar_Model_Attender::resolveGroupMembers($event->attendee);
2175                     $this->update($event);
2176                 } else {
2177                     // update thisandfuture for recurring events
2178                     $nextOccurrence = Calendar_Model_Rrule::computeNextOccurrence($event, $this->getRecurExceptions($event), Tinebase_DateTime::now());
2179                     Calendar_Model_Attender::resolveGroupMembers($nextOccurrence->attendee);
2180
2181                     if ($nextOccurrence->dtstart != $event->dtstart) {
2182                         $this->createRecurException($nextOccurrence, FALSE, TRUE);
2183                     } else {
2184                         $this->update($nextOccurrence);
2185                     }
2186                 }
2187             } catch (Exception $e) {
2188                 Tinebase_Core::getLogger()->NOTICE(__METHOD__ . '::' . __LINE__ . " could not update attendee");
2189             }
2190         }
2191
2192         $this->doContainerACLChecks($doContainerACLChecks);
2193     }
2194
2195     /****************************** alarm functions ************************/
2196
2197     /**
2198      * send an alarm
2199      *
2200      * @param  Tinebase_Model_Alarm $_alarm
2201      * @return void
2202      *
2203      * NOTE: the given alarm is raw and has not passed _inspectAlarmGet
2204      *
2205      * @todo throw exception on error
2206      */
2207     public function sendAlarm(Tinebase_Model_Alarm $_alarm)
2208     {
2209         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . " About to send alarm " . print_r($_alarm->toArray(), TRUE));
2210
2211         $doContainerACLChecks = $this->doContainerACLChecks(FALSE);
2212
2213         try {
2214             $event = $this->get($_alarm->record_id);
2215             $event->alarms = new Tinebase_Record_RecordSet('Tinebase_Model_Alarm', array($_alarm));
2216             $this->_inspectAlarmGet($event);
2217         } catch (Exception $e) {
2218             $this->doContainerACLChecks($doContainerACLChecks);
2219             throw($e);
2220         }
2221
2222         $this->doContainerACLChecks($doContainerACLChecks);
2223
2224         if ($event->rrule) {
2225             $recurid = $_alarm->getOption('recurid');
2226
2227             // adopts the (referenced) alarm and sets alarm time to next occurance
2228             parent::_inspectAlarmSet($event, $_alarm);
2229             $this->adoptAlarmTime($event, $_alarm, 'instance');
2230
2231             // sent_status might have changed in adoptAlarmTime()
2232             if ($_alarm->sent_status !== Tinebase_Model_Alarm::STATUS_PENDING) {
2233                 if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
2234                     . ' Not sending alarm for event at ' . $event->dtstart->toString() . ' with status ' . $_alarm->sent_status);
2235                 return;
2236             }
2237
2238             if ($recurid) {
2239                 // NOTE: In case of recuring events $event is always the baseEvent,
2240                 //       so we might need to adopt event time to recur instance.
2241                 $diff = $event->dtstart->diff($event->dtend);
2242
2243                 $event->dtstart = new Tinebase_DateTime(substr($recurid, -19));
2244
2245                 $event->dtend = clone $event->dtstart;
2246                 $event->dtend->add($diff);
2247             }
2248
2249             if ($event->exdate && in_array($event->dtstart, $event->exdate)) {
2250                 if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
2251                     . " Not sending alarm because instance at " . $event->dtstart->toString() . ' is an exception.');
2252                 return;
2253             }
2254         }
2255
2256         Calendar_Controller_EventNotifications::getInstance()->doSendNotifications($event, Tinebase_Core::getUser(), 'alarm', NULL, $_alarm);
2257     }
2258
2259     /**
2260      * send notifications
2261      *
2262      * @param Calendar_Model_Event       $_event
2263      * @param Tinebase_Model_FullAccount $_updater
2264      * @param Sting                      $_action
2265      * @param Calendar_Model_Event       $_oldEvent
2266      * @param Array                      $_additionalRecipients
2267      * @return void
2268      */
2269     public function doSendNotifications($_event, $_updater, $_action, $_oldEvent = NULL)
2270     {
2271         Tinebase_ActionQueue::getInstance()->queueAction('Calendar.sendEventNotifications',
2272             $_event,
2273             $_updater,
2274             $_action,
2275             $_oldEvent ? $_oldEvent : NULL
2276         );
2277     }
2278
2279     public function compareCalendars($cal1, $cal2, $from, $until)
2280     {
2281         $matchingEvents = new Tinebase_Record_RecordSet('Calendar_Model_Event');
2282         $changedEvents = new Tinebase_Record_RecordSet('Calendar_Model_Event');
2283         $missingEventsInCal1 = new Tinebase_Record_RecordSet('Calendar_Model_Event');
2284         $missingEventsInCal2 = new Tinebase_Record_RecordSet('Calendar_Model_Event');
2285         $cal2EventIdsAlreadyProcessed = array();
2286
2287         while ($from->isEarlier($until)) {
2288
2289             $endWeek = $from->getClone()->addWeek(1);
2290
2291             if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
2292                     . ' Comparing period ' . $from . ' - ' . $endWeek);
2293
2294             // get all events from cal1+cal2 for the week
2295             $cal1Events = $this->_getEventsForPeriodAndCalendar($cal1, $from, $endWeek);
2296             $cal1EventsClone = clone $cal1Events;
2297             $cal2Events = $this->_getEventsForPeriodAndCalendar($cal2, $from, $endWeek);
2298             $cal2EventsClone = clone $cal2Events;
2299
2300             $from->addWeek(1);
2301             if (count($cal1Events) == 0 && count($cal2Events) == 0) {
2302                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2303                         . ' No events found');
2304                 continue;
2305             }
2306
2307             foreach ($cal1Events as $event) {
2308                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2309                     . ' Checking event "' . $event->summary . '" ' . $event->dtstart . ' - ' . $event->dtend);
2310
2311                 if ($event->container_id != $cal1) {
2312                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2313                             . ' Event is in another calendar - skip');
2314                     $cal1Events->removeRecord($event);
2315                     continue;
2316                 }
2317
2318                 $summaryMatch = $cal2Events->filter('summary', $event->summary);
2319                 if (count($summaryMatch) > 0) {
2320                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2321                         . " Found " . count($summaryMatch) . ' events with matching summaries');
2322
2323                     $dtStartMatch = $summaryMatch->filter('dtstart', $event->dtstart);
2324                     if (count($dtStartMatch) > 0) {
2325                         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2326                             . " Found " . count($summaryMatch) . ' events with matching dtstarts and summaries');
2327
2328                         $matchingEvents->merge($dtStartMatch);
2329                         // remove from cal1+cal2
2330                         $cal1Events->removeRecord($event);
2331                         $cal2Events->removeRecords($dtStartMatch);
2332                         $cal2EventIdsAlreadyProcessed = array_merge($cal2EventIdsAlreadyProcessed, $dtStartMatch->getArrayOfIds());
2333                     } else {
2334                         $changedEvents->merge($summaryMatch);
2335                         $cal1Events->removeRecord($event);
2336                         $cal2Events->removeRecords($summaryMatch);
2337                         $cal2EventIdsAlreadyProcessed = array_merge($cal2EventIdsAlreadyProcessed, $summaryMatch->getArrayOfIds());
2338                     }
2339                 }
2340             }
2341
2342             // add missing events
2343             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2344                 . " Found " . count($cal1Events) . ' events missing in cal2');
2345             $missingEventsInCal2->merge($cal1Events);
2346
2347             // compare cal2 -> cal1 and add events as missing from cal1 that we did not detect before
2348             foreach ($cal2EventsClone as $event) {
2349                 if (in_array($event->getId(), $cal2EventIdsAlreadyProcessed)) {
2350                     continue;
2351                 }
2352                 if ($event->container_id != $cal2) {
2353                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2354                             . ' Event is in another calendar - skip');
2355                     continue;
2356                 }
2357
2358                 $missingEventsInCal1->addRecord($event);
2359             }
2360         }
2361
2362         $result = array(
2363             'matching'      => $matchingEvents,
2364             'changed'       => $changedEvents,
2365             'missingInCal1' => $missingEventsInCal1,
2366             'missingInCal2' => $missingEventsInCal2,
2367         );
2368         return $result;
2369     }
2370
2371     protected function _getEventsForPeriodAndCalendar($calendarId, $from, $until)
2372     {
2373         $filter = new Calendar_Model_EventFilter(array(
2374             array('field' => 'period', 'operator' => 'within', 'value' =>
2375                 array("from" => $from, "until" => $until)
2376             ),
2377             array('field' => 'container_id', 'operator' => 'equals', 'value' => $calendarId),
2378         ));
2379
2380         $events = Calendar_Controller_Event::getInstance()->search($filter);
2381         Calendar_Model_Rrule::mergeAndRemoveNonMatchingRecurrences($events, $filter);
2382         return $events;
2383     }
2384
2385     /**
2386      * add calendar owner as attendee if not already set
2387      *
2388      * @param string $calendarId
2389      * @param Tinebase_DateTime $from
2390      * @param Tinebase_DateTime $until
2391      * @param boolean $dry run
2392      *
2393      * @return number of updated events
2394      */
2395     public function repairAttendee($calendarId, $from, $until, $dry = false)
2396     {
2397         $container = Tinebase_Container::getInstance()->getContainerById($calendarId);
2398         if ($container->type !== Tinebase_Model_Container::TYPE_PERSONAL) {
2399             throw new Calendar_Exception('Only allowed for personal containers!');
2400         }
2401         if ($container->owner_id !== Tinebase_Core::getUser()->getId()) {
2402             throw new Calendar_Exception('Only allowed for own containers!');
2403         }
2404
2405         $updateCount = 0;
2406         while ($from->isEarlier($until)) {
2407             $endWeek = $from->getClone()->addWeek(1);
2408
2409             if (Tinebase_Core::isLogLevel(Zend_Log::INFO)) Tinebase_Core::getLogger()->info(__METHOD__ . '::' . __LINE__
2410                     . ' Repairing period ' . $from . ' - ' . $endWeek);
2411
2412
2413             // TODO we need to detect events with DECLINED/DELETED attendee
2414             $events = $this->_getEventsForPeriodAndCalendar($calendarId, $from, $endWeek);
2415
2416             $from->addWeek(1);
2417
2418             if (count($events) == 0) {
2419                 if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2420                         . ' No events found');
2421                 continue;
2422             }
2423
2424             foreach ($events as $event) {
2425                 // add attendee if not already set
2426                 if ($event->isRecurInstance()) {
2427                     // TODO get base event
2428                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2429                             . ' Skip recur instance ' . $event->toShortString());
2430                     continue;
2431                 }
2432
2433                 $ownAttender = Calendar_Model_Attender::getOwnAttender($event->attendee);
2434                 if (! $ownAttender) {
2435                     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
2436                             . ' Add missing attender to event ' . $event->toShortString());
2437
2438                     $attender = new Calendar_Model_Attender(array(
2439                         'user_type' => Calendar_Model_Attender::USERTYPE_USER,
2440                         'user_id'   => Tinebase_Core::getUser()->contact_id,
2441                         'status'    => Calendar_Model_Attender::STATUS_ACCEPTED
2442                     ));
2443                     $event->attendee->addRecord($attender);
2444                     if (! $dry) {
2445                         $this->update($event);
2446                     }
2447                     $updateCount++;
2448                 }
2449             }
2450         }
2451
2452         return $updateCount;
2453     }
2454 }