getEventObject() public méthode

This VEVENT will have a recurrence id, and it's DTSTART and DTEND altered.
public getEventObject ( ) : Sabre\VObject\Component\VEvent
Résultat Sabre\VObject\Component\VEvent
Exemple #1
0
 /**
  * If this calendar object, has events with recurrence rules, this method
  * can be used to expand the event into multiple sub-events.
  *
  * Each event will be stripped from it's recurrence information, and only
  * the instances of the event in the specified timerange will be left
  * alone.
  *
  * In addition, this method will cause timezone information to be stripped,
  * and normalized to UTC.
  *
  * This method will alter the VCalendar. This cannot be reversed.
  *
  * This functionality is specifically used by the CalDAV standard. It is
  * possible for clients to request expand events, if they are rather simple
  * clients and do not have the possibility to calculate recurrences.
  *
  * @param DateTime $start
  * @param DateTime $end
  * @param DateTimeZone $timeZone reference timezone for floating dates and
  *                     times.
  * @return void
  */
 function expand(DateTime $start, DateTime $end, DateTimeZone $timeZone = null)
 {
     $newEvents = array();
     if (!$timeZone) {
         $timeZone = new DateTimeZone('UTC');
     }
     // An array of events. Events are indexed by UID. Each item in this
     // array is a list of one or more events that match the UID.
     $recurringEvents = array();
     foreach ($this->select('VEVENT') as $key => $vevent) {
         $uid = (string) $vevent->UID;
         if (!$uid) {
             throw new \LogicException('Event did not have a UID!');
         }
         if (isset($vevent->{'RECURRENCE-ID'}) || isset($vevent->RRULE)) {
             if (isset($recurringEvents[$uid])) {
                 $recurringEvents[$uid][] = $vevent;
             } else {
                 $recurringEvents[$uid] = array($vevent);
             }
             continue;
         }
         if (!isset($vevent->RRULE)) {
             if ($vevent->isInTimeRange($start, $end)) {
                 $newEvents[] = $vevent;
             }
             continue;
         }
     }
     foreach ($recurringEvents as $events) {
         try {
             $it = new EventIterator($events, $timeZone);
         } catch (NoInstancesException $e) {
             // This event is recurring, but it doesn't have a single
             // instance. We are skipping this event from the output
             // entirely.
             continue;
         }
         $it->fastForward($start);
         while ($it->valid() && $it->getDTStart() < $end) {
             if ($it->getDTEnd() > $start) {
                 $newEvents[] = $it->getEventObject();
             }
             $it->next();
         }
     }
     // Wiping out all old VEVENT objects
     unset($this->VEVENT);
     // Setting all properties to UTC time.
     foreach ($newEvents as $newEvent) {
         foreach ($newEvent->children as $child) {
             if ($child instanceof VObject\Property\ICalendar\DateTime && $child->hasTime()) {
                 $dt = $child->getDateTimes($timeZone);
                 // We only need to update the first timezone, because
                 // setDateTimes will match all other timezones to the
                 // first.
                 $dt[0]->setTimeZone(new DateTimeZone('UTC'));
                 $child->setDateTimes($dt);
             }
         }
         $this->add($newEvent);
     }
     // Removing all VTIMEZONE components
     unset($this->VTIMEZONE);
 }
