plugins/calendar plugins/libkolab
Thomas Brüderli
bruederli at kolabsys.com
Tue Jul 3 08:28:46 CEST 2012
plugins/calendar/drivers/kolab/kolab_calendar.php | 7
plugins/calendar/lib/Horde_Date_Recurrence.php | 3
plugins/calendar/lib/Horde_iCalendar.php | 3
plugins/libkolab/bin/get_horde_date.sh | 38
plugins/libkolab/lib/Horde_Date.php | 1112 +++++++++++++
plugins/libkolab/lib/Horde_Date_Recurrence.php | 1768 ++++++++++++++++++++++
plugins/libkolab/lib/kolab_date_recurrence.php | 105 +
7 files changed, 3029 insertions(+), 7 deletions(-)
New commits:
commit 1142a8088600c19f0086eaf68c5fa4a49e56d61d
Author: Thomas Bruederli <thomas at roundcube.net>
Date: Tue Jul 3 08:25:55 2012 +0200
Move classes for recurring events/tasks computation to libkolab
diff --git a/plugins/calendar/drivers/kolab/kolab_calendar.php b/plugins/calendar/drivers/kolab/kolab_calendar.php
index 9e9825e..669b28e 100644
--- a/plugins/calendar/drivers/kolab/kolab_calendar.php
+++ b/plugins/calendar/drivers/kolab/kolab_calendar.php
@@ -360,7 +360,7 @@ class kolab_calendar
raise_error(array(
'code' => 600, 'type' => 'php',
'file' => __FILE__, 'line' => __LINE__,
- 'message' => "Error undeleting a contact object $uid from the Kolab server"),
+ 'message' => "Error undeleting the event object $uid from the Kolab server"),
true, false);
}
@@ -373,10 +373,7 @@ class kolab_calendar
*/
public function _get_recurring_events($event, $start, $end, $event_id = null)
{
- // include library class
- require_once($this->cal->home . '/lib/calendar_recurrence.php');
-
- $recurrence = new calendar_recurrence($this->cal, $event);
+ $recurrence = new kolab_date_recurrence($event);
$events = array();
$duration = $event['end'] - $event['start'];
diff --git a/plugins/calendar/lib/Horde_Date_Recurrence.php b/plugins/calendar/lib/Horde_Date_Recurrence.php
index 379d54a..829a6b8 100644
--- a/plugins/calendar/lib/Horde_Date_Recurrence.php
+++ b/plugins/calendar/lib/Horde_Date_Recurrence.php
@@ -5,7 +5,8 @@
* PEAR/Date/Calc.php, Horde/Date/Recurrence.php
*/
-require_once(dirname(__FILE__) . '/Horde_Date.php');
+if (!class_exists('Horde_Date'))
+ require_once(dirname(__FILE__) . '/Horde_Date.php');
// {{{ Header
diff --git a/plugins/calendar/lib/Horde_iCalendar.php b/plugins/calendar/lib/Horde_iCalendar.php
index f898170..a3ff79d 100644
--- a/plugins/calendar/lib/Horde_iCalendar.php
+++ b/plugins/calendar/lib/Horde_iCalendar.php
@@ -5,7 +5,8 @@
* Horde/String.php, Horde/iCalendar.php, Horde/iCalendar/*.php
*/
-require_once(dirname(__FILE__) . '/Horde_Date.php');
+if (!class_exists('Horde_Date'))
+ require_once(dirname(__FILE__) . '/Horde_Date.php');
$GLOBALS['_HORDE_STRING_CHARSET'] = 'iso-8859-1';
diff --git a/plugins/libkolab/bin/get_horde_date.sh b/plugins/libkolab/bin/get_horde_date.sh
new file mode 100755
index 0000000..c75b7fd
--- /dev/null
+++ b/plugins/libkolab/bin/get_horde_date.sh
@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# Copy Horde_Date_Recurrence classes and dependencies to stdout.
+# This will create a standalone copy of the classes requried for date recurrence computation.
+
+SRCDIR=$1
+
+if [ ! -d "$SRCDIR" ]; then
+ echo "Usage: get_horde_date.sh SRCDIR"
+ echo "Please enter a valid source directory of the Horde libs"
+ exit 1
+fi
+
+echo "<?php
+
+/**
+ * This is a concatenated copy of the following files:
+ * Horde/Date/Utils.php, Horde/Date/Recurrence.php
+ * Pull the latest version of these files from the PEAR channel of the Horde
+ * project at http://pear.horde.org by installing the Horde_Date package.
+ */
+
+if (!class_exists('Horde_Date'))
+ require_once(dirname(__FILE__) . '/Horde_Date.php');
+
+// minimal required implementation of Horde_Date_Translation to avoid a huge dependency nightmare
+class Horde_Date_Translation
+{
+ function t(\$arg) { return \$arg; }
+ function ngettext(\$sing, \$plur, \$num) { return (\$num > 1 ? \$plur : \$sing); }
+}
+"
+
+sed 's/<?php//; s/?>//' $SRCDIR/Date/Utils.php
+echo "\n"
+sed 's/<?php//; s/?>//' $SRCDIR/Date/Recurrence.php | sed -E "s/Horde_String::/strto/"
+echo "\n"
+
diff --git a/plugins/libkolab/lib/Horde_Date.php b/plugins/libkolab/lib/Horde_Date.php
new file mode 100644
index 0000000..4ddd9d5
--- /dev/null
+++ b/plugins/libkolab/lib/Horde_Date.php
@@ -0,0 +1,1112 @@
+<?php
+/**
+ * Horde Date wrapper/logic class, including some calculation
+ * functions.
+ *
+ * @category Horde
+ * @package Date
+ *
+ * @TODO in format():
+ * http://php.net/intldateformatter
+ *
+ * @TODO on timezones:
+ * http://trac.agavi.org/ticket/1008
+ * http://trac.agavi.org/changeset/3659
+ *
+ * @TODO on switching to PHP::DateTime:
+ * The only thing ever stored in the database *IS* Unix timestamps. Doing
+ * anything other than that is unmanageable, yet some frameworks use 'server
+ * based' times in their systems, simply because they do not bother with
+ * daylight saving and only 'serve' one timezone!
+ *
+ * The second you have to manage 'real' time across timezones then daylight
+ * saving becomes essential, BUT only on the display side! Since the browser
+ * only provides a time offset, this is useless and to be honest should simply
+ * be ignored ( until it is upgraded to provide the correct information ;)
+ * ). So we need a 'display' function that takes a simple numeric epoch, and a
+ * separate timezone id into which the epoch is to be 'converted'. My W3C
+ * mapping works simply because ADOdb then converts that to it's own simple
+ * offset abbreviation - in my case GMT or BST. As long as DateTime passes the
+ * full 64 bit number the date range from 100AD is also preserved ( and
+ * further back if 2 digit years are disabled ). If I want to display the
+ * 'real' timezone with this 'time' then I just add it in place of ADOdb's
+ * 'timezone'. I am tempted to simply adjust the ADOdb class to take a
+ * timezone in place of the simple GMT switch it currently uses.
+ *
+ * The return path is just the reverse and simply needs to take the client
+ * display offset off prior to storage of the UTC epoch. SO we use
+ * DateTimeZone to get an offset value for the clients timezone and simply add
+ * or subtract this from a timezone agnostic display on the client end when
+ * entering new times.
+ *
+ *
+ * It's not really feasible to store dates in specific timezone, as most
+ * national/local timezones support DST - and that is a pain to support, as
+ * eg. sorting breaks when some timestamps get repeated. That's why it's
+ * usually better to store datetimes as either UTC datetime or plain unix
+ * timestamp. I usually go with the former - using database datetime type.
+ */
+
+/**
+ * @category Horde
+ * @package Date
+ */
+class Horde_Date
+{
+ const DATE_SUNDAY = 0;
+ const DATE_MONDAY = 1;
+ const DATE_TUESDAY = 2;
+ const DATE_WEDNESDAY = 3;
+ const DATE_THURSDAY = 4;
+ const DATE_FRIDAY = 5;
+ const DATE_SATURDAY = 6;
+
+ const MASK_SUNDAY = 1;
+ const MASK_MONDAY = 2;
+ const MASK_TUESDAY = 4;
+ const MASK_WEDNESDAY = 8;
+ const MASK_THURSDAY = 16;
+ const MASK_FRIDAY = 32;
+ const MASK_SATURDAY = 64;
+ const MASK_WEEKDAYS = 62;
+ const MASK_WEEKEND = 65;
+ const MASK_ALLDAYS = 127;
+
+ const MASK_SECOND = 1;
+ const MASK_MINUTE = 2;
+ const MASK_HOUR = 4;
+ const MASK_DAY = 8;
+ const MASK_MONTH = 16;
+ const MASK_YEAR = 32;
+ const MASK_ALLPARTS = 63;
+
+ const DATE_DEFAULT = 'Y-m-d H:i:s';
+ const DATE_JSON = 'Y-m-d\TH:i:s';
+
+ /**
+ * Year
+ *
+ * @var integer
+ */
+ protected $_year;
+
+ /**
+ * Month
+ *
+ * @var integer
+ */
+ protected $_month;
+
+ /**
+ * Day
+ *
+ * @var integer
+ */
+ protected $_mday;
+
+ /**
+ * Hour
+ *
+ * @var integer
+ */
+ protected $_hour = 0;
+
+ /**
+ * Minute
+ *
+ * @var integer
+ */
+ protected $_min = 0;
+
+ /**
+ * Second
+ *
+ * @var integer
+ */
+ protected $_sec = 0;
+
+ /**
+ * String representation of the date's timezone.
+ *
+ * @var string
+ */
+ protected $_timezone;
+
+ /**
+ * Default format for __toString()
+ *
+ * @var string
+ */
+ protected $_defaultFormat = self::DATE_DEFAULT;
+
+ /**
+ * Default specs that are always supported.
+ * @var string
+ */
+ protected static $_defaultSpecs = '%CdDeHImMnRStTyY';
+
+ /**
+ * Internally supported strftime() specifiers.
+ * @var string
+ */
+ protected static $_supportedSpecs = '';
+
+ /**
+ * Map of required correction masks.
+ *
+ * @see __set()
+ *
+ * @var array
+ */
+ protected static $_corrections = array(
+ 'year' => self::MASK_YEAR,
+ 'month' => self::MASK_MONTH,
+ 'mday' => self::MASK_DAY,
+ 'hour' => self::MASK_HOUR,
+ 'min' => self::MASK_MINUTE,
+ 'sec' => self::MASK_SECOND,
+ );
+
+ protected $_formatCache = array();
+
+ /**
+ * Builds a new date object. If $date contains date parts, use them to
+ * initialize the object.
+ *
+ * Recognized formats:
+ * - arrays with keys 'year', 'month', 'mday', 'day'
+ * 'hour', 'min', 'minute', 'sec'
+ * - objects with properties 'year', 'month', 'mday', 'hour', 'min', 'sec'
+ * - yyyy-mm-dd hh:mm:ss
+ * - yyyymmddhhmmss
+ * - yyyymmddThhmmssZ
+ * - yyyymmdd (might conflict with unix timestamps between 31 Oct 1966 and
+ * 03 Mar 1973)
+ * - unix timestamps
+ * - anything parsed by strtotime()/DateTime.
+ *
+ * @throws Horde_Date_Exception
+ */
+ public function __construct($date = null, $timezone = null)
+ {
+ if (!self::$_supportedSpecs) {
+ self::$_supportedSpecs = self::$_defaultSpecs;
+ if (function_exists('nl_langinfo')) {
+ self::$_supportedSpecs .= 'bBpxX';
+ }
+ }
+
+ if (func_num_args() > 2) {
+ // Handle args in order: year month day hour min sec tz
+ $this->_initializeFromArgs(func_get_args());
+ return;
+ }
+
+ $this->_initializeTimezone($timezone);
+
+ if (is_null($date)) {
+ return;
+ }
+
+ if (is_string($date)) {
+ $date = trim($date, '"');
+ }
+
+ if (is_object($date)) {
+ $this->_initializeFromObject($date);
+ } elseif (is_array($date)) {
+ $this->_initializeFromArray($date);
+ } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})T? ?(\d{2}):?(\d{2}):?(\d{2})(?:\.\d+)?(Z?)$/', $date, $parts)) {
+ $this->_year = (int)$parts[1];
+ $this->_month = (int)$parts[2];
+ $this->_mday = (int)$parts[3];
+ $this->_hour = (int)$parts[4];
+ $this->_min = (int)$parts[5];
+ $this->_sec = (int)$parts[6];
+ if ($parts[7]) {
+ $this->_initializeTimezone('UTC');
+ }
+ } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})$/', $date, $parts) &&
+ $parts[2] > 0 && $parts[2] <= 12 &&
+ $parts[3] > 0 && $parts[3] <= 31) {
+ $this->_year = (int)$parts[1];
+ $this->_month = (int)$parts[2];
+ $this->_mday = (int)$parts[3];
+ $this->_hour = $this->_min = $this->_sec = 0;
+ } elseif ((string)(int)$date == $date) {
+ // Try as a timestamp.
+ $parts = @getdate($date);
+ if ($parts) {
+ $this->_year = $parts['year'];
+ $this->_month = $parts['mon'];
+ $this->_mday = $parts['mday'];
+ $this->_hour = $parts['hours'];
+ $this->_min = $parts['minutes'];
+ $this->_sec = $parts['seconds'];
+ }
+ } else {
+ // Use date_create() so we can catch errors with PHP 5.2. Use
+ // "new DateTime() once we require 5.3.
+ $parsed = date_create($date);
+ if (!$parsed) {
+ throw new Horde_Date_Exception(sprintf(Horde_Date_Translation::t("Failed to parse time string (%s)"), $date));
+ }
+ $parsed->setTimezone(new DateTimeZone(date_default_timezone_get()));
+ $this->_year = (int)$parsed->format('Y');
+ $this->_month = (int)$parsed->format('m');
+ $this->_mday = (int)$parsed->format('d');
+ $this->_hour = (int)$parsed->format('H');
+ $this->_min = (int)$parsed->format('i');
+ $this->_sec = (int)$parsed->format('s');
+ $this->_initializeTimezone(date_default_timezone_get());
+ }
+ }
+
+ /**
+ * Returns a simple string representation of the date object
+ *
+ * @return string This object converted to a string.
+ */
+ public function __toString()
+ {
+ try {
+ return $this->format($this->_defaultFormat);
+ } catch (Exception $e) {
+ return '';
+ }
+ }
+
+ /**
+ * Returns a DateTime object representing this object.
+ *
+ * @return DateTime
+ */
+ public function toDateTime()
+ {
+ $date = new DateTime(null, new DateTimeZone($this->_timezone));
+ $date->setDate($this->_year, $this->_month, $this->_mday);
+ $date->setTime($this->_hour, $this->_min, $this->_sec);
+ return $date;
+ }
+
+ /**
+ * Converts a date in the proleptic Gregorian calendar to the no of days
+ * since 24th November, 4714 B.C.
+ *
+ * Returns the no of days since Monday, 24th November, 4714 B.C. in the
+ * proleptic Gregorian calendar (which is 24th November, -4713 using
+ * 'Astronomical' year numbering, and 1st January, 4713 B.C. in the
+ * proleptic Julian calendar). This is also the first day of the 'Julian
+ * Period' proposed by Joseph Scaliger in 1583, and the number of days
+ * since this date is known as the 'Julian Day'. (It is not directly
+ * to do with the Julian calendar, although this is where the name
+ * is derived from.)
+ *
+ * The algorithm is valid for all years (positive and negative), and
+ * also for years preceding 4714 B.C.
+ *
+ * Algorithm is from PEAR::Date_Calc
+ *
+ * @author Monte Ohrt <monte at ispi.net>
+ * @author Pierre-Alain Joye <pajoye at php.net>
+ * @author Daniel Convissor <danielc at php.net>
+ * @author C.A. Woodcock <c01234 at netcomuk.co.uk>
+ *
+ * @return integer The number of days since 24th November, 4714 B.C.
+ */
+ public function toDays()
+ {
+ if (function_exists('GregorianToJD')) {
+ return gregoriantojd($this->_month, $this->_mday, $this->_year);
+ }
+
+ $day = $this->_mday;
+ $month = $this->_month;
+ $year = $this->_year;
+
+ if ($month > 2) {
+ // March = 0, April = 1, ..., December = 9,
+ // January = 10, February = 11
+ $month -= 3;
+ } else {
+ $month += 9;
+ --$year;
+ }
+
+ $hb_negativeyear = $year < 0;
+ $century = intval($year / 100);
+ $year = $year % 100;
+
+ if ($hb_negativeyear) {
+ // Subtract 1 because year 0 is a leap year;
+ // And N.B. that we must treat the leap years as occurring
+ // one year earlier than they do, because for the purposes
+ // of calculation, the year starts on 1st March:
+ //
+ return intval((14609700 * $century + ($year == 0 ? 1 : 0)) / 400) +
+ intval((1461 * $year + 1) / 4) +
+ intval((153 * $month + 2) / 5) +
+ $day + 1721118;
+ } else {
+ return intval(146097 * $century / 4) +
+ intval(1461 * $year / 4) +
+ intval((153 * $month + 2) / 5) +
+ $day + 1721119;
+ }
+ }
+
+ /**
+ * Converts number of days since 24th November, 4714 B.C. (in the proleptic
+ * Gregorian calendar, which is year -4713 using 'Astronomical' year
+ * numbering) to Gregorian calendar date.
+ *
+ * Returned date belongs to the proleptic Gregorian calendar, using
+ * 'Astronomical' year numbering.
+ *
+ * The algorithm is valid for all years (positive and negative), and
+ * also for years preceding 4714 B.C. (i.e. for negative 'Julian Days'),
+ * and so the only limitation is platform-dependent (for 32-bit systems
+ * the maximum year would be something like about 1,465,190 A.D.).
+ *
+ * N.B. Monday, 24th November, 4714 B.C. is Julian Day '0'.
+ *
+ * Algorithm is from PEAR::Date_Calc
+ *
+ * @author Monte Ohrt <monte at ispi.net>
+ * @author Pierre-Alain Joye <pajoye at php.net>
+ * @author Daniel Convissor <danielc at php.net>
+ * @author C.A. Woodcock <c01234 at netcomuk.co.uk>
+ *
+ * @param int $days the number of days since 24th November, 4714 B.C.
+ * @param string $format the string indicating how to format the output
+ *
+ * @return Horde_Date A Horde_Date object representing the date.
+ */
+ public static function fromDays($days)
+ {
+ if (function_exists('JDToGregorian')) {
+ list($month, $day, $year) = explode('/', JDToGregorian($days));
+ } else {
+ $days = intval($days);
+
+ $days -= 1721119;
+ $century = floor((4 * $days - 1) / 146097);
+ $days = floor(4 * $days - 1 - 146097 * $century);
+ $day = floor($days / 4);
+
+ $year = floor((4 * $day + 3) / 1461);
+ $day = floor(4 * $day + 3 - 1461 * $year);
+ $day = floor(($day + 4) / 4);
+
+ $month = floor((5 * $day - 3) / 153);
+ $day = floor(5 * $day - 3 - 153 * $month);
+ $day = floor(($day + 5) / 5);
+
+ $year = $century * 100 + $year;
+ if ($month < 10) {
+ $month +=3;
+ } else {
+ $month -=9;
+ ++$year;
+ }
+ }
+
+ return new Horde_Date($year, $month, $day);
+ }
+
+ /**
+ * Getter for the date and time properties.
+ *
+ * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
+ * 'sec'.
+ *
+ * @return integer The property value, or null if not set.
+ */
+ public function __get($name)
+ {
+ if ($name == 'day') {
+ $name = 'mday';
+ }
+
+ return $this->{'_' . $name};
+ }
+
+ /**
+ * Setter for the date and time properties.
+ *
+ * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
+ * 'sec'.
+ * @param integer $value The property value.
+ */
+ public function __set($name, $value)
+ {
+ if ($name == 'timezone') {
+ $this->_initializeTimezone($value);
+ return;
+ }
+ if ($name == 'day') {
+ $name = 'mday';
+ }
+
+ if ($name != 'year' && $name != 'month' && $name != 'mday' &&
+ $name != 'hour' && $name != 'min' && $name != 'sec') {
+ throw new InvalidArgumentException('Undefined property ' . $name);
+ }
+
+ $down = $value < $this->{'_' . $name};
+ $this->{'_' . $name} = $value;
+ $this->_correct(self::$_corrections[$name], $down);
+ $this->_formatCache = array();
+ }
+
+ /**
+ * Returns whether a date or time property exists.
+ *
+ * @param string $name One of 'year', 'month', 'mday', 'hour', 'min' or
+ * 'sec'.
+ *
+ * @return boolen True if the property exists and is set.
+ */
+ public function __isset($name)
+ {
+ if ($name == 'day') {
+ $name = 'mday';
+ }
+ return ($name == 'year' || $name == 'month' || $name == 'mday' ||
+ $name == 'hour' || $name == 'min' || $name == 'sec') &&
+ isset($this->{'_' . $name});
+ }
+
+ /**
+ * Adds a number of seconds or units to this date, returning a new Date
+ * object.
+ */
+ public function add($factor)
+ {
+ $d = clone($this);
+ if (is_array($factor) || is_object($factor)) {
+ foreach ($factor as $property => $value) {
+ $d->$property += $value;
+ }
+ } else {
+ $d->sec += $factor;
+ }
+
+ return $d;
+ }
+
+ /**
+ * Subtracts a number of seconds or units from this date, returning a new
+ * Horde_Date object.
+ */
+ public function sub($factor)
+ {
+ if (is_array($factor)) {
+ foreach ($factor as &$value) {
+ $value *= -1;
+ }
+ } else {
+ $factor *= -1;
+ }
+
+ return $this->add($factor);
+ }
+
+ /**
+ * Converts this object to a different timezone.
+ *
+ * @param string $timezone The new timezone.
+ *
+ * @return Horde_Date This object.
+ */
+ public function setTimezone($timezone)
+ {
+ $date = $this->toDateTime();
+ $date->setTimezone(new DateTimeZone($timezone));
+ $this->_timezone = $timezone;
+ $this->_year = (int)$date->format('Y');
+ $this->_month = (int)$date->format('m');
+ $this->_mday = (int)$date->format('d');
+ $this->_hour = (int)$date->format('H');
+ $this->_min = (int)$date->format('i');
+ $this->_sec = (int)$date->format('s');
+ $this->_formatCache = array();
+ return $this;
+ }
+
+ /**
+ * Sets the default date format used in __toString()
+ *
+ * @param string $format
+ */
+ public function setDefaultFormat($format)
+ {
+ $this->_defaultFormat = $format;
+ }
+
+ /**
+ * Returns the day of the week (0 = Sunday, 6 = Saturday) of this date.
+ *
+ * @return integer The day of the week.
+ */
+ public function dayOfWeek()
+ {
+ if ($this->_month > 2) {
+ $month = $this->_month - 2;
+ $year = $this->_year;
+ } else {
+ $month = $this->_month + 10;
+ $year = $this->_year - 1;
+ }
+
+ $day = (floor((13 * $month - 1) / 5) +
+ $this->_mday + ($year % 100) +
+ floor(($year % 100) / 4) +
+ floor(($year / 100) / 4) - 2 *
+ floor($year / 100) + 77);
+
+ return (int)($day - 7 * floor($day / 7));
+ }
+
+ /**
+ * Returns the day number of the year (1 to 365/366).
+ *
+ * @return integer The day of the year.
+ */
+ public function dayOfYear()
+ {
+ return $this->format('z') + 1;
+ }
+
+ /**
+ * Returns the week of the month.
+ *
+ * @return integer The week number.
+ */
+ public function weekOfMonth()
+ {
+ return ceil($this->_mday / 7);
+ }
+
+ /**
+ * Returns the week of the year, first Monday is first day of first week.
+ *
+ * @return integer The week number.
+ */
+ public function weekOfYear()
+ {
+ return $this->format('W');
+ }
+
+ /**
+ * Returns the number of weeks in the given year (52 or 53).
+ *
+ * @param integer $year The year to count the number of weeks in.
+ *
+ * @return integer $numWeeks The number of weeks in $year.
+ */
+ public static function weeksInYear($year)
+ {
+ // Find the last Thursday of the year.
+ $date = new Horde_Date($year . '-12-31');
+ while ($date->dayOfWeek() != self::DATE_THURSDAY) {
+ --$date->mday;
+ }
+ return $date->weekOfYear();
+ }
+
+ /**
+ * Sets the date of this object to the $nth weekday of $weekday.
+ *
+ * @param integer $weekday The day of the week (0 = Sunday, etc).
+ * @param integer $nth The $nth $weekday to set to (defaults to 1).
+ */
+ public function setNthWeekday($weekday, $nth = 1)
+ {
+ if ($weekday < self::DATE_SUNDAY || $weekday > self::DATE_SATURDAY) {
+ return;
+ }
+
+ $this->_mday = 1;
+ $first = $this->dayOfWeek();
+ if ($weekday < $first) {
+ $this->_mday = 8 + $weekday - $first;
+ } else {
+ $this->_mday = $weekday - $first + 1;
+ }
+ $diff = 7 * $nth - 7;
+ $this->_mday += $diff;
+ $this->_correct(self::MASK_DAY, $diff < 0);
+ }
+
+ /**
+ * Is the date currently represented by this object a valid date?
+ *
+ * @return boolean Validity, counting leap years, etc.
+ */
+ public function isValid()
+ {
+ return ($this->_year >= 0 && $this->_year <= 9999);
+ }
+
+ /**
+ * Compares this date to another date object to see which one is
+ * greater (later). Assumes that the dates are in the same
+ * timezone.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return integer == 0 if they are on the same date
+ * >= 1 if $this is greater (later)
+ * <= -1 if $other is greater (later)
+ */
+ public function compareDate($other)
+ {
+ if (!($other instanceof Horde_Date)) {
+ $other = new Horde_Date($other);
+ }
+
+ if ($this->_year != $other->year) {
+ return $this->_year - $other->year;
+ }
+ if ($this->_month != $other->month) {
+ return $this->_month - $other->month;
+ }
+
+ return $this->_mday - $other->mday;
+ }
+
+ /**
+ * Returns whether this date is after the other.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return boolean True if this date is after the other.
+ */
+ public function after($other)
+ {
+ return $this->compareDate($other) > 0;
+ }
+
+ /**
+ * Returns whether this date is before the other.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return boolean True if this date is before the other.
+ */
+ public function before($other)
+ {
+ return $this->compareDate($other) < 0;
+ }
+
+ /**
+ * Returns whether this date is the same like the other.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return boolean True if this date is the same like the other.
+ */
+ public function equals($other)
+ {
+ return $this->compareDate($other) == 0;
+ }
+
+ /**
+ * Compares this to another date object by time, to see which one
+ * is greater (later). Assumes that the dates are in the same
+ * timezone.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return integer == 0 if they are at the same time
+ * >= 1 if $this is greater (later)
+ * <= -1 if $other is greater (later)
+ */
+ public function compareTime($other)
+ {
+ if (!($other instanceof Horde_Date)) {
+ $other = new Horde_Date($other);
+ }
+
+ if ($this->_hour != $other->hour) {
+ return $this->_hour - $other->hour;
+ }
+ if ($this->_min != $other->min) {
+ return $this->_min - $other->min;
+ }
+
+ return $this->_sec - $other->sec;
+ }
+
+ /**
+ * Compares this to another date object, including times, to see
+ * which one is greater (later). Assumes that the dates are in the
+ * same timezone.
+ *
+ * @param mixed $other The date to compare to.
+ *
+ * @return integer == 0 if they are equal
+ * >= 1 if $this is greater (later)
+ * <= -1 if $other is greater (later)
+ */
+ public function compareDateTime($other)
+ {
+ if (!($other instanceof Horde_Date)) {
+ $other = new Horde_Date($other);
+ }
+
+ if ($diff = $this->compareDate($other)) {
+ return $diff;
+ }
+
+ return $this->compareTime($other);
+ }
+
+ /**
+ * Returns number of days between this date and another.
+ *
+ * @param Horde_Date $other The other day to diff with.
+ *
+ * @return integer The absolute number of days between the two dates.
+ */
+ public function diff($other)
+ {
+ return abs($this->toDays() - $other->toDays());
+ }
+
+ /**
+ * Returns the time offset for local time zone.
+ *
+ * @param boolean $colon Place a colon between hours and minutes?
+ *
+ * @return string Timezone offset as a string in the format +HH:MM.
+ */
+ public function tzOffset($colon = true)
+ {
+ return $colon ? $this->format('P') : $this->format('O');
+ }
+
+ /**
+ * Returns the unix timestamp representation of this date.
+ *
+ * @return integer A unix timestamp.
+ */
+ public function timestamp()
+ {
+ if ($this->_year >= 1970 && $this->_year < 2038) {
+ return mktime($this->_hour, $this->_min, $this->_sec,
+ $this->_month, $this->_mday, $this->_year);
+ }
+ return $this->format('U');
+ }
+
+ /**
+ * Returns the unix timestamp representation of this date, 12:00am.
+ *
+ * @return integer A unix timestamp.
+ */
+ public function datestamp()
+ {
+ if ($this->_year >= 1970 && $this->_year < 2038) {
+ return mktime(0, 0, 0, $this->_month, $this->_mday, $this->_year);
+ }
+ $date = new DateTime($this->format('Y-m-d'));
+ return $date->format('U');
+ }
+
+ /**
+ * Formats date and time to be passed around as a short url parameter.
+ *
+ * @return string Date and time.
+ */
+ public function dateString()
+ {
+ return sprintf('%04d%02d%02d', $this->_year, $this->_month, $this->_mday);
+ }
+
+ /**
+ * Formats date and time to the ISO format used by JSON.
+ *
+ * @return string Date and time.
+ */
+ public function toJson()
+ {
+ return $this->format(self::DATE_JSON);
+ }
+
+ /**
+ * Formats date and time to the RFC 2445 iCalendar DATE-TIME format.
+ *
+ * @param boolean $floating Whether to return a floating date-time
+ * (without time zone information).
+ *
+ * @return string Date and time.
+ */
+ public function toiCalendar($floating = false)
+ {
+ if ($floating) {
+ return $this->format('Ymd\THis');
+ }
+ $dateTime = $this->toDateTime();
+ $dateTime->setTimezone(new DateTimeZone('UTC'));
+ return $dateTime->format('Ymd\THis\Z');
+ }
+
+ /**
+ * Formats time using the specifiers available in date() or in the DateTime
+ * class' format() method.
+ *
+ * To format in languages other than English, use strftime() instead.
+ *
+ * @param string $format
+ *
+ * @return string Formatted time.
+ */
+ public function format($format)
+ {
+ if (!isset($this->_formatCache[$format])) {
+ $this->_formatCache[$format] = $this->toDateTime()->format($format);
+ }
+ return $this->_formatCache[$format];
+ }
+
+ /**
+ * Formats date and time using strftime() format.
+ *
+ * @return string strftime() formatted date and time.
+ */
+ public function strftime($format)
+ {
+ if (preg_match('/%[^' . self::$_supportedSpecs . ']/', $format)) {
+ return strftime($format, $this->timestamp());
+ } else {
+ return $this->_strftime($format);
+ }
+ }
+
+ /**
+ * Formats date and time using a limited set of the strftime() format.
+ *
+ * @return string strftime() formatted date and time.
+ */
+ protected function _strftime($format)
+ {
+ return preg_replace(
+ array('/%b/e',
+ '/%B/e',
+ '/%C/e',
+ '/%d/e',
+ '/%D/e',
+ '/%e/e',
+ '/%H/e',
+ '/%I/e',
+ '/%m/e',
+ '/%M/e',
+ '/%n/',
+ '/%p/e',
+ '/%R/e',
+ '/%S/e',
+ '/%t/',
+ '/%T/e',
+ '/%x/e',
+ '/%X/e',
+ '/%y/e',
+ '/%Y/',
+ '/%%/'),
+ array('$this->_strftime(Horde_Nls::getLangInfo(constant(\'ABMON_\' . (int)$this->_month)))',
+ '$this->_strftime(Horde_Nls::getLangInfo(constant(\'MON_\' . (int)$this->_month)))',
+ '(int)($this->_year / 100)',
+ 'sprintf(\'%02d\', $this->_mday)',
+ '$this->_strftime(\'%m/%d/%y\')',
+ 'sprintf(\'%2d\', $this->_mday)',
+ 'sprintf(\'%02d\', $this->_hour)',
+ 'sprintf(\'%02d\', $this->_hour == 0 ? 12 : ($this->_hour > 12 ? $this->_hour - 12 : $this->_hour))',
+ 'sprintf(\'%02d\', $this->_month)',
+ 'sprintf(\'%02d\', $this->_min)',
+ "\n",
+ '$this->_strftime(Horde_Nls::getLangInfo($this->_hour < 12 ? AM_STR : PM_STR))',
+ '$this->_strftime(\'%H:%M\')',
+ 'sprintf(\'%02d\', $this->_sec)',
+ "\t",
+ '$this->_strftime(\'%H:%M:%S\')',
+ '$this->_strftime(Horde_Nls::getLangInfo(D_FMT))',
+ '$this->_strftime(Horde_Nls::getLangInfo(T_FMT))',
+ 'substr(sprintf(\'%04d\', $this->_year), -2)',
+ (int)$this->_year,
+ '%'),
+ $format);
+ }
+
+ /**
+ * Corrects any over- or underflows in any of the date's members.
+ *
+ * @param integer $mask We may not want to correct some overflows.
+ * @param integer $down Whether to correct the date up or down.
+ */
+ protected function _correct($mask = self::MASK_ALLPARTS, $down = false)
+ {
+ if ($mask & self::MASK_SECOND) {
+ if ($this->_sec < 0 || $this->_sec > 59) {
+ $mask |= self::MASK_MINUTE;
+
+ $this->_min += (int)($this->_sec / 60);
+ $this->_sec %= 60;
+ if ($this->_sec < 0) {
+ $this->_min--;
+ $this->_sec += 60;
+ }
+ }
+ }
+
+ if ($mask & self::MASK_MINUTE) {
+ if ($this->_min < 0 || $this->_min > 59) {
+ $mask |= self::MASK_HOUR;
+
+ $this->_hour += (int)($this->_min / 60);
+ $this->_min %= 60;
+ if ($this->_min < 0) {
+ $this->_hour--;
+ $this->_min += 60;
+ }
+ }
+ }
+
+ if ($mask & self::MASK_HOUR) {
+ if ($this->_hour < 0 || $this->_hour > 23) {
+ $mask |= self::MASK_DAY;
+
+ $this->_mday += (int)($this->_hour / 24);
+ $this->_hour %= 24;
+ if ($this->_hour < 0) {
+ $this->_mday--;
+ $this->_hour += 24;
+ }
+ }
+ }
+
+ if ($mask & self::MASK_MONTH) {
+ $this->_correctMonth($down);
+ /* When correcting the month, always correct the day too. Months
+ * have different numbers of days. */
+ $mask |= self::MASK_DAY;
+ }
+
+ if ($mask & self::MASK_DAY) {
+ while ($this->_mday > 28 &&
+ $this->_mday > Horde_Date_Utils::daysInMonth($this->_month, $this->_year)) {
+ if ($down) {
+ $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month + 1, $this->_year) - Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
+ } else {
+ $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
+ $this->_month++;
+ }
+ $this->_correctMonth($down);
+ }
+ while ($this->_mday < 1) {
+ --$this->_month;
+ $this->_correctMonth($down);
+ $this->_mday += Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
+ }
+ }
+ }
+
+ /**
+ * Corrects the current month.
+ *
+ * This cannot be done in _correct() because that would also trigger a
+ * correction of the day, which would result in an infinite loop.
+ *
+ * @param integer $down Whether to correct the date up or down.
+ */
+ protected function _correctMonth($down = false)
+ {
+ $this->_year += (int)($this->_month / 12);
+ $this->_month %= 12;
+ if ($this->_month < 1) {
+ $this->_year--;
+ $this->_month += 12;
+ }
+ }
+
+ /**
+ * Handles args in order: year month day hour min sec tz
+ */
+ protected function _initializeFromArgs($args)
+ {
+ $tz = (isset($args[6])) ? array_pop($args) : null;
+ $this->_initializeTimezone($tz);
+
+ $args = array_slice($args, 0, 6);
+ $keys = array('year' => 1, 'month' => 1, 'mday' => 1, 'hour' => 0, 'min' => 0, 'sec' => 0);
+ $date = array_combine(array_slice(array_keys($keys), 0, count($args)), $args);
+ $date = array_merge($keys, $date);
+
+ $this->_initializeFromArray($date);
+ }
+
+ protected function _initializeFromArray($date)
+ {
+ if (isset($date['year']) && is_string($date['year']) && strlen($date['year']) == 2) {
+ if ($date['year'] > 70) {
+ $date['year'] += 1900;
+ } else {
+ $date['year'] += 2000;
+ }
+ }
+
+ foreach ($date as $key => $val) {
+ if (in_array($key, array('year', 'month', 'mday', 'hour', 'min', 'sec'))) {
+ $this->{'_'. $key} = (int)$val;
+ }
+ }
+
+ // If $date['day'] is present and numeric we may have been passed
+ // a Horde_Form_datetime array.
+ if (isset($date['day']) &&
+ (string)(int)$date['day'] == $date['day']) {
+ $this->_mday = (int)$date['day'];
+ }
+ // 'minute' key also from Horde_Form_datetime
+ if (isset($date['minute']) &&
+ (string)(int)$date['minute'] == $date['minute']) {
+ $this->_min = (int)$date['minute'];
+ }
+
+ $this->_correct();
+ }
+
+ protected function _initializeFromObject($date)
+ {
+ if ($date instanceof DateTime) {
+ $this->_year = (int)$date->format('Y');
+ $this->_month = (int)$date->format('m');
+ $this->_mday = (int)$date->format('d');
+ $this->_hour = (int)$date->format('H');
+ $this->_min = (int)$date->format('i');
+ $this->_sec = (int)$date->format('s');
+ $this->_initializeTimezone($date->getTimezone()->getName());
+ } else {
+ $is_horde_date = $date instanceof Horde_Date;
+ foreach (array('year', 'month', 'mday', 'hour', 'min', 'sec') as $key) {
+ if ($is_horde_date || isset($date->$key)) {
+ $this->{'_' . $key} = (int)$date->$key;
+ }
+ }
+ if (!$is_horde_date) {
+ $this->_correct();
+ } else {
+ $this->_initializeTimezone($date->timezone);
+ }
+ }
+ }
+
+ protected function _initializeTimezone($timezone)
+ {
+ if (empty($timezone)) {
+ $timezone = date_default_timezone_get();
+ }
+ $this->_timezone = $timezone;
+ }
+
+}
diff --git a/plugins/libkolab/lib/Horde_Date_Recurrence.php b/plugins/libkolab/lib/Horde_Date_Recurrence.php
new file mode 100644
index 0000000..2171a47
--- /dev/null
+++ b/plugins/libkolab/lib/Horde_Date_Recurrence.php
@@ -0,0 +1,1768 @@
+<?php
+
+/**
+ * This is a concatenated copy of the following files:
+ * Horde/Date.php, Horde/Date/Utils.php, Horde/Date/Recurrence.php
+ * Pull the latest version of these files from the PEAR channel of the Horde
+ * project at http://pear.horde.org by installing the Horde_Date package.
+ */
+
+if (!class_exists('Horde_Date'))
+ require_once(dirname(__FILE__) . '/Horde_Date.php');
+
+// minimal required implementation of Horde_Date_Translation to avoid a huge dependency nightmare
+class Horde_Date_Translation
+{
+ function t($arg) { return $arg; }
+ function ngettext($sing, $plur, $num) { return ($num > 1 ? $plur : $sing); }
+}
+
+
+/**
+ * @category Horde
+ * @package Date
+ */
+
+/**
+ * Horde Date wrapper/logic class, including some calculation
+ * functions.
+ *
+ * @category Horde
+ * @package Date
+ */
+class Horde_Date_Utils
+{
+ /**
+ * Returns whether a year is a leap year.
+ *
+ * @param integer $year The year.
+ *
+ * @return boolean True if the year is a leap year.
+ */
+ public static function isLeapYear($year)
+ {
+ if (strlen($year) != 4 || preg_match('/\D/', $year)) {
+ return false;
+ }
+
+ return (($year % 4 == 0 && $year % 100 != 0) || $year % 400 == 0);
+ }
+
+ /**
+ * Returns the date of the year that corresponds to the first day of the
+ * given week.
+ *
+ * @param integer $week The week of the year to find the first day of.
+ * @param integer $year The year to calculate for.
+ *
+ * @return Horde_Date The date of the first day of the given week.
+ */
+ public static function firstDayOfWeek($week, $year)
+ {
+ return new Horde_Date(sprintf('%04dW%02d', $year, $week));
+ }
+
+ /**
+ * Returns the number of days in the specified month.
+ *
+ * @param integer $month The month
+ * @param integer $year The year.
+ *
+ * @return integer The number of days in the month.
+ */
+ public static function daysInMonth($month, $year)
+ {
+ static $cache = array();
+ if (!isset($cache[$year][$month])) {
+ $date = new DateTime(sprintf('%04d-%02d-01', $year, $month));
+ $cache[$year][$month] = $date->format('t');
+ }
+ return $cache[$year][$month];
+ }
+
+ /**
+ * Returns a relative, natural language representation of a timestamp
+ *
+ * @todo Wider range of values ... maybe future time as well?
+ * @todo Support minimum resolution parameter.
+ *
+ * @param mixed $time The time. Any format accepted by Horde_Date.
+ * @param string $date_format Format to display date if timestamp is
+ * more then 1 day old.
+ * @param string $time_format Format to display time if timestamp is 1
+ * day old.
+ *
+ * @return string The relative time (i.e. 2 minutes ago)
+ */
+ public static function relativeDateTime($time, $date_format = '%x',
+ $time_format = '%X')
+ {
+ $date = new Horde_Date($time);
+
+ $delta = time() - $date->timestamp();
+ if ($delta < 60) {
+ return sprintf(Horde_Date_Translation::ngettext("%d second ago", "%d seconds ago", $delta), $delta);
+ }
+
+ $delta = round($delta / 60);
+ if ($delta < 60) {
+ return sprintf(Horde_Date_Translation::ngettext("%d minute ago", "%d minutes ago", $delta), $delta);
+ }
+
+ $delta = round($delta / 60);
+ if ($delta < 24) {
+ return sprintf(Horde_Date_Translation::ngettext("%d hour ago", "%d hours ago", $delta), $delta);
+ }
+
+ if ($delta > 24 && $delta < 48) {
+ $date = new Horde_Date($time);
+ return sprintf(Horde_Date_Translation::t("yesterday at %s"), $date->strftime($time_format));
+ }
+
+ $delta = round($delta / 24);
+ if ($delta < 7) {
+ return sprintf(Horde_Date_Translation::t("%d days ago"), $delta);
+ }
+
+ if (round($delta / 7) < 5) {
+ $delta = round($delta / 7);
+ return sprintf(Horde_Date_Translation::ngettext("%d week ago", "%d weeks ago", $delta), $delta);
+ }
+
+ // Default to the user specified date format.
+ return $date->strftime($date_format);
+ }
+
+ /**
+ * Tries to convert strftime() formatters to date() formatters.
+ *
+ * Unsupported formatters will be removed.
+ *
+ * @param string $format A strftime() formatting string.
+ *
+ * @return string A date() formatting string.
+ */
+ public static function strftime2date($format)
+ {
+ $replace = array(
+ '/%a/' => 'D',
+ '/%A/' => 'l',
+ '/%d/' => 'd',
+ '/%e/' => 'j',
+ '/%j/' => 'z',
+ '/%u/' => 'N',
+ '/%w/' => 'w',
+ '/%U/' => '',
+ '/%V/' => 'W',
+ '/%W/' => '',
+ '/%b/' => 'M',
+ '/%B/' => 'F',
+ '/%h/' => 'M',
+ '/%m/' => 'm',
+ '/%C/' => '',
+ '/%g/' => '',
+ '/%G/' => 'o',
+ '/%y/' => 'y',
+ '/%Y/' => 'Y',
+ '/%H/' => 'H',
+ '/%I/' => 'h',
+ '/%i/' => 'g',
+ '/%M/' => 'i',
+ '/%p/' => 'A',
+ '/%P/' => 'a',
+ '/%r/' => 'h:i:s A',
+ '/%R/' => 'H:i',
+ '/%S/' => 's',
+ '/%T/' => 'H:i:s',
+ '/%X/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(T_FMT))',
+ '/%z/' => 'O',
+ '/%Z/' => '',
+ '/%c/' => '',
+ '/%D/' => 'm/d/y',
+ '/%F/' => 'Y-m-d',
+ '/%s/' => 'U',
+ '/%x/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(D_FMT))',
+ '/%n/' => "\n",
+ '/%t/' => "\t",
+ '/%%/' => '%'
+ );
+
+ return preg_replace(array_keys($replace), array_values($replace), $format);
+ }
+
+}
+
+
+
+/**
+ * This file contains the Horde_Date_Recurrence class and according constants.
+ *
+ * Copyright 2007-2012 Horde LLC (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you
+ * did not receive this file, see http://www.horde.org/licenses/lgpl21.
+ *
+ * @category Horde
+ * @package Date
+ */
+
+/**
+ * The Horde_Date_Recurrence class implements algorithms for calculating
+ * recurrences of events, including several recurrence types, intervals,
+ * exceptions, and conversion from and to vCalendar and iCalendar recurrence
+ * rules.
+ *
+ * All methods expecting dates as parameters accept all values that the
+ * Horde_Date constructor accepts, i.e. a timestamp, another Horde_Date
+ * object, an ISO time string or a hash.
+ *
+ * @author Jan Schneider <jan at horde.org>
+ * @category Horde
+ * @package Date
+ */
+class Horde_Date_Recurrence
+{
+ /** No Recurrence **/
+ const RECUR_NONE = 0;
+
+ /** Recurs daily. */
+ const RECUR_DAILY = 1;
+
+ /** Recurs weekly. */
+ const RECUR_WEEKLY = 2;
+
+ /** Recurs monthly on the same date. */
+ const RECUR_MONTHLY_DATE = 3;
+
+ /** Recurs monthly on the same week day. */
+ const RECUR_MONTHLY_WEEKDAY = 4;
+
+ /** Recurs yearly on the same date. */
+ const RECUR_YEARLY_DATE = 5;
+
+ /** Recurs yearly on the same day of the year. */
+ const RECUR_YEARLY_DAY = 6;
+
+ /** Recurs yearly on the same week day. */
+ const RECUR_YEARLY_WEEKDAY = 7;
+
+ /**
+ * The start time of the event.
+ *
+ * @var Horde_Date
+ */
+ public $start;
+
+ /**
+ * The end date of the recurrence interval.
+ *
+ * @var Horde_Date
+ */
+ public $recurEnd = null;
+
+ /**
+ * The number of recurrences.
+ *
+ * @var integer
+ */
+ public $recurCount = null;
+
+ /**
+ * The type of recurrence this event follows. RECUR_* constant.
+ *
+ * @var integer
+ */
+ public $recurType = self::RECUR_NONE;
+
+ /**
+ * The length of time between recurrences. The time unit depends on the
+ * recurrence type.
+ *
+ * @var integer
+ */
+ public $recurInterval = 1;
+
+ /**
+ * Any additional recurrence data.
+ *
+ * @var integer
+ */
+ public $recurData = null;
+
+ /**
+ * All the exceptions from recurrence for this event.
+ *
+ * @var array
+ */
+ public $exceptions = array();
+
+ /**
+ * All the dates this recurrence has been marked as completed.
+ *
+ * @var array
+ */
+ public $completions = array();
+
+ /**
+ * Constructor.
+ *
+ * @param Horde_Date $start Start of the recurring event.
+ */
+ public function __construct($start)
+ {
+ $this->start = new Horde_Date($start);
+ }
+
+ /**
+ * Resets the class properties.
+ */
+ public function reset()
+ {
+ $this->recurEnd = null;
+ $this->recurCount = null;
+ $this->recurType = self::RECUR_NONE;
+ $this->recurInterval = 1;
+ $this->recurData = null;
+ $this->exceptions = array();
+ $this->completions = array();
+ }
+
+ /**
+ * Checks if this event recurs on a given day of the week.
+ *
+ * @param integer $dayMask A mask consisting of Horde_Date::MASK_*
+ * constants specifying the day(s) to check.
+ *
+ * @return boolean True if this event recurs on the given day(s).
+ */
+ public function recurOnDay($dayMask)
+ {
+ return ($this->recurData & $dayMask);
+ }
+
+ /**
+ * Specifies the days this event recurs on.
+ *
+ * @param integer $dayMask A mask consisting of Horde_Date::MASK_*
+ * constants specifying the day(s) to recur on.
+ */
+ public function setRecurOnDay($dayMask)
+ {
+ $this->recurData = $dayMask;
+ }
+
+ /**
+ * Returns the days this event recurs on.
+ *
+ * @return integer A mask consisting of Horde_Date::MASK_* constants
+ * specifying the day(s) this event recurs on.
+ */
+ public function getRecurOnDays()
+ {
+ return $this->recurData;
+ }
+
+ /**
+ * Returns whether this event has a specific recurrence type.
+ *
+ * @param integer $recurrence RECUR_* constant of the
+ * recurrence type to check for.
+ *
+ * @return boolean True if the event has the specified recurrence type.
+ */
+ public function hasRecurType($recurrence)
+ {
+ return ($recurrence == $this->recurType);
+ }
+
+ /**
+ * Sets a recurrence type for this event.
+ *
+ * @param integer $recurrence A RECUR_* constant.
+ */
+ public function setRecurType($recurrence)
+ {
+ $this->recurType = $recurrence;
+ }
+
+ /**
+ * Returns recurrence type of this event.
+ *
+ * @return integer A RECUR_* constant.
+ */
+ public function getRecurType()
+ {
+ return $this->recurType;
+ }
+
+ /**
+ * Returns a description of this event's recurring type.
+ *
+ * @return string Human readable recurring type.
+ */
+ public function getRecurName()
+ {
+ switch ($this->getRecurType()) {
+ case self::RECUR_NONE: return Horde_Date_Translation::t("No recurrence");
+ case self::RECUR_DAILY: return Horde_Date_Translation::t("Daily");
+ case self::RECUR_WEEKLY: return Horde_Date_Translation::t("Weekly");
+ case self::RECUR_MONTHLY_DATE:
+ case self::RECUR_MONTHLY_WEEKDAY: return Horde_Date_Translation::t("Monthly");
+ case self::RECUR_YEARLY_DATE:
+ case self::RECUR_YEARLY_DAY:
+ case self::RECUR_YEARLY_WEEKDAY: return Horde_Date_Translation::t("Yearly");
+ }
+ }
+
+ /**
+ * Sets the length of time between recurrences of this event.
+ *
+ * @param integer $interval The time between recurrences.
+ */
+ public function setRecurInterval($interval)
+ {
+ if ($interval > 0) {
+ $this->recurInterval = $interval;
+ }
+ }
+
+ /**
+ * Retrieves the length of time between recurrences of this event.
+ *
+ * @return integer The number of seconds between recurrences.
+ */
+ public function getRecurInterval()
+ {
+ return $this->recurInterval;
+ }
+
+ /**
+ * Sets the number of recurrences of this event.
+ *
+ * @param integer $count The number of recurrences.
+ */
+ public function setRecurCount($count)
+ {
+ if ($count > 0) {
+ $this->recurCount = (int)$count;
+ // Recurrence counts and end dates are mutually exclusive.
+ $this->recurEnd = null;
+ } else {
+ $this->recurCount = null;
+ }
+ }
+
+ /**
+ * Retrieves the number of recurrences of this event.
+ *
+ * @return integer The number recurrences.
+ */
+ public function getRecurCount()
+ {
+ return $this->recurCount;
+ }
+
+ /**
+ * Returns whether this event has a recurrence with a fixed count.
+ *
+ * @return boolean True if this recurrence has a fixed count.
+ */
+ public function hasRecurCount()
+ {
+ return isset($this->recurCount);
+ }
+
+ /**
+ * Sets the start date of the recurrence interval.
+ *
+ * @param Horde_Date $start The recurrence start.
+ */
+ public function setRecurStart($start)
+ {
+ $this->start = clone $start;
+ }
+
+ /**
+ * Retrieves the start date of the recurrence interval.
+ *
+ * @return Horde_Date The recurrence start.
+ */
+ public function getRecurStart()
+ {
+ return $this->start;
+ }
+
+ /**
+ * Sets the end date of the recurrence interval.
+ *
+ * @param Horde_Date $end The recurrence end.
+ */
+ public function setRecurEnd($end)
+ {
+ if (!empty($end)) {
+ // Recurrence counts and end dates are mutually exclusive.
+ $this->recurCount = null;
+ $this->recurEnd = clone $end;
+ } else {
+ $this->recurEnd = $end;
+ }
+ }
+
+ /**
+ * Retrieves the end date of the recurrence interval.
+ *
+ * @return Horde_Date The recurrence end.
+ */
+ public function getRecurEnd()
+ {
+ return $this->recurEnd;
+ }
+
+ /**
+ * Returns whether this event has a recurrence end.
+ *
+ * @return boolean True if this recurrence ends.
+ */
+ public function hasRecurEnd()
+ {
+ return isset($this->recurEnd) && isset($this->recurEnd->year) &&
+ $this->recurEnd->year != 9999;
+ }
+
+ /**
+ * Finds the next recurrence of this event that's after $afterDate.
+ *
+ * @param Horde_Date|string $after Return events after this date.
+ *
+ * @return Horde_Date|boolean The date of the next recurrence or false
+ * if the event does not recur after
+ * $afterDate.
+ */
+ public function nextRecurrence($after)
+ {
+ if (!($after instanceof Horde_Date)) {
+ $after = new Horde_Date($after);
+ } else {
+ $after = clone($after);
+ }
+
+ // Make sure $after and $this->start are in the same TZ
+ $after->setTimezone($this->start->timezone);
+ if ($this->start->compareDateTime($after) >= 0) {
+ return clone $this->start;
+ }
+
+ if ($this->recurInterval == 0) {
+ return false;
+ }
+
+ switch ($this->getRecurType()) {
+ case self::RECUR_DAILY:
+ $diff = $this->start->diff($after);
+ $recur = ceil($diff / $this->recurInterval);
+ if ($this->recurCount && $recur >= $this->recurCount) {
+ return false;
+ }
+
+ $recur *= $this->recurInterval;
+ $next = $this->start->add(array('day' => $recur));
+ if ((!$this->hasRecurEnd() ||
+ $next->compareDateTime($this->recurEnd) <= 0) &&
+ $next->compareDateTime($after) >= 0) {
+ return $next;
+ }
+ break;
+
+ case self::RECUR_WEEKLY:
+ if (empty($this->recurData)) {
+ return false;
+ }
+
+ $start_week = Horde_Date_Utils::firstDayOfWeek($this->start->format('W'),
+ $this->start->year);
+ $start_week->timezone = $this->start->timezone;
+ $start_week->hour = $this->start->hour;
+ $start_week->min = $this->start->min;
+ $start_week->sec = $this->start->sec;
+
+ // Make sure we are not at the ISO-8601 first week of year while
+ // still in month 12...OR in the ISO-8601 last week of year while
+ // in month 1 and adjust the year accordingly.
+ $week = $after->format('W');
+ if ($week == 1 && $after->month == 12) {
+ $theYear = $after->year + 1;
+ } elseif ($week >= 52 && $after->month == 1) {
+ $theYear = $after->year - 1;
+ } else {
+ $theYear = $after->year;
+ }
+
+ $after_week = Horde_Date_Utils::firstDayOfWeek($week, $theYear);
+ $after_week->timezone = $this->start->timezone;
+ $after_week_end = clone $after_week;
+ $after_week_end->mday += 7;
+
+ $diff = $start_week->diff($after_week);
+ $interval = $this->recurInterval * 7;
+ $repeats = floor($diff / $interval);
+ if ($diff % $interval < 7) {
+ $recur = $diff;
+ } else {
+ /**
+ * If the after_week is not in the first week interval the
+ * search needs to skip ahead a complete interval. The way it is
+ * calculated here means that an event that occurs every second
+ * week on Monday and Wednesday with the event actually starting
+ * on Tuesday or Wednesday will only have one incidence in the
+ * first week.
+ */
+ $recur = $interval * ($repeats + 1);
+ }
+
+ if ($this->hasRecurCount()) {
+ $recurrences = 0;
+ /**
+ * Correct the number of recurrences by the number of events
+ * that lay between the start of the start week and the
+ * recurrence start.
+ */
+ $next = clone $start_week;
+ while ($next->compareDateTime($this->start) < 0) {
+ if ($this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
+ $recurrences--;
+ }
+ ++$next->mday;
+ }
+ if ($repeats > 0) {
+ $weekdays = $this->recurData;
+ $total_recurrences_per_week = 0;
+ while ($weekdays > 0) {
+ if ($weekdays % 2) {
+ $total_recurrences_per_week++;
+ }
+ $weekdays = ($weekdays - ($weekdays % 2)) / 2;
+ }
+ $recurrences += $total_recurrences_per_week * $repeats;
+ }
+ }
+
+ $next = clone $start_week;
+ $next->mday += $recur;
+ while ($next->compareDateTime($after) < 0 &&
+ $next->compareDateTime($after_week_end) < 0) {
+ if ($this->hasRecurCount()
+ && $next->compareDateTime($after) < 0
+ && $this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
+ $recurrences++;
+ }
+ ++$next->mday;
+ }
+ if ($this->hasRecurCount() &&
+ $recurrences >= $this->recurCount) {
+ return false;
+ }
+ if (!$this->hasRecurEnd() ||
+ $next->compareDateTime($this->recurEnd) <= 0) {
+ if ($next->compareDateTime($after_week_end) >= 0) {
+ return $this->nextRecurrence($after_week_end);
+ }
+ while (!$this->recurOnDay((int)pow(2, $next->dayOfWeek())) &&
+ $next->compareDateTime($after_week_end) < 0) {
+ ++$next->mday;
+ }
+ if (!$this->hasRecurEnd() ||
+ $next->compareDateTime($this->recurEnd) <= 0) {
+ if ($next->compareDateTime($after_week_end) >= 0) {
+ return $this->nextRecurrence($after_week_end);
+ } else {
+ return $next;
+ }
+ }
+ }
+ break;
+
+ case self::RECUR_MONTHLY_DATE:
+ $start = clone $this->start;
+ if ($after->compareDateTime($start) < 0) {
+ $after = clone $start;
+ } else {
+ $after = clone $after;
+ }
+
+ // If we're starting past this month's recurrence of the event,
+ // look in the next month on the day the event recurs.
+ if ($after->mday > $start->mday) {
+ ++$after->month;
+ $after->mday = $start->mday;
+ }
+
+ // Adjust $start to be the first match.
+ $offset = ($after->month - $start->month) + ($after->year - $start->year) * 12;
+ $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
+
+ if ($this->recurCount &&
+ ($offset / $this->recurInterval) >= $this->recurCount) {
+ return false;
+ }
+ $start->month += $offset;
+ $count = $offset / $this->recurInterval;
+
+ do {
+ if ($this->recurCount &&
+ $count++ >= $this->recurCount) {
+ return false;
+ }
+
+ // Bail if we've gone past the end of recurrence.
+ if ($this->hasRecurEnd() &&
+ $this->recurEnd->compareDateTime($start) < 0) {
+ return false;
+ }
+ if ($start->isValid()) {
+ return $start;
+ }
+
+ // If the interval is 12, and the date isn't valid, then we
+ // need to see if February 29th is an option. If not, then the
+ // event will _never_ recur, and we need to stop checking to
+ // avoid an infinite loop.
+ if ($this->recurInterval == 12 && ($start->month != 2 || $start->mday > 29)) {
+ return false;
+ }
+
+ // Add the recurrence interval.
+ $start->month += $this->recurInterval;
+ } while (true);
+
+ break;
+
+ case self::RECUR_MONTHLY_WEEKDAY:
+ // Start with the start date of the event.
+ $estart = clone $this->start;
+
+ // What day of the week, and week of the month, do we recur on?
+ $nth = ceil($this->start->mday / 7);
+ $weekday = $estart->dayOfWeek();
+
+ // Adjust $estart to be the first candidate.
+ $offset = ($after->month - $estart->month) + ($after->year - $estart->year) * 12;
+ $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
+
+ // Adjust our working date until it's after $after.
+ $estart->month += $offset - $this->recurInterval;
+
+ $count = $offset / $this->recurInterval;
+ do {
+ if ($this->recurCount &&
+ $count++ >= $this->recurCount) {
+ return false;
+ }
+
+ $estart->month += $this->recurInterval;
+
+ $next = clone $estart;
+ $next->setNthWeekday($weekday, $nth);
+
+ if ($next->compareDateTime($after) < 0) {
+ // We haven't made it past $after yet, try again.
+ continue;
+ }
+ if ($this->hasRecurEnd() &&
+ $next->compareDateTime($this->recurEnd) > 0) {
+ // We've gone past the end of recurrence; we can give up
+ // now.
+ return false;
+ }
+
+ // We have a candidate to return.
+ break;
+ } while (true);
+
+ return $next;
+
+ case self::RECUR_YEARLY_DATE:
+ // Start with the start date of the event.
+ $estart = clone $this->start;
+ $after = clone $after;
+
+ if ($after->month > $estart->month ||
+ ($after->month == $estart->month && $after->mday > $estart->mday)) {
+ ++$after->year;
+ $after->month = $estart->month;
+ $after->mday = $estart->mday;
+ }
+
+ // Seperate case here for February 29th
+ if ($estart->month == 2 && $estart->mday == 29) {
+ while (!Horde_Date_Utils::isLeapYear($after->year)) {
+ ++$after->year;
+ }
+ }
+
+ // Adjust $estart to be the first candidate.
+ $offset = $after->year - $estart->year;
+ if ($offset > 0) {
+ $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
+ $estart->year += $offset;
+ }
+
+ // We've gone past the end of recurrence; give up.
+ if ($this->recurCount &&
+ $offset >= $this->recurCount) {
+ return false;
+ }
+ if ($this->hasRecurEnd() &&
+ $this->recurEnd->compareDateTime($estart) < 0) {
+ return false;
+ }
+
+ return $estart;
+
+ case self::RECUR_YEARLY_DAY:
+ // Check count first.
+ $dayofyear = $this->start->dayOfYear();
+ $count = ($after->year - $this->start->year) / $this->recurInterval + 1;
+ if ($this->recurCount &&
+ ($count > $this->recurCount ||
+ ($count == $this->recurCount &&
+ $after->dayOfYear() > $dayofyear))) {
+ return false;
+ }
+
+ // Start with a rough interval.
+ $estart = clone $this->start;
+ $estart->year += floor($count - 1) * $this->recurInterval;
+
+ // Now add the difference to the required day of year.
+ $estart->mday += $dayofyear - $estart->dayOfYear();
+
+ // Add an interval if the estimation was wrong.
+ if ($estart->compareDate($after) < 0) {
+ $estart->year += $this->recurInterval;
+ $estart->mday += $dayofyear - $estart->dayOfYear();
+ }
+
+ // We've gone past the end of recurrence; give up.
+ if ($this->hasRecurEnd() &&
+ $this->recurEnd->compareDateTime($estart) < 0) {
+ return false;
+ }
+
+ return $estart;
+
+ case self::RECUR_YEARLY_WEEKDAY:
+ // Start with the start date of the event.
+ $estart = clone $this->start;
+
+ // What day of the week, and week of the month, do we recur on?
+ $nth = ceil($this->start->mday / 7);
+ $weekday = $estart->dayOfWeek();
+
+ // Adjust $estart to be the first candidate.
+ $offset = floor(($after->year - $estart->year + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
+
+ // Adjust our working date until it's after $after.
+ $estart->year += $offset - $this->recurInterval;
+
+ $count = $offset / $this->recurInterval;
+ do {
+ if ($this->recurCount &&
+ $count++ >= $this->recurCount) {
+ return false;
+ }
+
+ $estart->year += $this->recurInterval;
+
+ $next = clone $estart;
+ $next->setNthWeekday($weekday, $nth);
+
+ if ($next->compareDateTime($after) < 0) {
+ // We haven't made it past $after yet, try again.
+ continue;
+ }
+ if ($this->hasRecurEnd() &&
+ $next->compareDateTime($this->recurEnd) > 0) {
+ // We've gone past the end of recurrence; we can give up
+ // now.
+ return false;
+ }
+
+ // We have a candidate to return.
+ break;
+ } while (true);
+
+ return $next;
+ }
+
+ // We didn't find anything, the recurType was bad, or something else
+ // went wrong - return false.
+ return false;
+ }
+
+ /**
+ * Returns whether this event has any date that matches the recurrence
+ * rules and is not an exception.
+ *
+ * @return boolean True if an active recurrence exists.
+ */
+ public function hasActiveRecurrence()
+ {
+ if (!$this->hasRecurEnd()) {
+ return true;
+ }
+
+ $next = $this->nextRecurrence(new Horde_Date($this->start));
+ while (is_object($next)) {
+ if (!$this->hasException($next->year, $next->month, $next->mday) &&
+ !$this->hasCompletion($next->year, $next->month, $next->mday)) {
+ return true;
+ }
+
+ $next = $this->nextRecurrence($next->add(array('day' => 1)));
+ }
+
+ return false;
+ }
+
+ /**
+ * Returns the next active recurrence.
+ *
+ * @param Horde_Date $afterDate Return events after this date.
+ *
+ * @return Horde_Date|boolean The date of the next active
+ * recurrence or false if the event
+ * has no active recurrence after
+ * $afterDate.
+ */
+ public function nextActiveRecurrence($afterDate)
+ {
+ $next = $this->nextRecurrence($afterDate);
+ while (is_object($next)) {
+ if (!$this->hasException($next->year, $next->month, $next->mday) &&
+ !$this->hasCompletion($next->year, $next->month, $next->mday)) {
+ return $next;
+ }
+ $next->mday++;
+ $next = $this->nextRecurrence($next);
+ }
+
+ return false;
+ }
+
+ /**
+ * Adds an exception to a recurring event.
+ *
+ * @param integer $year The year of the execption.
+ * @param integer $month The month of the execption.
+ * @param integer $mday The day of the month of the exception.
+ */
+ public function addException($year, $month, $mday)
+ {
+ $this->exceptions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
+ }
+
+ /**
+ * Deletes an exception from a recurring event.
+ *
+ * @param integer $year The year of the execption.
+ * @param integer $month The month of the execption.
+ * @param integer $mday The day of the month of the exception.
+ */
+ public function deleteException($year, $month, $mday)
+ {
+ $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->exceptions);
+ if ($key !== false) {
+ unset($this->exceptions[$key]);
+ }
+ }
+
+ /**
+ * Checks if an exception exists for a given reccurence of an event.
+ *
+ * @param integer $year The year of the reucrance.
+ * @param integer $month The month of the reucrance.
+ * @param integer $mday The day of the month of the reucrance.
+ *
+ * @return boolean True if an exception exists for the given date.
+ */
+ public function hasException($year, $month, $mday)
+ {
+ return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
+ $this->getExceptions());
+ }
+
+ /**
+ * Retrieves all the exceptions for this event.
+ *
+ * @return array Array containing the dates of all the exceptions in
+ * YYYYMMDD form.
+ */
+ public function getExceptions()
+ {
+ return $this->exceptions;
+ }
+
+ /**
+ * Adds a completion to a recurring event.
+ *
+ * @param integer $year The year of the execption.
+ * @param integer $month The month of the execption.
+ * @param integer $mday The day of the month of the completion.
+ */
+ public function addCompletion($year, $month, $mday)
+ {
+ $this->completions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
+ }
+
+ /**
+ * Deletes a completion from a recurring event.
+ *
+ * @param integer $year The year of the execption.
+ * @param integer $month The month of the execption.
+ * @param integer $mday The day of the month of the completion.
+ */
+ public function deleteCompletion($year, $month, $mday)
+ {
+ $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->completions);
+ if ($key !== false) {
+ unset($this->completions[$key]);
+ }
+ }
+
+ /**
+ * Checks if a completion exists for a given reccurence of an event.
+ *
+ * @param integer $year The year of the reucrance.
+ * @param integer $month The month of the recurrance.
+ * @param integer $mday The day of the month of the recurrance.
+ *
+ * @return boolean True if a completion exists for the given date.
+ */
+ public function hasCompletion($year, $month, $mday)
+ {
+ return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
+ $this->getCompletions());
+ }
+
+ /**
+ * Retrieves all the completions for this event.
+ *
+ * @return array Array containing the dates of all the completions in
+ * YYYYMMDD form.
+ */
+ public function getCompletions()
+ {
+ return $this->completions;
+ }
+
+ /**
+ * Parses a vCalendar 1.0 recurrence rule.
+ *
+ * @link http://www.imc.org/pdi/vcal-10.txt
+ * @link http://www.shuchow.com/vCalAddendum.html
+ *
+ * @param string $rrule A vCalendar 1.0 conform RRULE value.
+ */
+ public function fromRRule10($rrule)
+ {
+ $this->reset();
+
+ if (!$rrule) {
+ return;
+ }
+
+ if (!preg_match('/([A-Z]+)(\d+)?(.*)/', $rrule, $matches)) {
+ // No recurrence data - event does not recur.
+ $this->setRecurType(self::RECUR_NONE);
+ }
+
+ // Always default the recurInterval to 1.
+ $this->setRecurInterval(!empty($matches[2]) ? $matches[2] : 1);
+
+ $remainder = trim($matches[3]);
+
+ switch ($matches[1]) {
+ case 'D':
+ $this->setRecurType(self::RECUR_DAILY);
+ break;
+
+ case 'W':
+ $this->setRecurType(self::RECUR_WEEKLY);
+ if (!empty($remainder)) {
+ $maskdays = array(
+ 'SU' => Horde_Date::MASK_SUNDAY,
+ 'MO' => Horde_Date::MASK_MONDAY,
+ 'TU' => Horde_Date::MASK_TUESDAY,
+ 'WE' => Horde_Date::MASK_WEDNESDAY,
+ 'TH' => Horde_Date::MASK_THURSDAY,
+ 'FR' => Horde_Date::MASK_FRIDAY,
+ 'SA' => Horde_Date::MASK_SATURDAY,
+ );
+ $mask = 0;
+ while (preg_match('/^ ?[A-Z]{2} ?/', $remainder, $matches)) {
+ $day = trim($matches[0]);
+ $remainder = substr($remainder, strlen($matches[0]));
+ $mask |= $maskdays[$day];
+ }
+ $this->setRecurOnDay($mask);
+ } else {
+ // Recur on the day of the week of the original recurrence.
+ $maskdays = array(
+ Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
+ Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
+ Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
+ Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
+ Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
+ Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
+ Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY,
+ );
+ $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
+ }
+ break;
+
+ case 'MP':
+ $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
+ break;
+
+ case 'MD':
+ $this->setRecurType(self::RECUR_MONTHLY_DATE);
+ break;
+
+ case 'YM':
+ $this->setRecurType(self::RECUR_YEARLY_DATE);
+ break;
+
+ case 'YD':
+ $this->setRecurType(self::RECUR_YEARLY_DAY);
+ break;
+ }
+
+ // We don't support modifiers at the moment, strip them.
+ while ($remainder && !preg_match('/^(#\d+|\d{8})($| |T\d{6})/', $remainder)) {
+ $remainder = substr($remainder, 1);
+ }
+ if (!empty($remainder)) {
+ if (strpos($remainder, '#') === 0) {
+ $this->setRecurCount(substr($remainder, 1));
+ } else {
+ list($year, $month, $mday) = sscanf($remainder, '%04d%02d%02d');
+ $this->setRecurEnd(new Horde_Date(array('year' => $year,
+ 'month' => $month,
+ 'mday' => $mday)));
+ }
+ }
+ }
+
+ /**
+ * Creates a vCalendar 1.0 recurrence rule.
+ *
+ * @link http://www.imc.org/pdi/vcal-10.txt
+ * @link http://www.shuchow.com/vCalAddendum.html
+ *
+ * @param Horde_Icalendar $calendar A Horde_Icalendar object instance.
+ *
+ * @return string A vCalendar 1.0 conform RRULE value.
+ */
+ public function toRRule10($calendar)
+ {
+ switch ($this->recurType) {
+ case self::RECUR_NONE:
+ return '';
+
+ case self::RECUR_DAILY:
+ $rrule = 'D' . $this->recurInterval;
+ break;
+
+ case self::RECUR_WEEKLY:
+ $rrule = 'W' . $this->recurInterval;
+ $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
+
+ for ($i = 0; $i <= 7; ++$i) {
+ if ($this->recurOnDay(pow(2, $i))) {
+ $rrule .= ' ' . $vcaldays[$i];
+ }
+ }
+ break;
+
+ case self::RECUR_MONTHLY_DATE:
+ $rrule = 'MD' . $this->recurInterval . ' ' . trim($this->start->mday);
+ break;
+
+ case self::RECUR_MONTHLY_WEEKDAY:
+ $nth_weekday = (int)($this->start->mday / 7);
+ if (($this->start->mday % 7) > 0) {
+ $nth_weekday++;
+ }
+
+ $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
+ $rrule = 'MP' . $this->recurInterval . ' ' . $nth_weekday . '+ ' . $vcaldays[$this->start->dayOfWeek()];
+
+ break;
+
+ case self::RECUR_YEARLY_DATE:
+ $rrule = 'YM' . $this->recurInterval . ' ' . trim($this->start->month);
+ break;
+
+ case self::RECUR_YEARLY_DAY:
+ $rrule = 'YD' . $this->recurInterval . ' ' . $this->start->dayOfYear();
+ break;
+
+ default:
+ return '';
+ }
+
+ if ($this->hasRecurEnd()) {
+ $recurEnd = clone $this->recurEnd;
+ return $rrule . ' ' . $calendar->_exportDateTime($recurEnd);
+ }
+
+ return $rrule . ' #' . (int)$this->getRecurCount();
+ }
+
+ /**
+ * Parses an iCalendar 2.0 recurrence rule.
+ *
+ * @link http://rfc.net/rfc2445.html#s4.3.10
+ * @link http://rfc.net/rfc2445.html#s4.8.5
+ * @link http://www.shuchow.com/vCalAddendum.html
+ *
+ * @param string $rrule An iCalendar 2.0 conform RRULE value.
+ */
+ public function fromRRule20($rrule)
+ {
+ $this->reset();
+
+ // Parse the recurrence rule into keys and values.
+ $rdata = array();
+ $parts = explode(';', $rrule);
+ foreach ($parts as $part) {
+ list($key, $value) = explode('=', $part, 2);
+ $rdata[strtoupper($key)] = $value;
+ }
+
+ if (isset($rdata['FREQ'])) {
+ // Always default the recurInterval to 1.
+ $this->setRecurInterval(isset($rdata['INTERVAL']) ? $rdata['INTERVAL'] : 1);
+
+ switch (strtoupper($rdata['FREQ'])) {
+ case 'DAILY':
+ $this->setRecurType(self::RECUR_DAILY);
+ break;
+
+ case 'WEEKLY':
+ $this->setRecurType(self::RECUR_WEEKLY);
+ if (isset($rdata['BYDAY'])) {
+ $maskdays = array(
+ 'SU' => Horde_Date::MASK_SUNDAY,
+ 'MO' => Horde_Date::MASK_MONDAY,
+ 'TU' => Horde_Date::MASK_TUESDAY,
+ 'WE' => Horde_Date::MASK_WEDNESDAY,
+ 'TH' => Horde_Date::MASK_THURSDAY,
+ 'FR' => Horde_Date::MASK_FRIDAY,
+ 'SA' => Horde_Date::MASK_SATURDAY,
+ );
+ $days = explode(',', $rdata['BYDAY']);
+ $mask = 0;
+ foreach ($days as $day) {
+ $mask |= $maskdays[$day];
+ }
+ $this->setRecurOnDay($mask);
+ } else {
+ // Recur on the day of the week of the original
+ // recurrence.
+ $maskdays = array(
+ Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
+ Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
+ Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
+ Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
+ Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
+ Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
+ Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY);
+ $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
+ }
+ break;
+
+ case 'MONTHLY':
+ if (isset($rdata['BYDAY'])) {
+ $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
+ } else {
+ $this->setRecurType(self::RECUR_MONTHLY_DATE);
+ }
+ break;
+
+ case 'YEARLY':
+ if (isset($rdata['BYYEARDAY'])) {
+ $this->setRecurType(self::RECUR_YEARLY_DAY);
+ } elseif (isset($rdata['BYDAY'])) {
+ $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
+ } else {
+ $this->setRecurType(self::RECUR_YEARLY_DATE);
+ }
+ break;
+ }
+
+ if (isset($rdata['UNTIL'])) {
+ list($year, $month, $mday) = sscanf($rdata['UNTIL'],
+ '%04d%02d%02d');
+ $this->setRecurEnd(new Horde_Date(array('year' => $year,
+ 'month' => $month,
+ 'mday' => $mday)));
+ }
+ if (isset($rdata['COUNT'])) {
+ $this->setRecurCount($rdata['COUNT']);
+ }
+ } else {
+ // No recurrence data - event does not recur.
+ $this->setRecurType(self::RECUR_NONE);
+ }
+ }
+
+ /**
+ * Creates an iCalendar 2.0 recurrence rule.
+ *
+ * @link http://rfc.net/rfc2445.html#s4.3.10
+ * @link http://rfc.net/rfc2445.html#s4.8.5
+ * @link http://www.shuchow.com/vCalAddendum.html
+ *
+ * @param Horde_Icalendar $calendar A Horde_Icalendar object instance.
+ *
+ * @return string An iCalendar 2.0 conform RRULE value.
+ */
+ public function toRRule20($calendar)
+ {
+ switch ($this->recurType) {
+ case self::RECUR_NONE:
+ return '';
+
+ case self::RECUR_DAILY:
+ $rrule = 'FREQ=DAILY;INTERVAL=' . $this->recurInterval;
+ break;
+
+ case self::RECUR_WEEKLY:
+ $rrule = 'FREQ=WEEKLY;INTERVAL=' . $this->recurInterval . ';BYDAY=';
+ $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
+
+ for ($i = $flag = 0; $i <= 7; ++$i) {
+ if ($this->recurOnDay(pow(2, $i))) {
+ if ($flag) {
+ $rrule .= ',';
+ }
+ $rrule .= $vcaldays[$i];
+ $flag = true;
+ }
+ }
+ break;
+
+ case self::RECUR_MONTHLY_DATE:
+ $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval;
+ break;
+
+ case self::RECUR_MONTHLY_WEEKDAY:
+ $nth_weekday = (int)($this->start->mday / 7);
+ if (($this->start->mday % 7) > 0) {
+ $nth_weekday++;
+ }
+ $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
+ $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval
+ . ';BYDAY=' . $nth_weekday . $vcaldays[$this->start->dayOfWeek()];
+ break;
+
+ case self::RECUR_YEARLY_DATE:
+ $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval;
+ break;
+
+ case self::RECUR_YEARLY_DAY:
+ $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
+ . ';BYYEARDAY=' . $this->start->dayOfYear();
+ break;
+
+ case self::RECUR_YEARLY_WEEKDAY:
+ $nth_weekday = (int)($this->start->mday / 7);
+ if (($this->start->mday % 7) > 0) {
+ $nth_weekday++;
+ }
+ $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
+ $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
+ . ';BYDAY='
+ . $nth_weekday
+ . $vcaldays[$this->start->dayOfWeek()]
+ . ';BYMONTH=' . $this->start->month;
+ break;
+ }
+
+ if ($this->hasRecurEnd()) {
+ $recurEnd = clone $this->recurEnd;
+ $rrule .= ';UNTIL=' . $calendar->_exportDateTime($recurEnd);
+ }
+ if ($count = $this->getRecurCount()) {
+ $rrule .= ';COUNT=' . $count;
+ }
+ return $rrule;
+ }
+
+ /**
+ * Parses the recurrence data from a hash.
+ *
+ * @param array $hash The hash to convert.
+ *
+ * @return boolean True if the hash seemed valid, false otherwise.
+ */
+ public function fromHash($hash)
+ {
+ $this->reset();
+
+ if (!isset($hash['interval']) || !isset($hash['cycle'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ $this->setRecurInterval((int)$hash['interval']);
+
+ $parse_day = false;
+ $set_daymask = false;
+ $update_month = false;
+ $update_daynumber = false;
+ $update_weekday = false;
+ $nth_weekday = -1;
+
+ switch ($hash['cycle']) {
+ case 'daily':
+ $this->setRecurType(self::RECUR_DAILY);
+ break;
+
+ case 'weekly':
+ $this->setRecurType(self::RECUR_WEEKLY);
+ $parse_day = true;
+ $set_daymask = true;
+ break;
+
+ case 'monthly':
+ if (!isset($hash['daynumber'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ switch ($hash['type']) {
+ case 'daynumber':
+ $this->setRecurType(self::RECUR_MONTHLY_DATE);
+ $update_daynumber = true;
+ break;
+
+ case 'weekday':
+ $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
+ $nth_weekday = (int)$hash['daynumber'];
+ $hash['daynumber'] = 1;
+ $parse_day = true;
+ $update_daynumber = true;
+ $update_weekday = true;
+ break;
+ }
+ break;
+
+ case 'yearly':
+ if (!isset($hash['type'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ switch ($hash['type']) {
+ case 'monthday':
+ $this->setRecurType(self::RECUR_YEARLY_DATE);
+ $update_month = true;
+ $update_daynumber = true;
+ break;
+
+ case 'yearday':
+ if (!isset($hash['month'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ $this->setRecurType(self::RECUR_YEARLY_DAY);
+ // Start counting days in January.
+ $hash['month'] = 'january';
+ $update_month = true;
+ $update_daynumber = true;
+ break;
+
+ case 'weekday':
+ if (!isset($hash['daynumber'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
+ $nth_weekday = (int)$hash['daynumber'];
+ $hash['daynumber'] = 1;
+ $parse_day = true;
+ $update_month = true;
+ $update_daynumber = true;
+ $update_weekday = true;
+ break;
+ }
+ }
+
+ if (isset($hash['range-type']) && isset($hash['range'])) {
+ switch ($hash['range-type']) {
+ case 'number':
+ $this->setRecurCount((int)$hash['range']);
+ break;
+
+ case 'date':
+ $recur_end = new Horde_Date($hash['range']);
+ $recur_end->hour = 23;
+ $recur_end->min = 59;
+ $recur_end->sec = 59;
+ $this->setRecurEnd($recur_end);
+ break;
+ }
+ }
+
+ // Need to parse <day>?
+ $last_found_day = -1;
+ if ($parse_day) {
+ if (!isset($hash['day'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ $mask = 0;
+ $bits = array(
+ 'monday' => Horde_Date::MASK_MONDAY,
+ 'tuesday' => Horde_Date::MASK_TUESDAY,
+ 'wednesday' => Horde_Date::MASK_WEDNESDAY,
+ 'thursday' => Horde_Date::MASK_THURSDAY,
+ 'friday' => Horde_Date::MASK_FRIDAY,
+ 'saturday' => Horde_Date::MASK_SATURDAY,
+ 'sunday' => Horde_Date::MASK_SUNDAY,
+ );
+ $days = array(
+ 'monday' => Horde_Date::DATE_MONDAY,
+ 'tuesday' => Horde_Date::DATE_TUESDAY,
+ 'wednesday' => Horde_Date::DATE_WEDNESDAY,
+ 'thursday' => Horde_Date::DATE_THURSDAY,
+ 'friday' => Horde_Date::DATE_FRIDAY,
+ 'saturday' => Horde_Date::DATE_SATURDAY,
+ 'sunday' => Horde_Date::DATE_SUNDAY,
+ );
+
+ foreach ($hash['day'] as $day) {
+ // Validity check.
+ if (empty($day) || !isset($bits[$day])) {
+ continue;
+ }
+
+ $mask |= $bits[$day];
+ $last_found_day = $days[$day];
+ }
+
+ if ($set_daymask) {
+ $this->setRecurOnDay($mask);
+ }
+ }
+
+ if ($update_month || $update_daynumber || $update_weekday) {
+ if ($update_month) {
+ $month2number = array(
+ 'january' => 1,
+ 'february' => 2,
+ 'march' => 3,
+ 'april' => 4,
+ 'may' => 5,
+ 'june' => 6,
+ 'july' => 7,
+ 'august' => 8,
+ 'september' => 9,
+ 'october' => 10,
+ 'november' => 11,
+ 'december' => 12,
+ );
+
+ if (isset($month2number[$hash['month']])) {
+ $this->start->month = $month2number[$hash['month']];
+ }
+ }
+
+ if ($update_daynumber) {
+ if (!isset($hash['daynumber'])) {
+ $this->setRecurType(self::RECUR_NONE);
+ return false;
+ }
+
+ $this->start->mday = $hash['daynumber'];
+ }
+
+ if ($update_weekday) {
+ $this->start->setNthWeekday($last_found_day, $nth_weekday);
+ }
+ }
+
+ // Exceptions.
+ if (isset($hash['exceptions'])) {
+ $this->exceptions = $hash['exceptions'];
+ }
+
+ if (isset($hash['completions'])) {
+ $this->completions = $hash['completions'];
+ }
+
+ return true;
+ }
+
+ /**
+ * Export this object into a hash.
+ *
+ * @return array The recurrence hash.
+ */
+ public function toHash()
+ {
+ if ($this->getRecurType() == self::RECUR_NONE) {
+ return array();
+ }
+
+ $day2number = array(
+ 0 => 'sunday',
+ 1 => 'monday',
+ 2 => 'tuesday',
+ 3 => 'wednesday',
+ 4 => 'thursday',
+ 5 => 'friday',
+ 6 => 'saturday'
+ );
+ $month2number = array(
+ 1 => 'january',
+ 2 => 'february',
+ 3 => 'march',
+ 4 => 'april',
+ 5 => 'may',
+ 6 => 'june',
+ 7 => 'july',
+ 8 => 'august',
+ 9 => 'september',
+ 10 => 'october',
+ 11 => 'november',
+ 12 => 'december'
+ );
+
+ $hash = array('interval' => $this->getRecurInterval());
+ $start = $this->getRecurStart();
+
+ switch ($this->getRecurType()) {
+ case self::RECUR_DAILY:
+ $hash['cycle'] = 'daily';
+ break;
+
+ case self::RECUR_WEEKLY:
+ $hash['cycle'] = 'weekly';
+ $bits = array(
+ 'monday' => Horde_Date::MASK_MONDAY,
+ 'tuesday' => Horde_Date::MASK_TUESDAY,
+ 'wednesday' => Horde_Date::MASK_WEDNESDAY,
+ 'thursday' => Horde_Date::MASK_THURSDAY,
+ 'friday' => Horde_Date::MASK_FRIDAY,
+ 'saturday' => Horde_Date::MASK_SATURDAY,
+ 'sunday' => Horde_Date::MASK_SUNDAY,
+ );
+ $days = array();
+ foreach ($bits as $name => $bit) {
+ if ($this->recurOnDay($bit)) {
+ $days[] = $name;
+ }
+ }
+ $hash['day'] = $days;
+ break;
+
+ case self::RECUR_MONTHLY_DATE:
+ $hash['cycle'] = 'monthly';
+ $hash['type'] = 'daynumber';
+ $hash['daynumber'] = $start->mday;
+ break;
+
+ case self::RECUR_MONTHLY_WEEKDAY:
+ $hash['cycle'] = 'monthly';
+ $hash['type'] = 'weekday';
+ $hash['daynumber'] = $start->weekOfMonth();
+ $hash['day'] = array ($day2number[$start->dayOfWeek()]);
+ break;
+
+ case self::RECUR_YEARLY_DATE:
+ $hash['cycle'] = 'yearly';
+ $hash['type'] = 'monthday';
+ $hash['daynumber'] = $start->mday;
+ $hash['month'] = $month2number[$start->month];
+ break;
+
+ case self::RECUR_YEARLY_DAY:
+ $hash['cycle'] = 'yearly';
+ $hash['type'] = 'yearday';
+ $hash['daynumber'] = $start->dayOfYear();
+ break;
+
+ case self::RECUR_YEARLY_WEEKDAY:
+ $hash['cycle'] = 'yearly';
+ $hash['type'] = 'weekday';
+ $hash['daynumber'] = $start->weekOfMonth();
+ $hash['day'] = array ($day2number[$start->dayOfWeek()]);
+ $hash['month'] = $month2number[$start->month];
+ }
+
+ if ($this->hasRecurCount()) {
+ $hash['range-type'] = 'number';
+ $hash['range'] = $this->getRecurCount();
+ } elseif ($this->hasRecurEnd()) {
+ $date = $this->getRecurEnd();
+ $hash['range-type'] = 'date';
+ $hash['range'] = $date->datestamp();
+ } else {
+ $hash['range-type'] = 'none';
+ $hash['range'] = '';
+ }
+
+ // Recurrence exceptions
+ $hash['exceptions'] = $this->exceptions;
+ $hash['completions'] = $this->completions;
+
+ return $hash;
+ }
+
+ /**
+ * Returns a simple object suitable for json transport representing this
+ * object.
+ *
+ * Possible properties are:
+ * - t: type
+ * - i: interval
+ * - e: end date
+ * - c: count
+ * - d: data
+ * - co: completions
+ * - ex: exceptions
+ *
+ * @return object A simple object.
+ */
+ public function toJson()
+ {
+ $json = new stdClass;
+ $json->t = $this->recurType;
+ $json->i = $this->recurInterval;
+ if ($this->hasRecurEnd()) {
+ $json->e = $this->recurEnd->toJson();
+ }
+ if ($this->recurCount) {
+ $json->c = $this->recurCount;
+ }
+ if ($this->recurData) {
+ $json->d = $this->recurData;
+ }
+ if ($this->completions) {
+ $json->co = $this->completions;
+ }
+ if ($this->exceptions) {
+ $json->ex = $this->exceptions;
+ }
+ return $json;
+ }
+
+}
+
+
diff --git a/plugins/libkolab/lib/kolab_date_recurrence.php b/plugins/libkolab/lib/kolab_date_recurrence.php
new file mode 100644
index 0000000..c840864
--- /dev/null
+++ b/plugins/libkolab/lib/kolab_date_recurrence.php
@@ -0,0 +1,105 @@
+<?php
+
+/**
+ * Recurrence computation class for xcal-based Kolab format objects
+ *
+ * Uitility class to compute instances of recurring events.
+ *
+ * @version @package_version@
+ * @author Thomas Bruederli <bruederli at kolabsys.com>
+ *
+ * Copyright (C) 2012, Kolab Systems AG <contact at kolabsys.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+class kolab_date_recurrence
+{
+ private $engine;
+ private $tz_offset = 0;
+ private $allday = false;
+ private $hour = 0;
+
+ /**
+ * Default constructor
+ *
+ * @param array The Kolab object to operate on
+ */
+ function __construct($object)
+ {
+ // use (copied) Horde classes to compute recurring instances
+ // TODO: replace with something that has less than 6'000 lines of code
+ $this->engine = new Horde_Date_Recurrence($object['start']);
+ $this->engine->fromRRule20($this->to_rrule($object['recurrence'])); // TODO: get that string directly from libkolabxml
+
+ foreach ((array)$object['recurrence']['EXDATE'] as $exdate)
+ $this->engine->addException(date('Y', $exdate), date('n', $exdate), date('j', $exdate));
+
+ $now = new DateTime('now', kolab_format::$timezone);
+ $this->tz_offset = $object['allday'] ? $now->getOffset() - date('Z') : 0;
+ $this->next = new Horde_Date($object['start'] + $this->tz_offset); # shift all-day times to server timezone because computation operates in local TZ
+ $this->dst_start = $this->next->format('I');
+ $this->allday = $object['allday'];
+ $this->hour = $this->next->hour;
+ }
+
+ /**
+ * Get timestamp of the next occurence of this event
+ *
+ * @return mixed Unix timestamp or False if recurrence ended
+ */
+ public function next_start()
+ {
+ $time = false;
+ if ($this->next && ($next = $this->engine->nextActiveRecurrence(array('year' => $this->next->year, 'month' => $this->next->month, 'mday' => $this->next->mday + 1, 'hour' => $this->next->hour, 'min' => $this->next->min, 'sec' => $this->next->sec)))) {
+ if ($this->allday) {
+ $next->hour = $this->hour; # fix time for all-day events
+ $next->min = 0;
+ }
+ # consider difference in daylight saving between base event and recurring instance
+ $dst_diff = ($this->dst_start - $next->format('I')) * 3600;
+ $time = $next->timestamp() - $this->tz_offset - $dst_diff;
+ $this->next = $next;
+ }
+
+ return $time;
+ }
+
+ /**
+ * Convert the internal structured data into a vcalendar RRULE 2.0 string
+ */
+ private function to_rrule($recurrence)
+ {
+ if (is_string($recurrence))
+ return $recurrence;
+
+ $rrule = '';
+ foreach ((array)$recurrence as $k => $val) {
+ $k = strtoupper($k);
+ switch ($k) {
+ case 'UNTIL':
+ $val = gmdate('Ymd\THis', $val);
+ break;
+ case 'EXDATE':
+ foreach ((array)$val as $i => $ex)
+ $val[$i] = gmdate('Ymd\THis', $ex);
+ $val = join(',', (array)$val);
+ break;
+ }
+ $rrule .= $k . '=' . $val . ';';
+ }
+
+ return $rrule;
+ }
+
+}
More information about the commits
mailing list