Mercurial > hg > rc1

comparison plugins/calendar/lib/Horde_Date_Recurrence.php @ 3:f6fe4b6ae66a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
calendar plugin nearly as distributed
author Charlie Root
date Sat, 13 Jan 2018 08:56:12 -0500
parents
children
comparison
equal deleted inserted replaced
2:c828b0fd4a6e 3:f6fe4b6ae66a
1 <?php
2
3 /**
4 * This is a modified copy of Horde/Date/Recurrence.php
5 * Pull the latest version of this file from the PEAR channel of the Horde
6 * project at http://pear.horde.org by installing the Horde_Date package.
7 */
8
9 if (!class_exists('Horde_Date'))
10 require_once(dirname(__FILE__) . '/Horde_Date.php');
11
12 // minimal required implementation of Horde_Date_Translation to avoid a huge dependency nightmare
13 class Horde_Date_Translation
14 {
15 function t($arg) { return $arg; }
16 function ngettext($sing, $plur, $num) { return ($num > 1 ? $plur : $sing); }
17 }
18
19
20 /**
21 * This file contains the Horde_Date_Recurrence class and according constants.
22 *
23 * Copyright 2007-2012 Horde LLC (http://www.horde.org/)
24 *
25 * See the enclosed file COPYING for license information (LGPL). If you
26 * did not receive this file, see http://www.horde.org/licenses/lgpl21.
27 *
28 * @category Horde
29 * @package Date
30 */
31
32 /**
33 * The Horde_Date_Recurrence class implements algorithms for calculating
34 * recurrences of events, including several recurrence types, intervals,
35 * exceptions, and conversion from and to vCalendar and iCalendar recurrence
36 * rules.
37 *
38 * All methods expecting dates as parameters accept all values that the
39 * Horde_Date constructor accepts, i.e. a timestamp, another Horde_Date
40 * object, an ISO time string or a hash.
41 *
42 * @author Jan Schneider <jan@horde.org>
43 * @category Horde
44 * @package Date
45 */
46 class Horde_Date_Recurrence
47 {
48 /** No Recurrence **/
49 const RECUR_NONE = 0;
50
51 /** Recurs daily. */
52 const RECUR_DAILY = 1;
53
54 /** Recurs weekly. */
55 const RECUR_WEEKLY = 2;
56
57 /** Recurs monthly on the same date. */
58 const RECUR_MONTHLY_DATE = 3;
59
60 /** Recurs monthly on the same week day. */
61 const RECUR_MONTHLY_WEEKDAY = 4;
62
63 /** Recurs yearly on the same date. */
64 const RECUR_YEARLY_DATE = 5;
65
66 /** Recurs yearly on the same day of the year. */
67 const RECUR_YEARLY_DAY = 6;
68
69 /** Recurs yearly on the same week day. */
70 const RECUR_YEARLY_WEEKDAY = 7;
71
72 /**
73 * The start time of the event.
74 *
75 * @var Horde_Date
76 */
77 public $start;
78
79 /**
80 * The end date of the recurrence interval.
81 *
82 * @var Horde_Date
83 */
84 public $recurEnd = null;
85
86 /**
87 * The number of recurrences.
88 *
89 * @var integer
90 */
91 public $recurCount = null;
92
93 /**
94 * The type of recurrence this event follows. RECUR_* constant.
95 *
96 * @var integer
97 */
98 public $recurType = self::RECUR_NONE;
99
100 /**
101 * The length of time between recurrences. The time unit depends on the
102 * recurrence type.
103 *
104 * @var integer
105 */
106 public $recurInterval = 1;
107
108 /**
109 * Any additional recurrence data.
110 *
111 * @var integer
112 */
113 public $recurData = null;
114
115 /**
116 * BYDAY recurrence number
117 *
118 * @var integer
119 */
120 public $recurNthDay = null;
121
122 /**
123 * BYMONTH recurrence data
124 *
125 * @var array
126 */
127 public $recurMonths = array();
128
129 /**
130 * RDATE recurrence values
131 *
132 * @var array
133 */
134 public $rdates = array();
135
136 /**
137 * All the exceptions from recurrence for this event.
138 *
139 * @var array
140 */
141 public $exceptions = array();
142
143 /**
144 * All the dates this recurrence has been marked as completed.
145 *
146 * @var array
147 */
148 public $completions = array();
149
150 /**
151 * Constructor.
152 *
153 * @param Horde_Date $start Start of the recurring event.
154 */
155 public function __construct($start)
156 {
157 $this->start = new Horde_Date($start);
158 }
159
160 /**
161 * Resets the class properties.
162 */
163 public function reset()
164 {
165 $this->recurEnd = null;
166 $this->recurCount = null;
167 $this->recurType = self::RECUR_NONE;
168 $this->recurInterval = 1;
169 $this->recurData = null;
170 $this->exceptions = array();
171 $this->completions = array();
172 }
173
174 /**
175 * Checks if this event recurs on a given day of the week.
176 *
177 * @param integer $dayMask A mask consisting of Horde_Date::MASK_*
178 * constants specifying the day(s) to check.
179 *
180 * @return boolean True if this event recurs on the given day(s).
181 */
182 public function recurOnDay($dayMask)
183 {
184 return ($this->recurData & $dayMask);
185 }
186
187 /**
188 * Specifies the days this event recurs on.
189 *
190 * @param integer $dayMask A mask consisting of Horde_Date::MASK_*
191 * constants specifying the day(s) to recur on.
192 */
193 public function setRecurOnDay($dayMask)
194 {
195 $this->recurData = $dayMask;
196 }
197
198 /**
199 *
200 * @param integer $nthDay The nth weekday of month to repeat events on
201 */
202 public function setRecurNthWeekday($nth)
203 {
204 $this->recurNthDay = (int)$nth;
205 }
206
207 /**
208 *
209 * @return integer The nth weekday of month to repeat events.
210 */
211 public function getRecurNthWeekday()
212 {
213 return isset($this->recurNthDay) ? $this->recurNthDay : ceil($this->start->mday / 7);
214 }
215
216 /**
217 * Specifies the months for yearly (weekday) recurrence
218 *
219 * @param array $months List of months (integers) this event recurs on.
220 */
221 function setRecurByMonth($months)
222 {
223 $this->recurMonths = (array)$months;
224 }
225
226 /**
227 * Returns a list of months this yearly event recurs on
228 *
229 * @return array List of months (integers) this event recurs on.
230 */
231 function getRecurByMonth()
232 {
233 return $this->recurMonths;
234 }
235
236 /**
237 * Returns the days this event recurs on.
238 *
239 * @return integer A mask consisting of Horde_Date::MASK_* constants
240 * specifying the day(s) this event recurs on.
241 */
242 public function getRecurOnDays()
243 {
244 return $this->recurData;
245 }
246
247 /**
248 * Returns whether this event has a specific recurrence type.
249 *
250 * @param integer $recurrence RECUR_* constant of the
251 * recurrence type to check for.
252 *
253 * @return boolean True if the event has the specified recurrence type.
254 */
255 public function hasRecurType($recurrence)
256 {
257 return ($recurrence == $this->recurType);
258 }
259
260 /**
261 * Sets a recurrence type for this event.
262 *
263 * @param integer $recurrence A RECUR_* constant.
264 */
265 public function setRecurType($recurrence)
266 {
267 $this->recurType = $recurrence;
268 }
269
270 /**
271 * Returns recurrence type of this event.
272 *
273 * @return integer A RECUR_* constant.
274 */
275 public function getRecurType()
276 {
277 return $this->recurType;
278 }
279
280 /**
281 * Returns a description of this event's recurring type.
282 *
283 * @return string Human readable recurring type.
284 */
285 public function getRecurName()
286 {
287 switch ($this->getRecurType()) {
288 case self::RECUR_NONE: return Horde_Date_Translation::t("No recurrence");
289 case self::RECUR_DAILY: return Horde_Date_Translation::t("Daily");
290 case self::RECUR_WEEKLY: return Horde_Date_Translation::t("Weekly");
291 case self::RECUR_MONTHLY_DATE:
292 case self::RECUR_MONTHLY_WEEKDAY: return Horde_Date_Translation::t("Monthly");
293 case self::RECUR_YEARLY_DATE:
294 case self::RECUR_YEARLY_DAY:
295 case self::RECUR_YEARLY_WEEKDAY: return Horde_Date_Translation::t("Yearly");
296 }
297 }
298
299 /**
300 * Sets the length of time between recurrences of this event.
301 *
302 * @param integer $interval The time between recurrences.
303 */
304 public function setRecurInterval($interval)
305 {
306 if ($interval > 0) {
307 $this->recurInterval = $interval;
308 }
309 }
310
311 /**
312 * Retrieves the length of time between recurrences of this event.
313 *
314 * @return integer The number of seconds between recurrences.
315 */
316 public function getRecurInterval()
317 {
318 return $this->recurInterval;
319 }
320
321 /**
322 * Sets the number of recurrences of this event.
323 *
324 * @param integer $count The number of recurrences.
325 */
326 public function setRecurCount($count)
327 {
328 if ($count > 0) {
329 $this->recurCount = (int)$count;
330 // Recurrence counts and end dates are mutually exclusive.
331 $this->recurEnd = null;
332 } else {
333 $this->recurCount = null;
334 }
335 }
336
337 /**
338 * Retrieves the number of recurrences of this event.
339 *
340 * @return integer The number recurrences.
341 */
342 public function getRecurCount()
343 {
344 return $this->recurCount;
345 }
346
347 /**
348 * Returns whether this event has a recurrence with a fixed count.
349 *
350 * @return boolean True if this recurrence has a fixed count.
351 */
352 public function hasRecurCount()
353 {
354 return isset($this->recurCount);
355 }
356
357 /**
358 * Sets the start date of the recurrence interval.
359 *
360 * @param Horde_Date $start The recurrence start.
361 */
362 public function setRecurStart($start)
363 {
364 $this->start = clone $start;
365 }
366
367 /**
368 * Retrieves the start date of the recurrence interval.
369 *
370 * @return Horde_Date The recurrence start.
371 */
372 public function getRecurStart()
373 {
374 return $this->start;
375 }
376
377 /**
378 * Sets the end date of the recurrence interval.
379 *
380 * @param Horde_Date $end The recurrence end.
381 */
382 public function setRecurEnd($end)
383 {
384 if (!empty($end)) {
385 // Recurrence counts and end dates are mutually exclusive.
386 $this->recurCount = null;
387 $this->recurEnd = clone $end;
388 } else {
389 $this->recurEnd = $end;
390 }
391 }
392
393 /**
394 * Retrieves the end date of the recurrence interval.
395 *
396 * @return Horde_Date The recurrence end.
397 */
398 public function getRecurEnd()
399 {
400 return $this->recurEnd;
401 }
402
403 /**
404 * Returns whether this event has a recurrence end.
405 *
406 * @return boolean True if this recurrence ends.
407 */
408 public function hasRecurEnd()
409 {
410 return isset($this->recurEnd) && isset($this->recurEnd->year) &&
411 $this->recurEnd->year != 9999;
412 }
413
414 /**
415 * Finds the next recurrence of this event that's after $afterDate.
416 *
417 * @param Horde_Date|string $after Return events after this date.
418 *
419 * @return Horde_Date|boolean The date of the next recurrence or false
420 * if the event does not recur after
421 * $afterDate.
422 */
423 public function nextRecurrence($after)
424 {
425 if (!($after instanceof Horde_Date)) {
426 $after = new Horde_Date($after);
427 } else {
428 $after = clone($after);
429 }
430
431 // Make sure $after and $this->start are in the same TZ
432 $after->setTimezone($this->start->timezone);
433 if ($this->start->compareDateTime($after) >= 0) {
434 return clone $this->start;
435 }
436
437 if ($this->recurInterval == 0 && empty($this->rdates)) {
438 return false;
439 }
440
441 switch ($this->getRecurType()) {
442 case self::RECUR_DAILY:
443 $diff = $this->start->diff($after);
444 $recur = ceil($diff / $this->recurInterval);
445 if ($this->recurCount && $recur >= $this->recurCount) {
446 return false;
447 }
448
449 $recur *= $this->recurInterval;
450 $next = $this->start->add(array('day' => $recur));
451 if ((!$this->hasRecurEnd() ||
452 $next->compareDateTime($this->recurEnd) <= 0) &&
453 $next->compareDateTime($after) >= 0) {
454 return $next;
455 }
456 break;
457
458 case self::RECUR_WEEKLY:
459 if (empty($this->recurData)) {
460 return false;
461 }
462
463 $start_week = Horde_Date_Utils::firstDayOfWeek($this->start->format('W'),
464 $this->start->year);
465 $start_week->timezone = $this->start->timezone;
466 $start_week->hour = $this->start->hour;
467 $start_week->min = $this->start->min;
468 $start_week->sec = $this->start->sec;
469
470 // Make sure we are not at the ISO-8601 first week of year while
471 // still in month 12...OR in the ISO-8601 last week of year while
472 // in month 1 and adjust the year accordingly.
473 $week = $after->format('W');
474 if ($week == 1 && $after->month == 12) {
475 $theYear = $after->year + 1;
476 } elseif ($week >= 52 && $after->month == 1) {
477 $theYear = $after->year - 1;
478 } else {
479 $theYear = $after->year;
480 }
481
482 $after_week = Horde_Date_Utils::firstDayOfWeek($week, $theYear);
483 $after_week->timezone = $this->start->timezone;
484 $after_week_end = clone $after_week;
485 $after_week_end->mday += 7;
486
487 $diff = $start_week->diff($after_week);
488 $interval = $this->recurInterval * 7;
489 $repeats = floor($diff / $interval);
490 if ($diff % $interval < 7) {
491 $recur = $diff;
492 } else {
493 /**
494 * If the after_week is not in the first week interval the
495 * search needs to skip ahead a complete interval. The way it is
496 * calculated here means that an event that occurs every second
497 * week on Monday and Wednesday with the event actually starting
498 * on Tuesday or Wednesday will only have one incidence in the
499 * first week.
500 */
501 $recur = $interval * ($repeats + 1);
502 }
503
504 if ($this->hasRecurCount()) {
505 $recurrences = 0;
506 /**
507 * Correct the number of recurrences by the number of events
508 * that lay between the start of the start week and the
509 * recurrence start.
510 */
511 $next = clone $start_week;
512 while ($next->compareDateTime($this->start) < 0) {
513 if ($this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
514 $recurrences--;
515 }
516 ++$next->mday;
517 }
518 if ($repeats > 0) {
519 $weekdays = $this->recurData;
520 $total_recurrences_per_week = 0;
521 while ($weekdays > 0) {
522 if ($weekdays % 2) {
523 $total_recurrences_per_week++;
524 }
525 $weekdays = ($weekdays - ($weekdays % 2)) / 2;
526 }
527 $recurrences += $total_recurrences_per_week * $repeats;
528 }
529 }
530
531 $next = clone $start_week;
532 $next->mday += $recur;
533 while ($next->compareDateTime($after) < 0 &&
534 $next->compareDateTime($after_week_end) < 0) {
535 if ($this->hasRecurCount()
536 && $next->compareDateTime($after) < 0
537 && $this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
538 $recurrences++;
539 }
540 ++$next->mday;
541 }
542 if ($this->hasRecurCount() &&
543 $recurrences >= $this->recurCount) {
544 return false;
545 }
546 if (!$this->hasRecurEnd() ||
547 $next->compareDateTime($this->recurEnd) <= 0) {
548 if ($next->compareDateTime($after_week_end) >= 0) {
549 return $this->nextRecurrence($after_week_end);
550 }
551 while (!$this->recurOnDay((int)pow(2, $next->dayOfWeek())) &&
552 $next->compareDateTime($after_week_end) < 0) {
553 ++$next->mday;
554 }
555 if (!$this->hasRecurEnd() ||
556 $next->compareDateTime($this->recurEnd) <= 0) {
557 if ($next->compareDateTime($after_week_end) >= 0) {
558 return $this->nextRecurrence($after_week_end);
559 } else {
560 return $next;
561 }
562 }
563 }
564 break;
565
566 case self::RECUR_MONTHLY_DATE:
567 $start = clone $this->start;
568 if ($after->compareDateTime($start) < 0) {
569 $after = clone $start;
570 } else {
571 $after = clone $after;
572 }
573
574 // If we're starting past this month's recurrence of the event,
575 // look in the next month on the day the event recurs.
576 if ($after->mday > $start->mday) {
577 ++$after->month;
578 $after->mday = $start->mday;
579 }
580
581 // Adjust $start to be the first match.
582 $offset = ($after->month - $start->month) + ($after->year - $start->year) * 12;
583 $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
584
585 if ($this->recurCount &&
586 ($offset / $this->recurInterval) >= $this->recurCount) {
587 return false;
588 }
589 $start->month += $offset;
590 $count = $offset / $this->recurInterval;
591
592 do {
593 if ($this->recurCount &&
594 $count++ >= $this->recurCount) {
595 return false;
596 }
597
598 // Bail if we've gone past the end of recurrence.
599 if ($this->hasRecurEnd() &&
600 $this->recurEnd->compareDateTime($start) < 0) {
601 return false;
602 }
603 if ($start->isValid()) {
604 return $start;
605 }
606
607 // If the interval is 12, and the date isn't valid, then we
608 // need to see if February 29th is an option. If not, then the
609 // event will _never_ recur, and we need to stop checking to
610 // avoid an infinite loop.
611 if ($this->recurInterval == 12 && ($start->month != 2 || $start->mday > 29)) {
612 return false;
613 }
614
615 // Add the recurrence interval.
616 $start->month += $this->recurInterval;
617 } while (true);
618
619 break;
620
621 case self::RECUR_MONTHLY_WEEKDAY:
622 // Start with the start date of the event.
623 $estart = clone $this->start;
624
625 // What day of the week, and week of the month, do we recur on?
626 if (isset($this->recurNthDay)) {
627 $nth = $this->recurNthDay;
628 $weekday = log($this->recurData, 2);
629 } else {
630 $nth = ceil($this->start->mday / 7);
631 $weekday = $estart->dayOfWeek();
632 }
633
634 // Adjust $estart to be the first candidate.
635 $offset = ($after->month - $estart->month) + ($after->year - $estart->year) * 12;
636 $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
637
638 // Adjust our working date until it's after $after.
639 $estart->month += $offset - $this->recurInterval;
640
641 $count = $offset / $this->recurInterval;
642 do {
643 if ($this->recurCount &&
644 $count++ >= $this->recurCount) {
645 return false;
646 }
647
648 $estart->month += $this->recurInterval;
649
650 $next = clone $estart;
651 $next->setNthWeekday($weekday, $nth);
652
653 if ($next->compareDateTime($after) < 0) {
654 // We haven't made it past $after yet, try again.
655 continue;
656 }
657 if ($this->hasRecurEnd() &&
658 $next->compareDateTime($this->recurEnd) > 0) {
659 // We've gone past the end of recurrence; we can give up
660 // now.
661 return false;
662 }
663
664 // We have a candidate to return.
665 break;
666 } while (true);
667
668 return $next;
669
670 case self::RECUR_YEARLY_DATE:
671 // Start with the start date of the event.
672 $estart = clone $this->start;
673 $after = clone $after;
674
675 if ($after->month > $estart->month ||
676 ($after->month == $estart->month && $after->mday > $estart->mday)) {
677 ++$after->year;
678 $after->month = $estart->month;
679 $after->mday = $estart->mday;
680 }
681
682 // Seperate case here for February 29th
683 if ($estart->month == 2 && $estart->mday == 29) {
684 while (!Horde_Date_Utils::isLeapYear($after->year)) {
685 ++$after->year;
686 }
687 }
688
689 // Adjust $estart to be the first candidate.
690 $offset = $after->year - $estart->year;
691 if ($offset > 0) {
692 $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
693 $estart->year += $offset;
694 }
695
696 // We've gone past the end of recurrence; give up.
697 if ($this->recurCount &&
698 $offset >= $this->recurCount) {
699 return false;
700 }
701 if ($this->hasRecurEnd() &&
702 $this->recurEnd->compareDateTime($estart) < 0) {
703 return false;
704 }
705
706 return $estart;
707
708 case self::RECUR_YEARLY_DAY:
709 // Check count first.
710 $dayofyear = $this->start->dayOfYear();
711 $count = ($after->year - $this->start->year) / $this->recurInterval + 1;
712 if ($this->recurCount &&
713 ($count > $this->recurCount ||
714 ($count == $this->recurCount &&
715 $after->dayOfYear() > $dayofyear))) {
716 return false;
717 }
718
719 // Start with a rough interval.
720 $estart = clone $this->start;
721 $estart->year += floor($count - 1) * $this->recurInterval;
722
723 // Now add the difference to the required day of year.
724 $estart->mday += $dayofyear - $estart->dayOfYear();
725
726 // Add an interval if the estimation was wrong.
727 if ($estart->compareDate($after) < 0) {
728 $estart->year += $this->recurInterval;
729 $estart->mday += $dayofyear - $estart->dayOfYear();
730 }
731
732 // We've gone past the end of recurrence; give up.
733 if ($this->hasRecurEnd() &&
734 $this->recurEnd->compareDateTime($estart) < 0) {
735 return false;
736 }
737
738 return $estart;
739
740 case self::RECUR_YEARLY_WEEKDAY:
741 // Start with the start date of the event.
742 $estart = clone $this->start;
743
744 // What day of the week, and week of the month, do we recur on?
745 if (isset($this->recurNthDay)) {
746 $nth = $this->recurNthDay;
747 $weekday = log($this->recurData, 2);
748 } else {
749 $nth = ceil($this->start->mday / 7);
750 $weekday = $estart->dayOfWeek();
751 }
752
753 // Adjust $estart to be the first candidate.
754 $offset = floor(($after->year - $estart->year + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
755
756 // Adjust our working date until it's after $after.
757 $estart->year += $offset - $this->recurInterval;
758
759 $count = $offset / $this->recurInterval;
760 do {
761 if ($this->recurCount &&
762 $count++ >= $this->recurCount) {
763 return false;
764 }
765
766 $estart->year += $this->recurInterval;
767
768 $next = clone $estart;
769 $next->setNthWeekday($weekday, $nth);
770
771 if ($next->compareDateTime($after) < 0) {
772 // We haven't made it past $after yet, try again.
773 continue;
774 }
775 if ($this->hasRecurEnd() &&
776 $next->compareDateTime($this->recurEnd) > 0) {
777 // We've gone past the end of recurrence; we can give up
778 // now.
779 return false;
780 }
781
782 // We have a candidate to return.
783 break;
784 } while (true);
785
786 return $next;
787 }
788
789 // fall-back to RDATE properties
790 if (!empty($this->rdates)) {
791 $next = clone $this->start;
792 foreach ($this->rdates as $rdate) {
793 $next->year = $rdate->year;
794 $next->month = $rdate->month;
795 $next->mday = $rdate->mday;
796 if ($next->compareDateTime($after) > 0) {
797 return $next;
798 }
799 }
800 }
801
802 // We didn't find anything, the recurType was bad, or something else
803 // went wrong - return false.
804 return false;
805 }
806
807 /**
808 * Returns whether this event has any date that matches the recurrence
809 * rules and is not an exception.
810 *
811 * @return boolean True if an active recurrence exists.
812 */
813 public function hasActiveRecurrence()
814 {
815 if (!$this->hasRecurEnd()) {
816 return true;
817 }
818
819 $next = $this->nextRecurrence(new Horde_Date($this->start));
820 while (is_object($next)) {
821 if (!$this->hasException($next->year, $next->month, $next->mday) &&
822 !$this->hasCompletion($next->year, $next->month, $next->mday)) {
823 return true;
824 }
825
826 $next = $this->nextRecurrence($next->add(array('day' => 1)));
827 }
828
829 return false;
830 }
831
832 /**
833 * Returns the next active recurrence.
834 *
835 * @param Horde_Date $afterDate Return events after this date.
836 *
837 * @return Horde_Date|boolean The date of the next active
838 * recurrence or false if the event
839 * has no active recurrence after
840 * $afterDate.
841 */
842 public function nextActiveRecurrence($afterDate)
843 {
844 $next = $this->nextRecurrence($afterDate);
845 while (is_object($next)) {
846 if (!$this->hasException($next->year, $next->month, $next->mday) &&
847 !$this->hasCompletion($next->year, $next->month, $next->mday)) {
848 return $next;
849 }
850 $next->mday++;
851 $next = $this->nextRecurrence($next);
852 }
853
854 return false;
855 }
856
857 /**
858 * Adds an absolute recurrence date.
859 *
860 * @param integer $year The year of the instance.
861 * @param integer $month The month of the instance.
862 * @param integer $mday The day of the month of the instance.
863 */
864 public function addRDate($year, $month, $mday)
865 {
866 $this->rdates[] = new Horde_Date($year, $month, $mday);
867 }
868
869 /**
870 * Adds an exception to a recurring event.
871 *
872 * @param integer $year The year of the execption.
873 * @param integer $month The month of the execption.
874 * @param integer $mday The day of the month of the exception.
875 */
876 public function addException($year, $month, $mday)
877 {
878 $this->exceptions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
879 }
880
881 /**
882 * Deletes an exception from a recurring event.
883 *
884 * @param integer $year The year of the execption.
885 * @param integer $month The month of the execption.
886 * @param integer $mday The day of the month of the exception.
887 */
888 public function deleteException($year, $month, $mday)
889 {
890 $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->exceptions);
891 if ($key !== false) {
892 unset($this->exceptions[$key]);
893 }
894 }
895
896 /**
897 * Checks if an exception exists for a given reccurence of an event.
898 *
899 * @param integer $year The year of the reucrance.
900 * @param integer $month The month of the reucrance.
901 * @param integer $mday The day of the month of the reucrance.
902 *
903 * @return boolean True if an exception exists for the given date.
904 */
905 public function hasException($year, $month, $mday)
906 {
907 return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
908 $this->getExceptions());
909 }
910
911 /**
912 * Retrieves all the exceptions for this event.
913 *
914 * @return array Array containing the dates of all the exceptions in
915 * YYYYMMDD form.
916 */
917 public function getExceptions()
918 {
919 return $this->exceptions;
920 }
921
922 /**
923 * Adds a completion to a recurring event.
924 *
925 * @param integer $year The year of the execption.
926 * @param integer $month The month of the execption.
927 * @param integer $mday The day of the month of the completion.
928 */
929 public function addCompletion($year, $month, $mday)
930 {
931 $this->completions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
932 }
933
934 /**
935 * Deletes a completion from a recurring event.
936 *
937 * @param integer $year The year of the execption.
938 * @param integer $month The month of the execption.
939 * @param integer $mday The day of the month of the completion.
940 */
941 public function deleteCompletion($year, $month, $mday)
942 {
943 $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->completions);
944 if ($key !== false) {
945 unset($this->completions[$key]);
946 }
947 }
948
949 /**
950 * Checks if a completion exists for a given reccurence of an event.
951 *
952 * @param integer $year The year of the reucrance.
953 * @param integer $month The month of the recurrance.
954 * @param integer $mday The day of the month of the recurrance.
955 *
956 * @return boolean True if a completion exists for the given date.
957 */
958 public function hasCompletion($year, $month, $mday)
959 {
960 return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
961 $this->getCompletions());
962 }
963
964 /**
965 * Retrieves all the completions for this event.
966 *
967 * @return array Array containing the dates of all the completions in
968 * YYYYMMDD form.
969 */
970 public function getCompletions()
971 {
972 return $this->completions;
973 }
974
975 /**
976 * Parses a vCalendar 1.0 recurrence rule.
977 *
978 * @link http://www.imc.org/pdi/vcal-10.txt
979 * @link http://www.shuchow.com/vCalAddendum.html
980 *
981 * @param string $rrule A vCalendar 1.0 conform RRULE value.
982 */
983 public function fromRRule10($rrule)
984 {
985 $this->reset();
986
987 if (!$rrule) {
988 return;
989 }
990
991 if (!preg_match('/([A-Z]+)(\d+)?(.*)/', $rrule, $matches)) {
992 // No recurrence data - event does not recur.
993 $this->setRecurType(self::RECUR_NONE);
994 }
995
996 // Always default the recurInterval to 1.
997 $this->setRecurInterval(!empty($matches[2]) ? $matches[2] : 1);
998
999 $remainder = trim($matches[3]);
1000
1001 switch ($matches[1]) {
1002 case 'D':
1003 $this->setRecurType(self::RECUR_DAILY);
1004 break;
1005
1006 case 'W':
1007 $this->setRecurType(self::RECUR_WEEKLY);
1008 if (!empty($remainder)) {
1009 $mask = 0;
1010 while (preg_match('/^ ?[A-Z]{2} ?/', $remainder, $matches)) {
1011 $day = trim($matches[0]);
1012 $remainder = substr($remainder, strlen($matches[0]));
1013 $mask |= $maskdays[$day];
1014 }
1015 $this->setRecurOnDay($mask);
1016 } else {
1017 // Recur on the day of the week of the original recurrence.
1018 $maskdays = array(
1019 Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
1020 Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
1021 Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
1022 Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
1023 Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
1024 Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
1025 Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY,
1026 );
1027 $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
1028 }
1029 break;
1030
1031 case 'MP':
1032 $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
1033 break;
1034
1035 case 'MD':
1036 $this->setRecurType(self::RECUR_MONTHLY_DATE);
1037 break;
1038
1039 case 'YM':
1040 $this->setRecurType(self::RECUR_YEARLY_DATE);
1041 break;
1042
1043 case 'YD':
1044 $this->setRecurType(self::RECUR_YEARLY_DAY);
1045 break;
1046 }
1047
1048 // We don't support modifiers at the moment, strip them.
1049 while ($remainder && !preg_match('/^(#\d+|\d{8})($| |T\d{6})/', $remainder)) {
1050 $remainder = substr($remainder, 1);
1051 }
1052 if (!empty($remainder)) {
1053 if (strpos($remainder, '#') === 0) {
1054 $this->setRecurCount(substr($remainder, 1));
1055 } else {
1056 list($year, $month, $mday) = sscanf($remainder, '%04d%02d%02d');
1057 $this->setRecurEnd(new Horde_Date(array('year' => $year,
1058 'month' => $month,
1059 'mday' => $mday,
1060 'hour' => 23,
1061 'min' => 59,
1062 'sec' => 59)));
1063 }
1064 }
1065 }
1066
1067 /**
1068 * Creates a vCalendar 1.0 recurrence rule.
1069 *
1070 * @link http://www.imc.org/pdi/vcal-10.txt
1071 * @link http://www.shuchow.com/vCalAddendum.html
1072 *
1073 * @param Horde_Icalendar $calendar A Horde_Icalendar object instance.
1074 *
1075 * @return string A vCalendar 1.0 conform RRULE value.
1076 */
1077 public function toRRule10($calendar)
1078 {
1079 switch ($this->recurType) {
1080 case self::RECUR_NONE:
1081 return '';
1082
1083 case self::RECUR_DAILY:
1084 $rrule = 'D' . $this->recurInterval;
1085 break;
1086
1087 case self::RECUR_WEEKLY:
1088 $rrule = 'W' . $this->recurInterval;
1089 $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
1090
1091 for ($i = 0; $i <= 7; ++$i) {
1092 if ($this->recurOnDay(pow(2, $i))) {
1093 $rrule .= ' ' . $vcaldays[$i];
1094 }
1095 }
1096 break;
1097
1098 case self::RECUR_MONTHLY_DATE:
1099 $rrule = 'MD' . $this->recurInterval . ' ' . trim($this->start->mday);
1100 break;
1101
1102 case self::RECUR_MONTHLY_WEEKDAY:
1103 $nth_weekday = (int)($this->start->mday / 7);
1104 if (($this->start->mday % 7) > 0) {
1105 $nth_weekday++;
1106 }
1107
1108 $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
1109 $rrule = 'MP' . $this->recurInterval . ' ' . $nth_weekday . '+ ' . $vcaldays[$this->start->dayOfWeek()];
1110
1111 break;
1112
1113 case self::RECUR_YEARLY_DATE:
1114 $rrule = 'YM' . $this->recurInterval . ' ' . trim($this->start->month);
1115 break;
1116
1117 case self::RECUR_YEARLY_DAY:
1118 $rrule = 'YD' . $this->recurInterval . ' ' . $this->start->dayOfYear();
1119 break;
1120
1121 default:
1122 return '';
1123 }
1124
1125 if ($this->hasRecurEnd()) {
1126 $recurEnd = clone $this->recurEnd;
1127 return $rrule . ' ' . $calendar->_exportDateTime($recurEnd);
1128 }
1129
1130 return $rrule . ' #' . (int)$this->getRecurCount();
1131 }
1132
1133 /**
1134 * Parses an iCalendar 2.0 recurrence rule.
1135 *
1136 * @link http://rfc.net/rfc2445.html#s4.3.10
1137 * @link http://rfc.net/rfc2445.html#s4.8.5
1138 * @link http://www.shuchow.com/vCalAddendum.html
1139 *
1140 * @param string $rrule An iCalendar 2.0 conform RRULE value.
1141 */
1142 public function fromRRule20($rrule)
1143 {
1144 $this->reset();
1145
1146 // Parse the recurrence rule into keys and values.
1147 $rdata = array();
1148 $parts = explode(';', $rrule);
1149 foreach ($parts as $part) {
1150 list($key, $value) = explode('=', $part, 2);
1151 $rdata[strtoupper($key)] = $value;
1152 }
1153
1154 if (isset($rdata['FREQ'])) {
1155 // Always default the recurInterval to 1.
1156 $this->setRecurInterval(isset($rdata['INTERVAL']) ? $rdata['INTERVAL'] : 1);
1157
1158 $maskdays = array(
1159 'SU' => Horde_Date::MASK_SUNDAY,
1160 'MO' => Horde_Date::MASK_MONDAY,
1161 'TU' => Horde_Date::MASK_TUESDAY,
1162 'WE' => Horde_Date::MASK_WEDNESDAY,
1163 'TH' => Horde_Date::MASK_THURSDAY,
1164 'FR' => Horde_Date::MASK_FRIDAY,
1165 'SA' => Horde_Date::MASK_SATURDAY,
1166 );
1167
1168 switch (strtoupper($rdata['FREQ'])) {
1169 case 'DAILY':
1170 $this->setRecurType(self::RECUR_DAILY);
1171 break;
1172
1173 case 'WEEKLY':
1174 $this->setRecurType(self::RECUR_WEEKLY);
1175 if (isset($rdata['BYDAY'])) {
1176 $days = explode(',', $rdata['BYDAY']);
1177 $mask = 0;
1178 foreach ($days as $day) {
1179 $mask |= $maskdays[$day];
1180 }
1181 $this->setRecurOnDay($mask);
1182 } else {
1183 // Recur on the day of the week of the original
1184 // recurrence.
1185 $maskdays = array(
1186 Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
1187 Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
1188 Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
1189 Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
1190 Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
1191 Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
1192 Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY);
1193 $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
1194 }
1195 break;
1196
1197 case 'MONTHLY':
1198 if (isset($rdata['BYDAY'])) {
1199 $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
1200 if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
1201 $this->setRecurOnDay($maskdays[$m[2]]);
1202 $this->setRecurNthWeekday($m[1]);
1203 }
1204 } else {
1205 $this->setRecurType(self::RECUR_MONTHLY_DATE);
1206 }
1207 break;
1208
1209 case 'YEARLY':
1210 if (isset($rdata['BYYEARDAY'])) {
1211 $this->setRecurType(self::RECUR_YEARLY_DAY);
1212 } elseif (isset($rdata['BYDAY'])) {
1213 $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
1214 if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
1215 $this->setRecurOnDay($maskdays[$m[2]]);
1216 $this->setRecurNthWeekday($m[1]);
1217 }
1218 if ($rdata['BYMONTH']) {
1219 $months = explode(',', $rdata['BYMONTH']);
1220 $this->setRecurByMonth($months);
1221 }
1222 } else {
1223 $this->setRecurType(self::RECUR_YEARLY_DATE);
1224 }
1225 break;
1226 }
1227
1228 if (isset($rdata['UNTIL'])) {
1229 list($year, $month, $mday) = sscanf($rdata['UNTIL'],
1230 '%04d%02d%02d');
1231 $this->setRecurEnd(new Horde_Date(array('year' => $year,
1232 'month' => $month,
1233 'mday' => $mday,
1234 'hour' => 23,
1235 'min' => 59,
1236 'sec' => 59)));
1237 }
1238 if (isset($rdata['COUNT'])) {
1239 $this->setRecurCount($rdata['COUNT']);
1240 }
1241 } else {
1242 // No recurrence data - event does not recur.
1243 $this->setRecurType(self::RECUR_NONE);
1244 }
1245 }
1246
1247 /**
1248 * Creates an iCalendar 2.0 recurrence rule.
1249 *
1250 * @link http://rfc.net/rfc2445.html#s4.3.10
1251 * @link http://rfc.net/rfc2445.html#s4.8.5
1252 * @link http://www.shuchow.com/vCalAddendum.html
1253 *
1254 * @param Horde_Icalendar $calendar A Horde_Icalendar object instance.
1255 *
1256 * @return string An iCalendar 2.0 conform RRULE value.
1257 */
1258 public function toRRule20($calendar)
1259 {
1260 switch ($this->recurType) {
1261 case self::RECUR_NONE:
1262 return '';
1263
1264 case self::RECUR_DAILY:
1265 $rrule = 'FREQ=DAILY;INTERVAL=' . $this->recurInterval;
1266 break;
1267
1268 case self::RECUR_WEEKLY:
1269 $rrule = 'FREQ=WEEKLY;INTERVAL=' . $this->recurInterval . ';BYDAY=';
1270 $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
1271
1272 for ($i = $flag = 0; $i <= 7; ++$i) {
1273 if ($this->recurOnDay(pow(2, $i))) {
1274 if ($flag) {
1275 $rrule .= ',';
1276 }
1277 $rrule .= $vcaldays[$i];
1278 $flag = true;
1279 }
1280 }
1281 break;
1282
1283 case self::RECUR_MONTHLY_DATE:
1284 $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval;
1285 break;
1286
1287 case self::RECUR_MONTHLY_WEEKDAY:
1288 if (isset($this->recurNthDay)) {
1289 $nth_weekday = $this->recurNthDay;
1290 $day_of_week = log($this->recurData, 2);
1291 } else {
1292 $day_of_week = $this->start->dayOfWeek();
1293 $nth_weekday = (int)($this->start->mday / 7);
1294 if (($this->start->mday % 7) > 0) {
1295 $nth_weekday++;
1296 }
1297 }
1298 $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
1299 $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval
1300 . ';BYDAY=' . $nth_weekday . $vcaldays[$day_of_week];
1301 break;
1302
1303 case self::RECUR_YEARLY_DATE:
1304 $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval;
1305 break;
1306
1307 case self::RECUR_YEARLY_DAY:
1308 $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
1309 . ';BYYEARDAY=' . $this->start->dayOfYear();
1310 break;
1311
1312 case self::RECUR_YEARLY_WEEKDAY:
1313 if (isset($this->recurNthDay)) {
1314 $nth_weekday = $this->recurNthDay;
1315 $day_of_week = log($this->recurData, 2);
1316 } else {
1317 $day_of_week = $this->start->dayOfWeek();
1318 $nth_weekday = (int)($this->start->mday / 7);
1319 if (($this->start->mday % 7) > 0) {
1320 $nth_weekday++;
1321 }
1322 }
1323 $months = !empty($this->recurMonths) ? join(',', $this->recurMonths) : $this->start->month;
1324 $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
1325 $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
1326 . ';BYDAY='
1327 . $nth_weekday
1328 . $vcaldays[$day_of_week]
1329 . ';BYMONTH=' . $this->start->month;
1330 break;
1331 }
1332
1333 if ($this->hasRecurEnd()) {
1334 $recurEnd = clone $this->recurEnd;
1335 $rrule .= ';UNTIL=' . $calendar->_exportDateTime($recurEnd);
1336 }
1337 if ($count = $this->getRecurCount()) {
1338 $rrule .= ';COUNT=' . $count;
1339 }
1340 return $rrule;
1341 }
1342
1343 /**
1344 * Parses the recurrence data from a hash.
1345 *
1346 * @param array $hash The hash to convert.
1347 *
1348 * @return boolean True if the hash seemed valid, false otherwise.
1349 */
1350 public function fromHash($hash)
1351 {
1352 $this->reset();
1353
1354 if (!isset($hash['interval']) || !isset($hash['cycle'])) {
1355 $this->setRecurType(self::RECUR_NONE);
1356 return false;
1357 }
1358
1359 $this->setRecurInterval((int)$hash['interval']);
1360
1361 $month2number = array(
1362 'january' => 1,
1363 'february' => 2,
1364 'march' => 3,
1365 'april' => 4,
1366 'may' => 5,
1367 'june' => 6,
1368 'july' => 7,
1369 'august' => 8,
1370 'september' => 9,
1371 'october' => 10,
1372 'november' => 11,
1373 'december' => 12,
1374 );
1375
1376 $parse_day = false;
1377 $set_daymask = false;
1378 $update_month = false;
1379 $update_daynumber = false;
1380 $update_weekday = false;
1381 $nth_weekday = -1;
1382
1383 switch ($hash['cycle']) {
1384 case 'daily':
1385 $this->setRecurType(self::RECUR_DAILY);
1386 break;
1387
1388 case 'weekly':
1389 $this->setRecurType(self::RECUR_WEEKLY);
1390 $parse_day = true;
1391 $set_daymask = true;
1392 break;
1393
1394 case 'monthly':
1395 if (!isset($hash['daynumber'])) {
1396 $this->setRecurType(self::RECUR_NONE);
1397 return false;
1398 }
1399
1400 switch ($hash['type']) {
1401 case 'daynumber':
1402 $this->setRecurType(self::RECUR_MONTHLY_DATE);
1403 $update_daynumber = true;
1404 break;
1405
1406 case 'weekday':
1407 $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
1408 $this->setRecurNthWeekday($hash['daynumber']);
1409 $parse_day = true;
1410 $set_daymask = true;
1411 break;
1412 }
1413 break;
1414
1415 case 'yearly':
1416 if (!isset($hash['type'])) {
1417 $this->setRecurType(self::RECUR_NONE);
1418 return false;
1419 }
1420
1421 switch ($hash['type']) {
1422 case 'monthday':
1423 $this->setRecurType(self::RECUR_YEARLY_DATE);
1424 $update_month = true;
1425 $update_daynumber = true;
1426 break;
1427
1428 case 'yearday':
1429 if (!isset($hash['month'])) {
1430 $this->setRecurType(self::RECUR_NONE);
1431 return false;
1432 }
1433
1434 $this->setRecurType(self::RECUR_YEARLY_DAY);
1435 // Start counting days in January.
1436 $hash['month'] = 'january';
1437 $update_month = true;
1438 $update_daynumber = true;
1439 break;
1440
1441 case 'weekday':
1442 if (!isset($hash['daynumber'])) {
1443 $this->setRecurType(self::RECUR_NONE);
1444 return false;
1445 }
1446
1447 $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
1448 $this->setRecurNthWeekday($hash['daynumber']);
1449 $parse_day = true;
1450 $set_daymask = true;
1451
1452 if ($hash['month'] && isset($month2number[$hash['month']])) {
1453 $this->setRecurByMonth($month2number[$hash['month']]);
1454 }
1455 break;
1456 }
1457 }
1458
1459 if (isset($hash['range-type']) && isset($hash['range'])) {
1460 switch ($hash['range-type']) {
1461 case 'number':
1462 $this->setRecurCount((int)$hash['range']);
1463 break;
1464
1465 case 'date':
1466 $recur_end = new Horde_Date($hash['range']);
1467 $recur_end->hour = 23;
1468 $recur_end->min = 59;
1469 $recur_end->sec = 59;
1470 $this->setRecurEnd($recur_end);
1471 break;
1472 }
1473 }
1474
1475 // Need to parse <day>?
1476 $last_found_day = -1;
1477 if ($parse_day) {
1478 if (!isset($hash['day'])) {
1479 $this->setRecurType(self::RECUR_NONE);
1480 return false;
1481 }
1482
1483 $mask = 0;
1484 $bits = array(
1485 'monday' => Horde_Date::MASK_MONDAY,
1486 'tuesday' => Horde_Date::MASK_TUESDAY,
1487 'wednesday' => Horde_Date::MASK_WEDNESDAY,
1488 'thursday' => Horde_Date::MASK_THURSDAY,
1489 'friday' => Horde_Date::MASK_FRIDAY,
1490 'saturday' => Horde_Date::MASK_SATURDAY,
1491 'sunday' => Horde_Date::MASK_SUNDAY,
1492 );
1493 $days = array(
1494 'monday' => Horde_Date::DATE_MONDAY,
1495 'tuesday' => Horde_Date::DATE_TUESDAY,
1496 'wednesday' => Horde_Date::DATE_WEDNESDAY,
1497 'thursday' => Horde_Date::DATE_THURSDAY,
1498 'friday' => Horde_Date::DATE_FRIDAY,
1499 'saturday' => Horde_Date::DATE_SATURDAY,
1500 'sunday' => Horde_Date::DATE_SUNDAY,
1501 );
1502
1503 foreach ($hash['day'] as $day) {
1504 // Validity check.
1505 if (empty($day) || !isset($bits[$day])) {
1506 continue;
1507 }
1508
1509 $mask |= $bits[$day];
1510 $last_found_day = $days[$day];
1511 }
1512
1513 if ($set_daymask) {
1514 $this->setRecurOnDay($mask);
1515 }
1516 }
1517
1518 if ($update_month || $update_daynumber || $update_weekday) {
1519 if ($update_month) {
1520 if (isset($month2number[$hash['month']])) {
1521 $this->start->month = $month2number[$hash['month']];
1522 }
1523 }
1524
1525 if ($update_daynumber) {
1526 if (!isset($hash['daynumber'])) {
1527 $this->setRecurType(self::RECUR_NONE);
1528 return false;
1529 }
1530
1531 $this->start->mday = $hash['daynumber'];
1532 }
1533
1534 if ($update_weekday) {
1535 $this->setNthWeekday($nth_weekday);
1536 }
1537 }
1538
1539 // Exceptions.
1540 if (isset($hash['exceptions'])) {
1541 $this->exceptions = $hash['exceptions'];
1542 }
1543
1544 if (isset($hash['completions'])) {
1545 $this->completions = $hash['completions'];
1546 }
1547
1548 return true;
1549 }
1550
1551 /**
1552 * Export this object into a hash.
1553 *
1554 * @return array The recurrence hash.
1555 */
1556 public function toHash()
1557 {
1558 if ($this->getRecurType() == self::RECUR_NONE) {
1559 return array();
1560 }
1561
1562 $day2number = array(
1563 0 => 'sunday',
1564 1 => 'monday',
1565 2 => 'tuesday',
1566 3 => 'wednesday',
1567 4 => 'thursday',
1568 5 => 'friday',
1569 6 => 'saturday'
1570 );
1571 $month2number = array(
1572 1 => 'january',
1573 2 => 'february',
1574 3 => 'march',
1575 4 => 'april',
1576 5 => 'may',
1577 6 => 'june',
1578 7 => 'july',
1579 8 => 'august',
1580 9 => 'september',
1581 10 => 'october',
1582 11 => 'november',
1583 12 => 'december'
1584 );
1585
1586 $hash = array('interval' => $this->getRecurInterval());
1587 $start = $this->getRecurStart();
1588
1589 switch ($this->getRecurType()) {
1590 case self::RECUR_DAILY:
1591 $hash['cycle'] = 'daily';
1592 break;
1593
1594 case self::RECUR_WEEKLY:
1595 $hash['cycle'] = 'weekly';
1596 $bits = array(
1597 'monday' => Horde_Date::MASK_MONDAY,
1598 'tuesday' => Horde_Date::MASK_TUESDAY,
1599 'wednesday' => Horde_Date::MASK_WEDNESDAY,
1600 'thursday' => Horde_Date::MASK_THURSDAY,
1601 'friday' => Horde_Date::MASK_FRIDAY,
1602 'saturday' => Horde_Date::MASK_SATURDAY,
1603 'sunday' => Horde_Date::MASK_SUNDAY,
1604 );
1605 $days = array();
1606 foreach ($bits as $name => $bit) {
1607 if ($this->recurOnDay($bit)) {
1608 $days[] = $name;
1609 }
1610 }
1611 $hash['day'] = $days;
1612 break;
1613
1614 case self::RECUR_MONTHLY_DATE:
1615 $hash['cycle'] = 'monthly';
1616 $hash['type'] = 'daynumber';
1617 $hash['daynumber'] = $start->mday;
1618 break;
1619
1620 case self::RECUR_MONTHLY_WEEKDAY:
1621 $hash['cycle'] = 'monthly';
1622 $hash['type'] = 'weekday';
1623 $hash['daynumber'] = $start->weekOfMonth();
1624 $hash['day'] = array ($day2number[$start->dayOfWeek()]);
1625 break;
1626
1627 case self::RECUR_YEARLY_DATE:
1628 $hash['cycle'] = 'yearly';
1629 $hash['type'] = 'monthday';
1630 $hash['daynumber'] = $start->mday;
1631 $hash['month'] = $month2number[$start->month];
1632 break;
1633
1634 case self::RECUR_YEARLY_DAY:
1635 $hash['cycle'] = 'yearly';
1636 $hash['type'] = 'yearday';
1637 $hash['daynumber'] = $start->dayOfYear();
1638 break;
1639
1640 case self::RECUR_YEARLY_WEEKDAY:
1641 $hash['cycle'] = 'yearly';
1642 $hash['type'] = 'weekday';
1643 $hash['daynumber'] = $start->weekOfMonth();
1644 $hash['day'] = array ($day2number[$start->dayOfWeek()]);
1645 $hash['month'] = $month2number[$start->month];
1646 }
1647
1648 if ($this->hasRecurCount()) {
1649 $hash['range-type'] = 'number';
1650 $hash['range'] = $this->getRecurCount();
1651 } elseif ($this->hasRecurEnd()) {
1652 $date = $this->getRecurEnd();
1653 $hash['range-type'] = 'date';
1654 $hash['range'] = $date->datestamp();
1655 } else {
1656 $hash['range-type'] = 'none';
1657 $hash['range'] = '';
1658 }
1659
1660 // Recurrence exceptions
1661 $hash['exceptions'] = $this->exceptions;
1662 $hash['completions'] = $this->completions;
1663
1664 return $hash;
1665 }
1666
1667 /**
1668 * Returns a simple object suitable for json transport representing this
1669 * object.
1670 *
1671 * Possible properties are:
1672 * - t: type
1673 * - i: interval
1674 * - e: end date
1675 * - c: count
1676 * - d: data
1677 * - co: completions
1678 * - ex: exceptions
1679 *
1680 * @return object A simple object.
1681 */
1682 public function toJson()
1683 {
1684 $json = new stdClass;
1685 $json->t = $this->recurType;
1686 $json->i = $this->recurInterval;
1687 if ($this->hasRecurEnd()) {
1688 $json->e = $this->recurEnd->toJson();
1689 }
1690 if ($this->recurCount) {
1691 $json->c = $this->recurCount;
1692 }
1693 if ($this->recurData) {
1694 $json->d = $this->recurData;
1695 }
1696 if ($this->completions) {
1697 $json->co = $this->completions;
1698 }
1699 if ($this->exceptions) {
1700 $json->ex = $this->exceptions;
1701 }
1702 return $json;
1703 }
1704
1705 }