Exemple #2
0
 /**
  * Processes incoming REPLY messages.
  *
  * The message is a reply. This is for example an attendee telling
  * an organizer he accepted the invite, or declined it.
  *
  * @param Message $itipMessage
  * @param VCalendar $existingObject
  * @return VCalendar|null
  */
 protected function processMessageReply(Message $itipMessage, VCalendar $existingObject = null)
 {
     // A reply can only be processed based on an existing object.
     // If the object is not available, the reply is ignored.
     if (!$existingObject) {
         return null;
     }
     $instances = array();
     $requestStatus = '2.0';
     // Finding all the instances the attendee replied to.
     foreach ($itipMessage->message->VEVENT as $vevent) {
         $recurId = isset($vevent->{'RECURRENCE-ID'}) ? $vevent->{'RECURRENCE-ID'}->getValue() : 'master';
         $attendee = $vevent->ATTENDEE;
         $instances[$recurId] = $attendee['PARTSTAT']->getValue();
         if (isset($vevent->{'REQUEST-STATUS'})) {
             $requestStatus = $vevent->{'REQUEST-STATUS'}->getValue();
             list($requestStatus) = explode(';', $requestStatus);
         }
     }
     // Now we need to loop through the original organizer event, to find
     // all the instances where we have a reply for.
     $masterObject = null;
     foreach ($existingObject->VEVENT as $vevent) {
         $recurId = isset($vevent->{'RECURRENCE-ID'}) ? $vevent->{'RECURRENCE-ID'}->getValue() : 'master';
         if ($recurId === 'master') {
             $masterObject = $vevent;
         }
         if (isset($instances[$recurId])) {
             $attendeeFound = false;
             if (isset($vevent->ATTENDEE)) {
                 foreach ($vevent->ATTENDEE as $attendee) {
                     if ($attendee->getValue() === $itipMessage->sender) {
                         $attendeeFound = true;
                         $attendee['PARTSTAT'] = $instances[$recurId];
                         $attendee['SCHEDULE-STATUS'] = $requestStatus;
                         // Un-setting the RSVP status, because we now know
                         // that the attende already replied.
                         unset($attendee['RSVP']);
                         break;
                     }
                 }
             }
             if (!$attendeeFound) {
                 // Adding a new attendee. The iTip documentation calls this
                 // a party crasher.
                 $attendee = $vevent->add('ATTENDEE', $itipMessage->sender, array('PARTSTAT' => $instances[$recurId]));
                 if ($itipMessage->senderName) {
                     $attendee['CN'] = $itipMessage->senderName;
                 }
             }
             unset($instances[$recurId]);
         }
     }
     if (!$masterObject) {
         // No master object, we can't add new instances.
         return null;
     }
     // If we got replies to instances that did not exist in the
     // original list, it means that new exceptions must be created.
     foreach ($instances as $recurId => $partstat) {
         $recurrenceIterator = new EventIterator($existingObject, $itipMessage->uid);
         $found = false;
         $iterations = 1000;
         do {
             $newObject = $recurrenceIterator->getEventObject();
             $recurrenceIterator->next();
             if (isset($newObject->{'RECURRENCE-ID'}) && $newObject->{'RECURRENCE-ID'}->getValue() === $recurId) {
                 $found = true;
             }
             $iterations--;
         } while ($recurrenceIterator->valid() && !$found && $iterations);
         // Invalid recurrence id. Skipping this object.
         if (!$found) {
             continue;
         }
         unset($newObject->RRULE, $newObject->EXDATE, $newObject->RDATE);
         $attendeeFound = false;
         if (isset($newObject->ATTENDEE)) {
             foreach ($newObject->ATTENDEE as $attendee) {
                 if ($attendee->getValue() === $itipMessage->sender) {
                     $attendeeFound = true;
                     $attendee['PARTSTAT'] = $partstat;
                     break;
                 }
             }
         }
         if (!$attendeeFound) {
             // Adding a new attendee
             $attendee = $newObject->add('ATTENDEE', $itipMessage->sender, array('PARTSTAT' => $partstat));
             if ($itipMessage->senderName) {
                 $attendee['CN'] = $itipMessage->senderName;
             }
         }
         $existingObject->add($newObject);
     }
     return $existingObject;
 }
