Page MenuHomePhorge
Files F117877816

No OneTemporary
Actions

Authored By
Unknown
Size
104 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/plugins/calendar/lib/Horde_Date.php b/plugins/calendar/lib/Horde_Date.php
index 4ddd9d5e..9197f846 100644
--- a/plugins/calendar/lib/Horde_Date.php
+++ b/plugins/calendar/lib/Horde_Date.php
@@ -1,1112 +1,1304 @@
<?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.
+ */
+
+
/**
* 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@ispi.net>
* @author Pierre-Alain Joye <pajoye@php.net>
* @author Daniel Convissor <danielc@php.net>
* @author C.A. Woodcock <c01234@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@ispi.net>
* @author Pierre-Alain Joye <pajoye@php.net>
* @author Daniel Convissor <danielc@php.net>
* @author C.A. Woodcock <c01234@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;
+ if ($nth < 0) { // last $weekday of month
+ $this->_mday = $lastday = Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
+ $last = $this->dayOfWeek();
+ $this->_mday += ($weekday - $last);
+ if ($this->_mday > $lastday)
+ $this->_mday -= 7;
+ }
+ else {
+ $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);
}
- $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;
}
}
+
+/**
+ * @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);
+ }
+
+}
diff --git a/plugins/calendar/lib/Horde_Date_Recurrence.php b/plugins/calendar/lib/Horde_Date_Recurrence.php
index a1151046..81f0857d 100644
--- a/plugins/calendar/lib/Horde_Date_Recurrence.php
+++ b/plugins/calendar/lib/Horde_Date_Recurrence.php
@@ -1,1771 +1,1673 @@
<?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
+ * This is a modified copy of Horde/Date/Recurrence.php
+ * Pull the latest version of this file 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@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;
+ /**
+ * BYDAY recurrence number
+ *
+ * @var integer
+ */
+ public $recurNthDay = null;
+
+ /**
+ * BYMONTH recurrence data
+ *
+ * @var array
+ */
+ public $recurMonths = array();
+
/**
* 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;
}
+ /**
+ *
+ * @param integer $nthDay The nth weekday of month to repeat events on
+ */
+ public function setRecurNthWeekday($nth)
+ {
+ $this->recurNthDay = (int)$nth;
+ }
+
+ /**
+ *
+ * @return integer The nth weekday of month to repeat events.
+ */
+ public function getRecurNthWeekday()
+ {
+ return isset($this->recurNthDay) ? $this->recurNthDay : ceil($this->start->mday / 7);
+ }
+
+ /**
+ * Specifies the months for yearly (weekday) recurrence
+ *
+ * @param array $months List of months (integers) this event recurs on.
+ */
+ function setRecurByMonth($months)
+ {
+ $this->recurMonths = (array)$months;
+ }
+
+ /**
+ * Returns a list of months this yearly event recurs on
+ *
+ * @return array List of months (integers) this event recurs on.
+ */
+ function getRecurByMonth()
+ {
+ return $this->recurMonths;
+ }
+
/**
* 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();
+ if (isset($this->recurNthDay)) {
+ $nth = $this->recurNthDay;
+ $weekday = log($this->recurData, 2);
+ } else {
+ $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();
+ if (isset($this->recurNthDay)) {
+ $nth = $this->recurNthDay;
+ $weekday = log($this->recurData, 2);
+ } else {
+ $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)));
+ 'mday' => $mday,
+ 'hour' => 23,
+ 'min' => 59,
+ 'sec' => 59)));
}
}
}
/**
* 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);
+ $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,
+ );
+
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);
+ if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
+ $this->setRecurOnDay($maskdays[$m[2]]);
+ $this->setRecurNthWeekday($m[1]);
+ }
} 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);
+ if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
+ $this->setRecurOnDay($maskdays[$m[2]]);
+ $this->setRecurNthWeekday($m[1]);
+ }
+ if ($rdata['BYMONTH']) {
+ $months = explode(',', $rdata['BYMONTH']);
+ $this->setRecurByMonth($months);
+ }
} 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,
'hour' => 23,
'min' => 59,
'sec' => 59)));
}
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++;
+ if (isset($this->recurNthDay)) {
+ $nth_weekday = $this->recurNthDay;
+ $day_of_week = log($this->recurData, 2);
+ } else {
+ $day_of_week = $this->start->dayOfWeek();
+ $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()];
+ . ';BYDAY=' . $nth_weekday . $vcaldays[$day_of_week];
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++;
- }
+ if (isset($this->recurNthDay)) {
+ $nth_weekday = $this->recurNthDay;
+ $day_of_week = log($this->recurData, 2);
+ } else {
+ $day_of_week = $this->start->dayOfWeek();
+ $nth_weekday = (int)($this->start->mday / 7);
+ if (($this->start->mday % 7) > 0) {
+ $nth_weekday++;
+ }
+ }
+ $months = !empty($this->recurMonths) ? join(',', $this->recurMonths) : $this->start->month;
$vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
$rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
. ';BYDAY='
. $nth_weekday
- . $vcaldays[$this->start->dayOfWeek()]
+ . $vcaldays[$day_of_week]
. ';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']);
+ $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,
+ );
+
$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;
+ $this->setRecurNthWeekday($hash['daynumber']);
$parse_day = true;
- $update_daynumber = true;
- $update_weekday = true;
+ $set_daymask = 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;
+ $this->setRecurNthWeekday($hash['daynumber']);
$parse_day = true;
- $update_month = true;
- $update_daynumber = true;
- $update_weekday = true;
+ $set_daymask = true;
+
+ if ($hash['month'] && isset($month2number[$hash['month']])) {
+ $this->setRecurByMonth($month2number[$hash['month']]);
+ }
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);
+ $this->setNthWeekday($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;
}
}
-
-

File Metadata

Mime Type
text/x-diff
Expires
Sun, Apr 5, 9:40 PM (3 w, 20 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
18831289
Default Alt Text
(104 KB)

Event Timeline