Exemple #3
0
 /**
  * @depends testValues
  */
 function testOverridenEventNoValuesExpected()
 {
     $vcal = new VCalendar();
     $ev1 = $vcal->createComponent('VEVENT');
     $ev1->UID = 'overridden';
     $ev1->RRULE = 'FREQ=WEEKLY;COUNT=3';
     $ev1->DTSTART = '20120124T120000Z';
     $ev1->SUMMARY = 'baseEvent';
     $vcal->add($ev1);
     // ev2 overrides an event, and puts it 6 days earlier instead.
     $ev2 = $vcal->createComponent('VEVENT');
     $ev2->UID = 'overridden';
     $ev2->{'RECURRENCE-ID'} = '20120131T120000Z';
     $ev2->DTSTART = '20120125T120000Z';
     $ev2->SUMMARY = 'Override!';
     $vcal->add($ev2);
     $it = new EventIterator($vcal, 'overridden');
     $dates = array();
     $summaries = array();
     // The reported problem was specifically related to the VCALENDAR
     // expansion. In this parcitular case, we had to forward to the 28th of
     // january.
     $it->fastForward(new DateTime('2012-01-28 23:00:00'));
     // We stop the loop when it hits the 6th of februari. Normally this
     // iterator would hit 24, 25 (overriden from 31) and 7 feb but because
     // we 'filter' from the 28th till the 6th, we should get 0 results.
     while ($it->valid() && $it->getDTSTart() < new DateTime('2012-02-06 23:00:00')) {
         $dates[] = $it->getDTStart();
         $summaries[] = (string) $it->getEventObject()->SUMMARY;
         $it->next();
     }
     $this->assertEquals(array(), $dates);
     $this->assertEquals(array(), $summaries);
 }
 /**
  * If this calendar object, has events with recurrence rules, this method
  * can be used to expand the event into multiple sub-events.
  *
  * Each event will be stripped from it's recurrence information, and only
  * the instances of the event in the specified timerange will be left
  * alone.
  *
  * In addition, this method will cause timezone information to be stripped,
  * and normalized to UTC.
  *
  * This method will alter the VCalendar. This cannot be reversed.
  *
  * This functionality is specifically used by the CalDAV standard. It is
  * possible for clients to request expand events, if they are rather simple
  * clients and do not have the possibility to calculate recurrences.
  *
  * @param DateTime $start
  * @param DateTime $end
  * @return void
  */
 public function expand(\DateTime $start, \DateTime $end)
 {
     $newEvents = array();
     foreach ($this->select('VEVENT') as $key => $vevent) {
         if (isset($vevent->{'RECURRENCE-ID'})) {
             unset($this->children[$key]);
             continue;
         }
         if (!$vevent->rrule) {
             unset($this->children[$key]);
             if ($vevent->isInTimeRange($start, $end)) {
                 $newEvents[] = $vevent;
             }
             continue;
         }
         $uid = (string) $vevent->uid;
         if (!$uid) {
             throw new \LogicException('Event did not have a UID!');
         }
         $it = new EventIterator($this, $vevent->uid);
         $it->fastForward($start);
         while ($it->valid() && $it->getDTStart() < $end) {
             if ($it->getDTEnd() > $start) {
                 $newEvents[] = $it->getEventObject();
             }
             $it->next();
         }
         unset($this->children[$key]);
     }
     // Setting all properties to UTC time.
     foreach ($newEvents as $newEvent) {
         foreach ($newEvent->children as $child) {
             if ($child instanceof VObject\Property\ICalendar\DateTime && $child->hasTime()) {
                 $dt = $child->getDateTimes();
                 // We only need to update the first timezone, because
                 // setDateTimes will match all other timezones to the
                 // first.
                 $dt[0]->setTimeZone(new \DateTimeZone('UTC'));
                 $child->setDateTimes($dt);
             }
         }
         $this->add($newEvent);
     }
     // Removing all VTIMEZONE components
     unset($this->VTIMEZONE);
 }
Exemple #5
0
 /**
  * Expand all events in this VCalendar object and return a new VCalendar
  * with the expanded events.
  *
  * If this calendar object, has events with recurrence rules, this method
  * can be used to expand the event into multiple sub-events.
  *
  * Each event will be stripped from it's recurrence information, and only
  * the instances of the event in the specified timerange will be left
  * alone.
  *
  * In addition, this method will cause timezone information to be stripped,
  * and normalized to UTC.
  *
  * @param DateTimeInterface $start
  * @param DateTimeInterface $end
  * @param DateTimeZone $timeZone reference timezone for floating dates and
  *                     times.
  * @return VCalendar
  */
 function expand(DateTimeInterface $start, DateTimeInterface $end, DateTimeZone $timeZone = null)
 {
     $newChildren = [];
     $recurringEvents = [];
     if (!$timeZone) {
         $timeZone = new DateTimeZone('UTC');
     }
     $stripTimezones = function (Component $component) use($timeZone, &$stripTimezones) {
         foreach ($component->children() as $componentChild) {
             if ($componentChild instanceof Property\ICalendar\DateTime && $componentChild->hasTime()) {
                 $dt = $componentChild->getDateTimes($timeZone);
                 // We only need to update the first timezone, because
                 // setDateTimes will match all other timezones to the
                 // first.
                 $dt[0] = $dt[0]->setTimeZone(new DateTimeZone('UTC'));
                 $componentChild->setDateTimes($dt);
             } elseif ($componentChild instanceof Component) {
                 $stripTimezones($componentChild);
             }
         }
         return $component;
     };
     foreach ($this->children() as $child) {
         if ($child instanceof Property && $child->name !== 'PRODID') {
             // We explictly want to ignore PRODID, because we want to
             // overwrite it with our own.
             $newChildren[] = clone $child;
         } elseif ($child instanceof Component && $child->name !== 'VTIMEZONE') {
             // We're also stripping all VTIMEZONE objects because we're
             // converting everything to UTC.
             if ($child->name === 'VEVENT' && (isset($child->{'RECURRENCE-ID'}) || isset($child->RRULE) || isset($child->RDATE))) {
                 // Handle these a bit later.
                 $uid = (string) $child->UID;
                 if (!$uid) {
                     throw new InvalidDataException('Every VEVENT object must have a UID property');
                 }
                 if (isset($recurringEvents[$uid])) {
                     $recurringEvents[$uid][] = clone $child;
                 } else {
                     $recurringEvents[$uid] = [clone $child];
                 }
             } elseif ($child->name === 'VEVENT' && $child->isInTimeRange($start, $end)) {
                 $newChildren[] = $stripTimezones(clone $child);
             }
         }
     }
     foreach ($recurringEvents as $events) {
         try {
             $it = new EventIterator($events, $timeZone);
         } catch (NoInstancesException $e) {
             // This event is recurring, but it doesn't have a single
             // instance. We are skipping this event from the output
             // entirely.
             continue;
         }
         $it->fastForward($start);
         while ($it->valid() && $it->getDTStart() < $end) {
             if ($it->getDTEnd() > $start) {
                 $newChildren[] = $stripTimezones($it->getEventObject());
             }
             $it->next();
         }
     }
     return new self($newChildren);
 }
 /**
  * Validates if a component matches the given time range.
  *
  * This is all based on the rules specified in rfc4791, which are quite
  * complex.
  *
  * @param VObject\Node $component
  * @param DateTime $start
  * @param DateTime $end
  * @return bool
  */
 protected function validateTimeRange(VObject\Node $component, $start, $end)
 {
     if (is_null($start)) {
         $start = new DateTime('1900-01-01');
     }
     if (is_null($end)) {
         $end = new DateTime('3000-01-01');
     }
     switch ($component->name) {
         case 'VEVENT':
         case 'VTODO':
         case 'VJOURNAL':
             return $component->isInTimeRange($start, $end);
         case 'VALARM':
             // If the valarm is wrapped in a recurring event, we need to
             // expand the recursions, and validate each.
             //
             // Our datamodel doesn't easily allow us to do this straight
             // in the VALARM component code, so this is a hack, and an
             // expensive one too.
             if ($component->parent->name === 'VEVENT' && $component->parent->RRULE) {
                 // Fire up the iterator!
                 $it = new VObject\Recur\EventIterator($component->parent->parent, (string) $component->parent->UID);
                 while ($it->valid()) {
                     $expandedEvent = $it->getEventObject();
                     // We need to check from these expanded alarms, which
                     // one is the first to trigger. Based on this, we can
                     // determine if we can 'give up' expanding events.
                     $firstAlarm = null;
                     if ($expandedEvent->VALARM !== null) {
                         foreach ($expandedEvent->VALARM as $expandedAlarm) {
                             $effectiveTrigger = $expandedAlarm->getEffectiveTriggerTime();
                             if ($expandedAlarm->isInTimeRange($start, $end)) {
                                 return true;
                             }
                             if ((string) $expandedAlarm->TRIGGER['VALUE'] === 'DATE-TIME') {
                                 // This is an alarm with a non-relative trigger
                                 // time, likely created by a buggy client. The
                                 // implication is that every alarm in this
                                 // recurring event trigger at the exact same
                                 // time. It doesn't make sense to traverse
                                 // further.
                             } else {
                                 // We store the first alarm as a means to
                                 // figure out when we can stop traversing.
                                 if (!$firstAlarm || $effectiveTrigger < $firstAlarm) {
                                     $firstAlarm = $effectiveTrigger;
                                 }
                             }
                         }
                     }
                     if (is_null($firstAlarm)) {
                         // No alarm was found.
                         //
                         // Or technically: No alarm that will change for
                         // every instance of the recurrence was found,
                         // which means we can assume there was no match.
                         return false;
                     }
                     if ($firstAlarm > $end) {
                         return false;
                     }
                     $it->next();
                 }
                 return false;
             } else {
                 return $component->isInTimeRange($start, $end);
             }
         case 'VFREEBUSY':
             throw new \Sabre\DAV\Exception\NotImplemented('time-range filters are currently not supported on ' . $component->name . ' components');
         case 'COMPLETED':
         case 'CREATED':
         case 'DTEND':
         case 'DTSTAMP':
         case 'DTSTART':
         case 'DUE':
         case 'LAST-MODIFIED':
             return $start <= $component->getDateTime() && $end >= $component->getDateTime();
         default:
             throw new \Sabre\DAV\Exception\BadRequest('You cannot create a time-range filter on a ' . $component->name . ' component');
     }
 }
Exemple #7
0
 /**
  * Processes incoming REPLY messages.
  *
  * The message is a reply. This is for example an attendee telling
  * an organizer he accepted the invite, or declined it.
  *
  * @param Message $itipMessage
  * @param VCalendar $existingObject
  * @return VCalendar|null
  */
 protected function processMessageReply(Message $itipMessage, VCalendar $existingObject = null)
 {
     // A reply can only be processed based on an existing object.
     // If the object is not available, the reply is ignored.
     if (!$existingObject) {
         return null;
     }
     $instances = array();
     foreach ($itipMessage->message->VEVENT as $vevent) {
         $recurId = isset($vevent->{'RECURRENCE-ID'}) ? $vevent->{'RECURRENCE-ID'}->getValue() : 'master';
         $attendee = $vevent->ATTENDEE;
         $instances[$recurId] = $attendee['PARTSTAT']->getValue();
     }
     $masterObject = null;
     foreach ($existingObject->VEVENT as $vevent) {
         $recurId = isset($vevent->{'RECURRENCE-ID'}) ? $vevent->{'RECURRENCE-ID'}->getValue() : 'master';
         if ($recurId === 'master') {
             $masterObject = $vevent;
         }
         if (isset($instances[$recurId])) {
             $attendeeFound = false;
             if (isset($vevent->ATTENDEE)) {
                 foreach ($vevent->ATTENDEE as $attendee) {
                     if ($attendee->getValue() === $itipMessage->sender) {
                         $attendeeFound = true;
                         $attendee['PARTSTAT'] = $instances[$recurId];
                         break;
                     }
                 }
             }
             if (!$attendeeFound) {
                 // Adding a new attendee. The iTip documentation calls this
                 // a party crasher.
                 $attendee = $vevent->add('ATTENDEE', $itipMessage->sender, array('PARTSTAT' => $instances[$recurId]));
                 if ($itipMessage->senderName) {
                     $attendee['CN'] = $itipMessage->senderName;
                 }
             }
             unset($instances[$recurId]);
         }
     }
     if (!$masterObject) {
         // No master object, we can't add new instances.
         return null;
     }
     // If we got replies to instances that did not exist in the
     // original list, it means that new exceptions must be created.
     foreach ($instances as $recurId => $partstat) {
         $recurrenceIterator = new EventIterator($existingObject, $itipMessage->uid);
         $found = false;
         $iterations = 1000;
         do {
             $newObject = $recurrenceIterator->getEventObject();
             $recurrenceIterator->next();
             if (isset($newObject->{'RECURRENCE-ID'}) && $newObject->{'RECURRENCE-ID'}->getValue() === $recurId) {
                 $found = true;
             }
             $iterations--;
         } while ($recurrenceIterator->valid() && !$found && $iterations);
         // Invalid recurrence id. Skipping this object.
         if (!$found) {
             continue;
         }
         unset($newObject->RRULE, $newObject->EXDATE, $newObject->RDATE);
         $newObject->{'RECURRENCE-ID'} = $recurId;
         $attendeeFound = false;
         if (isset($newObject->ATTENDEE)) {
             foreach ($newObject->ATTENDEE as $attendee) {
                 if ($attendee->getValue() === $itipMessage->sender) {
                     $attendeeFound = true;
                     $attendee['PARTSTAT'] = $partstat;
                     break;
                 }
             }
         }
         if (!$attendeeFound) {
             // Adding a new attendee
             $attendee = $newObject->add('ATTENDEE', $itipMessage->sender, array('PARTSTAT' => $partstat));
             if ($itipMessage->senderName) {
                 $attendee['CN'] = $itipMessage->senderName;
             }
         }
         $existingObject->add($newObject);
     }
     return $existingObject;
 }