You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1357 lines
49 KiB
1357 lines
49 KiB
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle 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 General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Defines calendar class to manage recurrence rule (rrule) during ical imports.
|
|
*
|
|
* @package core_calendar
|
|
* @copyright 2014 onwards Ankit Agarwal
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace core_calendar;
|
|
|
|
use calendar_event;
|
|
use DateInterval;
|
|
use DateTime;
|
|
use moodle_exception;
|
|
use stdClass;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
require_once($CFG->dirroot . '/calendar/lib.php');
|
|
|
|
/**
|
|
* Defines calendar class to manage recurrence rule (rrule) during ical imports.
|
|
*
|
|
* Please refer to RFC 2445 {@link http://www.ietf.org/rfc/rfc2445.txt} for detail explanation of the logic.
|
|
* Here is a basic extract from it to explain various params:-
|
|
* recur = "FREQ"=freq *(
|
|
* ; either UNTIL or COUNT may appear in a 'recur',
|
|
* ; but UNTIL and COUNT MUST NOT occur in the same 'recur'
|
|
* ( ";" "UNTIL" "=" enddate ) /
|
|
* ( ";" "COUNT" "=" 1*DIGIT ) /
|
|
* ; the rest of these keywords are optional,
|
|
* ; but MUST NOT occur more than once
|
|
* ( ";" "INTERVAL" "=" 1*DIGIT ) /
|
|
* ( ";" "BYSECOND" "=" byseclist ) /
|
|
* ( ";" "BYMINUTE" "=" byminlist ) /
|
|
* ( ";" "BYHOUR" "=" byhrlist ) /
|
|
* ( ";" "BYDAY" "=" bywdaylist ) /
|
|
* ( ";" "BYMONTHDAY" "=" bymodaylist ) /
|
|
* ( ";" "BYYEARDAY" "=" byyrdaylist ) /
|
|
* ( ";" "BYWEEKNO" "=" bywknolist ) /
|
|
* ( ";" "BYMONTH" "=" bymolist ) /
|
|
* ( ";" "BYSETPOS" "=" bysplist ) /
|
|
* ( ";" "WKST" "=" weekday ) /
|
|
* ( ";" x-name "=" text )
|
|
* )
|
|
*
|
|
* freq = "SECONDLY" / "MINUTELY" / "HOURLY" / "DAILY"
|
|
* / "WEEKLY" / "MONTHLY" / "YEARLY"
|
|
* enddate = date
|
|
* enddate =/ date-time ;An UTC value
|
|
* byseclist = seconds / ( seconds *("," seconds) )
|
|
* seconds = 1DIGIT / 2DIGIT ;0 to 59
|
|
* byminlist = minutes / ( minutes *("," minutes) )
|
|
* minutes = 1DIGIT / 2DIGIT ;0 to 59
|
|
* byhrlist = hour / ( hour *("," hour) )
|
|
* hour = 1DIGIT / 2DIGIT ;0 to 23
|
|
* bywdaylist = weekdaynum / ( weekdaynum *("," weekdaynum) )
|
|
* weekdaynum = [([plus] ordwk / minus ordwk)] weekday
|
|
* plus = "+"
|
|
* minus = "-"
|
|
* ordwk = 1DIGIT / 2DIGIT ;1 to 53
|
|
* weekday = "SU" / "MO" / "TU" / "WE" / "TH" / "FR" / "SA"
|
|
* ;Corresponding to SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
|
|
* ;FRIDAY, SATURDAY and SUNDAY days of the week.
|
|
* bymodaylist = monthdaynum / ( monthdaynum *("," monthdaynum) )
|
|
* monthdaynum = ([plus] ordmoday) / (minus ordmoday)
|
|
* ordmoday = 1DIGIT / 2DIGIT ;1 to 31
|
|
* byyrdaylist = yeardaynum / ( yeardaynum *("," yeardaynum) )
|
|
* yeardaynum = ([plus] ordyrday) / (minus ordyrday)
|
|
* ordyrday = 1DIGIT / 2DIGIT / 3DIGIT ;1 to 366
|
|
* bywknolist = weeknum / ( weeknum *("," weeknum) )
|
|
* weeknum = ([plus] ordwk) / (minus ordwk)
|
|
* bymolist = monthnum / ( monthnum *("," monthnum) )
|
|
* monthnum = 1DIGIT / 2DIGIT ;1 to 12
|
|
* bysplist = setposday / ( setposday *("," setposday) )
|
|
* setposday = yeardaynum
|
|
*
|
|
* @package core_calendar
|
|
* @copyright 2014 onwards Ankit Agarwal <ankit.agrr@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class rrule_manager {
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_YEARLY = 'yearly';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_MONTHLY = 'monthly';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_WEEKLY = 'weekly';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_DAILY = 'daily';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_HOURLY = 'hourly';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_MINUTELY = 'everyminute';
|
|
|
|
/** const string Frequency constant */
|
|
const FREQ_SECONDLY = 'everysecond';
|
|
|
|
/** const string Day constant */
|
|
const DAY_MONDAY = 'Monday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_TUESDAY = 'Tuesday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_WEDNESDAY = 'Wednesday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_THURSDAY = 'Thursday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_FRIDAY = 'Friday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_SATURDAY = 'Saturday';
|
|
|
|
/** const string Day constant */
|
|
const DAY_SUNDAY = 'Sunday';
|
|
|
|
/** const int For forever repeating events, repeat for this many years */
|
|
const TIME_UNLIMITED_YEARS = 10;
|
|
|
|
/** const array Array of days in a week. */
|
|
const DAYS_OF_WEEK = [
|
|
'MO' => self::DAY_MONDAY,
|
|
'TU' => self::DAY_TUESDAY,
|
|
'WE' => self::DAY_WEDNESDAY,
|
|
'TH' => self::DAY_THURSDAY,
|
|
'FR' => self::DAY_FRIDAY,
|
|
'SA' => self::DAY_SATURDAY,
|
|
'SU' => self::DAY_SUNDAY,
|
|
];
|
|
|
|
/** @var string string representing the recurrence rule */
|
|
protected $rrule;
|
|
|
|
/** @var string Frequency of event */
|
|
protected $freq;
|
|
|
|
/** @var int defines a timestamp value which bounds the recurrence rule in an inclusive manner.*/
|
|
protected $until = 0;
|
|
|
|
/** @var int Defines the number of occurrences at which to range-bound the recurrence */
|
|
protected $count = 0;
|
|
|
|
/** @var int This rule part contains a positive integer representing how often the recurrence rule repeats */
|
|
protected $interval = 1;
|
|
|
|
/** @var array List of second rules */
|
|
protected $bysecond = array();
|
|
|
|
/** @var array List of Minute rules */
|
|
protected $byminute = array();
|
|
|
|
/** @var array List of hour rules */
|
|
protected $byhour = array();
|
|
|
|
/** @var array List of day rules */
|
|
protected $byday = array();
|
|
|
|
/** @var array List of monthday rules */
|
|
protected $bymonthday = array();
|
|
|
|
/** @var array List of yearday rules */
|
|
protected $byyearday = array();
|
|
|
|
/** @var array List of weekno rules */
|
|
protected $byweekno = array();
|
|
|
|
/** @var array List of month rules */
|
|
protected $bymonth = array();
|
|
|
|
/** @var array List of setpos rules */
|
|
protected $bysetpos = array();
|
|
|
|
/** @var string Week start rule. Default is Monday. */
|
|
protected $wkst = self::DAY_MONDAY;
|
|
|
|
/**
|
|
* Constructor for the class
|
|
*
|
|
* @param string $rrule Recurrence rule
|
|
*/
|
|
public function __construct($rrule) {
|
|
$this->rrule = $rrule;
|
|
}
|
|
|
|
/**
|
|
* Parse the recurrence rule and setup all properties.
|
|
*/
|
|
public function parse_rrule() {
|
|
$rules = explode(';', $this->rrule);
|
|
if (empty($rules)) {
|
|
return;
|
|
}
|
|
foreach ($rules as $rule) {
|
|
$this->parse_rrule_property($rule);
|
|
}
|
|
// Validate the rules as a whole.
|
|
$this->validate_rules();
|
|
}
|
|
|
|
/**
|
|
* Create events for specified rrule.
|
|
*
|
|
* @param calendar_event $passedevent Properties of event to create.
|
|
* @throws moodle_exception
|
|
*/
|
|
public function create_events($passedevent) {
|
|
global $DB;
|
|
|
|
$event = clone($passedevent);
|
|
// If Frequency is not set, there is nothing to do.
|
|
if (empty($this->freq)) {
|
|
return;
|
|
}
|
|
|
|
// Delete all child events in case of an update. This should be faster than verifying if the event exists and updating it.
|
|
$where = "repeatid = ? AND id != ?";
|
|
$DB->delete_records_select('event', $where, array($event->id, $event->id));
|
|
$eventrec = $event->properties();
|
|
|
|
// Generate timestamps that obey the rrule.
|
|
$eventtimes = $this->generate_recurring_event_times($eventrec);
|
|
|
|
// Update the parent event. Make sure that its repeat ID is the same as its ID.
|
|
$calevent = new calendar_event($eventrec);
|
|
$updatedata = new stdClass();
|
|
$updatedata->repeatid = $event->id;
|
|
// Also, adjust the parent event's timestart, if necessary.
|
|
if (count($eventtimes) > 0 && !in_array($eventrec->timestart, $eventtimes)) {
|
|
$updatedata->timestart = reset($eventtimes);
|
|
}
|
|
$calevent->update($updatedata, false);
|
|
$eventrec->timestart = $calevent->timestart;
|
|
|
|
// Create the recurring calendar events.
|
|
$this->create_recurring_events($eventrec, $eventtimes);
|
|
}
|
|
|
|
/**
|
|
* Parse a property of the recurrence rule.
|
|
*
|
|
* @param string $prop property string with type-value pair
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function parse_rrule_property($prop) {
|
|
list($property, $value) = explode('=', $prop);
|
|
switch ($property) {
|
|
case 'FREQ' :
|
|
$this->set_frequency($value);
|
|
break;
|
|
case 'UNTIL' :
|
|
$this->set_until($value);
|
|
break;
|
|
CASE 'COUNT' :
|
|
$this->set_count($value);
|
|
break;
|
|
CASE 'INTERVAL' :
|
|
$this->set_interval($value);
|
|
break;
|
|
CASE 'BYSECOND' :
|
|
$this->set_bysecond($value);
|
|
break;
|
|
CASE 'BYMINUTE' :
|
|
$this->set_byminute($value);
|
|
break;
|
|
CASE 'BYHOUR' :
|
|
$this->set_byhour($value);
|
|
break;
|
|
CASE 'BYDAY' :
|
|
$this->set_byday($value);
|
|
break;
|
|
CASE 'BYMONTHDAY' :
|
|
$this->set_bymonthday($value);
|
|
break;
|
|
CASE 'BYYEARDAY' :
|
|
$this->set_byyearday($value);
|
|
break;
|
|
CASE 'BYWEEKNO' :
|
|
$this->set_byweekno($value);
|
|
break;
|
|
CASE 'BYMONTH' :
|
|
$this->set_bymonth($value);
|
|
break;
|
|
CASE 'BYSETPOS' :
|
|
$this->set_bysetpos($value);
|
|
break;
|
|
CASE 'WKST' :
|
|
$this->wkst = $this->get_day($value);
|
|
break;
|
|
default:
|
|
// We should never get here, something is very wrong.
|
|
throw new moodle_exception('errorrrule', 'calendar');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets Frequency property.
|
|
*
|
|
* @param string $freq Frequency of event
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_frequency($freq) {
|
|
switch ($freq) {
|
|
case 'YEARLY':
|
|
$this->freq = self::FREQ_YEARLY;
|
|
break;
|
|
case 'MONTHLY':
|
|
$this->freq = self::FREQ_MONTHLY;
|
|
break;
|
|
case 'WEEKLY':
|
|
$this->freq = self::FREQ_WEEKLY;
|
|
break;
|
|
case 'DAILY':
|
|
$this->freq = self::FREQ_DAILY;
|
|
break;
|
|
case 'HOURLY':
|
|
$this->freq = self::FREQ_HOURLY;
|
|
break;
|
|
case 'MINUTELY':
|
|
$this->freq = self::FREQ_MINUTELY;
|
|
break;
|
|
case 'SECONDLY':
|
|
$this->freq = self::FREQ_SECONDLY;
|
|
break;
|
|
default:
|
|
// We should never get here, something is very wrong.
|
|
throw new moodle_exception('errorrrulefreq', 'calendar');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the day from day string.
|
|
*
|
|
* @param string $daystring Day string (MO, TU, etc)
|
|
* @throws moodle_exception
|
|
*
|
|
* @return string Day represented by the parameter.
|
|
*/
|
|
protected function get_day($daystring) {
|
|
switch ($daystring) {
|
|
case 'MO':
|
|
return self::DAY_MONDAY;
|
|
break;
|
|
case 'TU':
|
|
return self::DAY_TUESDAY;
|
|
break;
|
|
case 'WE':
|
|
return self::DAY_WEDNESDAY;
|
|
break;
|
|
case 'TH':
|
|
return self::DAY_THURSDAY;
|
|
break;
|
|
case 'FR':
|
|
return self::DAY_FRIDAY;
|
|
break;
|
|
case 'SA':
|
|
return self::DAY_SATURDAY;
|
|
break;
|
|
case 'SU':
|
|
return self::DAY_SUNDAY;
|
|
break;
|
|
default:
|
|
// We should never get here, something is very wrong.
|
|
throw new moodle_exception('errorrruleday', 'calendar');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the UNTIL rule.
|
|
*
|
|
* @param string $until The date string representation of the UNTIL rule.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_until($until) {
|
|
$this->until = strtotime($until);
|
|
}
|
|
|
|
/**
|
|
* Sets the COUNT rule.
|
|
*
|
|
* @param string $count The count value.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_count($count) {
|
|
$this->count = intval($count);
|
|
}
|
|
|
|
/**
|
|
* Sets the INTERVAL rule.
|
|
*
|
|
* The INTERVAL rule part contains a positive integer representing how often the recurrence rule repeats.
|
|
* The default value is "1", meaning:
|
|
* - every second for a SECONDLY rule, or
|
|
* - every minute for a MINUTELY rule,
|
|
* - every hour for an HOURLY rule,
|
|
* - every day for a DAILY rule,
|
|
* - every week for a WEEKLY rule,
|
|
* - every month for a MONTHLY rule and
|
|
* - every year for a YEARLY rule.
|
|
*
|
|
* @param string $intervalstr The value for the interval rule.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_interval($intervalstr) {
|
|
$interval = intval($intervalstr);
|
|
if ($interval < 1) {
|
|
throw new moodle_exception('errorinvalidinterval', 'calendar');
|
|
}
|
|
$this->interval = $interval;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYSECOND rule.
|
|
*
|
|
* The BYSECOND rule part specifies a comma-separated list of seconds within a minute.
|
|
* Valid values are 0 to 59.
|
|
*
|
|
* @param string $bysecond Comma-separated list of seconds within a minute.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_bysecond($bysecond) {
|
|
$seconds = explode(',', $bysecond);
|
|
$bysecondrules = [];
|
|
foreach ($seconds as $second) {
|
|
if ($second < 0 || $second > 59) {
|
|
throw new moodle_exception('errorinvalidbysecond', 'calendar');
|
|
}
|
|
$bysecondrules[] = (int)$second;
|
|
}
|
|
$this->bysecond = $bysecondrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYMINUTE rule.
|
|
*
|
|
* The BYMINUTE rule part specifies a comma-separated list of seconds within an hour.
|
|
* Valid values are 0 to 59.
|
|
*
|
|
* @param string $byminute Comma-separated list of minutes within an hour.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_byminute($byminute) {
|
|
$minutes = explode(',', $byminute);
|
|
$byminuterules = [];
|
|
foreach ($minutes as $minute) {
|
|
if ($minute < 0 || $minute > 59) {
|
|
throw new moodle_exception('errorinvalidbyminute', 'calendar');
|
|
}
|
|
$byminuterules[] = (int)$minute;
|
|
}
|
|
$this->byminute = $byminuterules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYHOUR rule.
|
|
*
|
|
* The BYHOUR rule part specifies a comma-separated list of hours of the day.
|
|
* Valid values are 0 to 23.
|
|
*
|
|
* @param string $byhour Comma-separated list of hours of the day.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_byhour($byhour) {
|
|
$hours = explode(',', $byhour);
|
|
$byhourrules = [];
|
|
foreach ($hours as $hour) {
|
|
if ($hour < 0 || $hour > 23) {
|
|
throw new moodle_exception('errorinvalidbyhour', 'calendar');
|
|
}
|
|
$byhourrules[] = (int)$hour;
|
|
}
|
|
$this->byhour = $byhourrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYDAY rule.
|
|
*
|
|
* The BYDAY rule part specifies a comma-separated list of days of the week;
|
|
* - MO indicates Monday;
|
|
* - TU indicates Tuesday;
|
|
* - WE indicates Wednesday;
|
|
* - TH indicates Thursday;
|
|
* - FR indicates Friday;
|
|
* - SA indicates Saturday;
|
|
* - SU indicates Sunday.
|
|
*
|
|
* Each BYDAY value can also be preceded by a positive (+n) or negative (-n) integer.
|
|
* If present, this indicates the nth occurrence of the specific day within the MONTHLY or YEARLY RRULE.
|
|
* For example, within a MONTHLY rule, +1MO (or simply 1MO) represents the first Monday within the month,
|
|
* whereas -1MO represents the last Monday of the month.
|
|
* If an integer modifier is not present, it means all days of this type within the specified frequency.
|
|
* For example, within a MONTHLY rule, MO represents all Mondays within the month.
|
|
*
|
|
* @param string $byday Comma-separated list of days of the week.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_byday($byday) {
|
|
$weekdays = array_keys(self::DAYS_OF_WEEK);
|
|
$days = explode(',', $byday);
|
|
$bydayrules = [];
|
|
foreach ($days as $day) {
|
|
$suffix = substr($day, -2);
|
|
if (!in_array($suffix, $weekdays)) {
|
|
throw new moodle_exception('errorinvalidbydaysuffix', 'calendar');
|
|
}
|
|
|
|
$bydayrule = new stdClass();
|
|
$bydayrule->day = substr($suffix, -2);
|
|
$bydayrule->value = (int)str_replace($suffix, '', $day);
|
|
|
|
$bydayrules[] = $bydayrule;
|
|
}
|
|
|
|
$this->byday = $bydayrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYMONTHDAY rule.
|
|
*
|
|
* The BYMONTHDAY rule part specifies a comma-separated list of days of the month.
|
|
* Valid values are 1 to 31 or -31 to -1. For example, -10 represents the tenth to the last day of the month.
|
|
*
|
|
* @param string $bymonthday Comma-separated list of days of the month.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_bymonthday($bymonthday) {
|
|
$monthdays = explode(',', $bymonthday);
|
|
$bymonthdayrules = [];
|
|
foreach ($monthdays as $day) {
|
|
// Valid values are 1 to 31 or -31 to -1.
|
|
if ($day < -31 || $day > 31 || $day == 0) {
|
|
throw new moodle_exception('errorinvalidbymonthday', 'calendar');
|
|
}
|
|
$bymonthdayrules[] = (int)$day;
|
|
}
|
|
|
|
// Sort these MONTHDAY rules in ascending order.
|
|
sort($bymonthdayrules);
|
|
|
|
$this->bymonthday = $bymonthdayrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYYEARDAY rule.
|
|
*
|
|
* The BYYEARDAY rule part specifies a comma-separated list of days of the year.
|
|
* Valid values are 1 to 366 or -366 to -1. For example, -1 represents the last day of the year (December 31st)
|
|
* and -306 represents the 306th to the last day of the year (March 1st).
|
|
*
|
|
* @param string $byyearday Comma-separated list of days of the year.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_byyearday($byyearday) {
|
|
$yeardays = explode(',', $byyearday);
|
|
$byyeardayrules = [];
|
|
foreach ($yeardays as $day) {
|
|
// Valid values are 1 to 366 or -366 to -1.
|
|
if ($day < -366 || $day > 366 || $day == 0) {
|
|
throw new moodle_exception('errorinvalidbyyearday', 'calendar');
|
|
}
|
|
$byyeardayrules[] = (int)$day;
|
|
}
|
|
$this->byyearday = $byyeardayrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYWEEKNO rule.
|
|
*
|
|
* The BYWEEKNO rule part specifies a comma-separated list of ordinals specifying weeks of the year.
|
|
* Valid values are 1 to 53 or -53 to -1. This corresponds to weeks according to week numbering as defined in [ISO 8601].
|
|
* A week is defined as a seven day period, starting on the day of the week defined to be the week start (see WKST).
|
|
* Week number one of the calendar year is the first week which contains at least four (4) days in that calendar year.
|
|
* This rule part is only valid for YEARLY rules. For example, 3 represents the third week of the year.
|
|
*
|
|
* Note: Assuming a Monday week start, week 53 can only occur when Thursday is January 1 or if it is a leap year and Wednesday
|
|
* is January 1.
|
|
*
|
|
* @param string $byweekno Comma-separated list of number of weeks.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_byweekno($byweekno) {
|
|
$weeknumbers = explode(',', $byweekno);
|
|
$byweeknorules = [];
|
|
foreach ($weeknumbers as $week) {
|
|
// Valid values are 1 to 53 or -53 to -1.
|
|
if ($week < -53 || $week > 53 || $week == 0) {
|
|
throw new moodle_exception('errorinvalidbyweekno', 'calendar');
|
|
}
|
|
$byweeknorules[] = (int)$week;
|
|
}
|
|
$this->byweekno = $byweeknorules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYMONTH rule.
|
|
*
|
|
* The BYMONTH rule part specifies a comma-separated list of months of the year.
|
|
* Valid values are 1 to 12.
|
|
*
|
|
* @param string $bymonth Comma-separated list of months of the year.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_bymonth($bymonth) {
|
|
$months = explode(',', $bymonth);
|
|
$bymonthrules = [];
|
|
foreach ($months as $month) {
|
|
// Valid values are 1 to 12.
|
|
if ($month < 1 || $month > 12) {
|
|
throw new moodle_exception('errorinvalidbymonth', 'calendar');
|
|
}
|
|
$bymonthrules[] = (int)$month;
|
|
}
|
|
$this->bymonth = $bymonthrules;
|
|
}
|
|
|
|
/**
|
|
* Sets the BYSETPOS rule.
|
|
*
|
|
* The BYSETPOS rule part specifies a comma-separated list of values which corresponds to the nth occurrence within the set of
|
|
* events specified by the rule. Valid values are 1 to 366 or -366 to -1.
|
|
* It MUST only be used in conjunction with another BYxxx rule part.
|
|
*
|
|
* For example "the last work day of the month" could be represented as: RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1
|
|
*
|
|
* @param string $bysetpos Comma-separated list of values.
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function set_bysetpos($bysetpos) {
|
|
$setposes = explode(',', $bysetpos);
|
|
$bysetposrules = [];
|
|
foreach ($setposes as $pos) {
|
|
// Valid values are 1 to 366 or -366 to -1.
|
|
if ($pos < -366 || $pos > 366 || $pos == 0) {
|
|
throw new moodle_exception('errorinvalidbysetpos', 'calendar');
|
|
}
|
|
$bysetposrules[] = (int)$pos;
|
|
}
|
|
$this->bysetpos = $bysetposrules;
|
|
}
|
|
|
|
/**
|
|
* Validate the rules as a whole.
|
|
*
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function validate_rules() {
|
|
// UNTIL and COUNT cannot be in the same recurrence rule.
|
|
if (!empty($this->until) && !empty($this->count)) {
|
|
throw new moodle_exception('errorhasuntilandcount', 'calendar');
|
|
}
|
|
|
|
// BYSETPOS only be used in conjunction with another BYxxx rule part.
|
|
if (!empty($this->bysetpos) && empty($this->bymonth) && empty($this->bymonthday) && empty($this->bysecond)
|
|
&& empty($this->byday) && empty($this->byweekno) && empty($this->byhour) && empty($this->byminute)
|
|
&& empty($this->byyearday)) {
|
|
throw new moodle_exception('errormustbeusedwithotherbyrule', 'calendar');
|
|
}
|
|
|
|
// Integer values preceding BYDAY rules can only be present for MONTHLY or YEARLY RRULE.
|
|
foreach ($this->byday as $bydayrule) {
|
|
if (!empty($bydayrule->value) && $this->freq != self::FREQ_MONTHLY && $this->freq != self::FREQ_YEARLY) {
|
|
throw new moodle_exception('errorinvalidbydayprefix', 'calendar');
|
|
}
|
|
}
|
|
|
|
// The BYWEEKNO rule is only valid for YEARLY rules.
|
|
if (!empty($this->byweekno) && $this->freq != self::FREQ_YEARLY) {
|
|
throw new moodle_exception('errornonyearlyfreqwithbyweekno', 'calendar');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates calendar events for the recurring events.
|
|
*
|
|
* @param stdClass $event The parent event.
|
|
* @param int[] $eventtimes The timestamps of the recurring events.
|
|
*/
|
|
protected function create_recurring_events($event, $eventtimes) {
|
|
$count = false;
|
|
if ($this->count) {
|
|
$count = $this->count;
|
|
}
|
|
|
|
foreach ($eventtimes as $time) {
|
|
// Skip if time is the same time with the parent event's timestamp.
|
|
if ($time == $event->timestart) {
|
|
continue;
|
|
}
|
|
|
|
// Decrement count, if set.
|
|
if ($count !== false) {
|
|
$count--;
|
|
if ($count == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Create the recurring event.
|
|
$cloneevent = clone($event);
|
|
$cloneevent->repeatid = $event->id;
|
|
$cloneevent->timestart = $time;
|
|
unset($cloneevent->id);
|
|
// UUID should only be set on the first instance of the recurring events.
|
|
unset($cloneevent->uuid);
|
|
calendar_event::create($cloneevent, false);
|
|
}
|
|
|
|
// If COUNT rule is defined and the number of the generated event times is less than the the COUNT rule,
|
|
// repeat the processing until the COUNT rule is satisfied.
|
|
if ($count !== false && $count > 0) {
|
|
// Set count to the remaining counts.
|
|
$this->count = $count;
|
|
// Clone the original event, but set the timestart to the last generated event time.
|
|
$tmpevent = clone($event);
|
|
$tmpevent->timestart = end($eventtimes);
|
|
// Generate the additional event times.
|
|
$additionaleventtimes = $this->generate_recurring_event_times($tmpevent);
|
|
// Create the additional events.
|
|
$this->create_recurring_events($event, $additionaleventtimes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates recurring events based on the parent event and the RRULE set.
|
|
*
|
|
* If multiple BYxxx rule parts are specified, then after evaluating the specified FREQ and INTERVAL rule parts,
|
|
* the BYxxx rule parts are applied to the current set of evaluated occurrences in the following order:
|
|
* BYMONTH, BYWEEKNO, BYYEARDAY, BYMONTHDAY, BYDAY, BYHOUR, BYMINUTE, BYSECOND and BYSETPOS;
|
|
* then COUNT and UNTIL are evaluated.
|
|
*
|
|
* @param stdClass $event The event object.
|
|
* @return array The list of timestamps that obey the given RRULE.
|
|
*/
|
|
protected function generate_recurring_event_times($event) {
|
|
$interval = $this->get_interval();
|
|
|
|
// Candidate event times.
|
|
$eventtimes = [];
|
|
|
|
$eventdatetime = new DateTime(date('Y-m-d H:i:s', $event->timestart));
|
|
|
|
$until = null;
|
|
if (empty($this->count)) {
|
|
if ($this->until) {
|
|
$until = $this->until;
|
|
} else {
|
|
// Forever event. However, since there's no such thing as 'forever' (at least not in Moodle),
|
|
// we only repeat the events until 10 years from the current time.
|
|
$untildate = new DateTime();
|
|
$foreverinterval = new DateInterval('P' . self::TIME_UNLIMITED_YEARS . 'Y');
|
|
$untildate->add($foreverinterval);
|
|
$until = $untildate->getTimestamp();
|
|
}
|
|
} else {
|
|
// If count is defined, let's define a tentative until date. We'll just trim the number of events later.
|
|
$untildate = clone($eventdatetime);
|
|
$count = $this->count;
|
|
while ($count >= 0) {
|
|
$untildate->add($interval);
|
|
$count--;
|
|
}
|
|
$until = $untildate->getTimestamp();
|
|
}
|
|
|
|
// No filters applied. Generate recurring events right away.
|
|
if (!$this->has_by_rules()) {
|
|
// Get initial list of prospective events.
|
|
$tmpstart = clone($eventdatetime);
|
|
while ($tmpstart->getTimestamp() <= $until) {
|
|
$eventtimes[] = $tmpstart->getTimestamp();
|
|
$tmpstart->add($interval);
|
|
}
|
|
return $eventtimes;
|
|
}
|
|
|
|
// Get all of potential dates covered by the periods from the event's start date until the last.
|
|
$dailyinterval = new DateInterval('P1D');
|
|
$boundslist = $this->get_period_bounds_list($eventdatetime->getTimestamp(), $until);
|
|
foreach ($boundslist as $bounds) {
|
|
$tmpdate = new DateTime(date('Y-m-d H:i:s', $bounds->start));
|
|
while ($tmpdate->getTimestamp() >= $bounds->start && $tmpdate->getTimestamp() < $bounds->next) {
|
|
$eventtimes[] = $tmpdate->getTimestamp();
|
|
$tmpdate->add($dailyinterval);
|
|
}
|
|
}
|
|
|
|
// Evaluate BYMONTH rules.
|
|
$eventtimes = $this->filter_by_month($eventtimes);
|
|
|
|
// Evaluate BYWEEKNO rules.
|
|
$eventtimes = $this->filter_by_weekno($eventtimes);
|
|
|
|
// Evaluate BYYEARDAY rules.
|
|
$eventtimes = $this->filter_by_yearday($eventtimes);
|
|
|
|
// If BYYEARDAY, BYMONTHDAY and BYDAY are not set, default to BYMONTHDAY based on the DTSTART's day.
|
|
if ($this->freq != self::FREQ_DAILY && empty($this->byyearday) && empty($this->bymonthday) && empty($this->byday)) {
|
|
$this->bymonthday = [$eventdatetime->format('j')];
|
|
}
|
|
|
|
// Evaluate BYMONTHDAY rules.
|
|
$eventtimes = $this->filter_by_monthday($eventtimes);
|
|
|
|
// Evaluate BYDAY rules.
|
|
$eventtimes = $this->filter_by_day($event, $eventtimes, $until);
|
|
|
|
// Evaluate BYHOUR rules.
|
|
$eventtimes = $this->apply_hour_minute_second_rules($eventdatetime, $eventtimes);
|
|
|
|
// Evaluate BYSETPOS rules.
|
|
$eventtimes = $this->filter_by_setpos($event, $eventtimes, $until);
|
|
|
|
// Sort event times in ascending order.
|
|
sort($eventtimes);
|
|
|
|
// Finally, filter candidate event times to make sure they are within the DTSTART and UNTIL/tentative until boundaries.
|
|
$results = [];
|
|
foreach ($eventtimes as $time) {
|
|
// Skip out-of-range events.
|
|
if ($time < $eventdatetime->getTimestamp()) {
|
|
continue;
|
|
}
|
|
// End if event time is beyond the until limit.
|
|
if ($time > $until) {
|
|
break;
|
|
}
|
|
$results[] = $time;
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Generates a DateInterval object based on the FREQ and INTERVAL rules.
|
|
*
|
|
* @return DateInterval
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function get_interval() {
|
|
$intervalspec = null;
|
|
switch ($this->freq) {
|
|
case self::FREQ_YEARLY:
|
|
$intervalspec = 'P' . $this->interval . 'Y';
|
|
break;
|
|
case self::FREQ_MONTHLY:
|
|
$intervalspec = 'P' . $this->interval . 'M';
|
|
break;
|
|
case self::FREQ_WEEKLY:
|
|
$intervalspec = 'P' . $this->interval . 'W';
|
|
break;
|
|
case self::FREQ_DAILY:
|
|
$intervalspec = 'P' . $this->interval . 'D';
|
|
break;
|
|
case self::FREQ_HOURLY:
|
|
$intervalspec = 'PT' . $this->interval . 'H';
|
|
break;
|
|
case self::FREQ_MINUTELY:
|
|
$intervalspec = 'PT' . $this->interval . 'M';
|
|
break;
|
|
case self::FREQ_SECONDLY:
|
|
$intervalspec = 'PT' . $this->interval . 'S';
|
|
break;
|
|
default:
|
|
// We should never get here, something is very wrong.
|
|
throw new moodle_exception('errorrrulefreq', 'calendar');
|
|
}
|
|
|
|
return new DateInterval($intervalspec);
|
|
}
|
|
|
|
/**
|
|
* Determines whether the RRULE has BYxxx rules or not.
|
|
*
|
|
* @return bool True if there is one or more BYxxx rules to process. False, otherwise.
|
|
*/
|
|
protected function has_by_rules() {
|
|
return !empty($this->bymonth) || !empty($this->bymonthday) || !empty($this->bysecond) || !empty($this->byday)
|
|
|| !empty($this->byweekno) || !empty($this->byhour) || !empty($this->byminute) || !empty($this->byyearday);
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYMONTH rule.
|
|
*
|
|
* @param int[] $eventdates Timestamps of event times to be filtered.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_month($eventdates) {
|
|
if (empty($this->bymonth)) {
|
|
return $eventdates;
|
|
}
|
|
|
|
$filteredbymonth = [];
|
|
foreach ($eventdates as $time) {
|
|
foreach ($this->bymonth as $month) {
|
|
$prospectmonth = date('n', $time);
|
|
if ($month == $prospectmonth) {
|
|
$filteredbymonth[] = $time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return $filteredbymonth;
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYWEEKNO rule.
|
|
*
|
|
* @param int[] $eventdates Timestamps of event times to be filtered.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_weekno($eventdates) {
|
|
if (empty($this->byweekno)) {
|
|
return $eventdates;
|
|
}
|
|
|
|
$filteredbyweekno = [];
|
|
$weeklyinterval = null;
|
|
foreach ($eventdates as $time) {
|
|
$tmpdate = new DateTime(date('Y-m-d H:i:s', $time));
|
|
foreach ($this->byweekno as $weekno) {
|
|
if ($weekno > 0) {
|
|
if ($tmpdate->format('W') == $weekno) {
|
|
$filteredbyweekno[] = $time;
|
|
break;
|
|
}
|
|
} else if ($weekno < 0) {
|
|
if ($weeklyinterval === null) {
|
|
$weeklyinterval = new DateInterval('P1W');
|
|
}
|
|
$weekstart = new DateTime();
|
|
$weekstart->setISODate($tmpdate->format('Y'), $weekno);
|
|
$weeknext = clone($weekstart);
|
|
$weeknext->add($weeklyinterval);
|
|
|
|
$tmptimestamp = $tmpdate->getTimestamp();
|
|
|
|
if ($tmptimestamp >= $weekstart->getTimestamp() && $tmptimestamp < $weeknext->getTimestamp()) {
|
|
$filteredbyweekno[] = $time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $filteredbyweekno;
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYYEARDAY rule.
|
|
*
|
|
* @param int[] $eventdates Timestamps of event times to be filtered.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_yearday($eventdates) {
|
|
if (empty($this->byyearday)) {
|
|
return $eventdates;
|
|
}
|
|
|
|
$filteredbyyearday = [];
|
|
foreach ($eventdates as $time) {
|
|
$tmpdate = new DateTime(date('Y-m-d', $time));
|
|
|
|
foreach ($this->byyearday as $yearday) {
|
|
$dayoffset = abs($yearday) - 1;
|
|
$dayoffsetinterval = new DateInterval("P{$dayoffset}D");
|
|
|
|
if ($yearday > 0) {
|
|
$tmpyearday = (int)$tmpdate->format('z') + 1;
|
|
if ($tmpyearday == $yearday) {
|
|
$filteredbyyearday[] = $time;
|
|
break;
|
|
}
|
|
} else if ($yearday < 0) {
|
|
$yeardaydate = new DateTime('last day of ' . $tmpdate->format('Y'));
|
|
$yeardaydate->sub($dayoffsetinterval);
|
|
|
|
$tmpdate->getTimestamp();
|
|
|
|
if ($yeardaydate->format('z') == $tmpdate->format('z')) {
|
|
$filteredbyyearday[] = $time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $filteredbyyearday;
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYMONTHDAY rule.
|
|
*
|
|
* @param int[] $eventdates The event times to be filtered.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_monthday($eventdates) {
|
|
if (empty($this->bymonthday)) {
|
|
return $eventdates;
|
|
}
|
|
|
|
$filteredbymonthday = [];
|
|
foreach ($eventdates as $time) {
|
|
$eventdatetime = new DateTime(date('Y-m-d', $time));
|
|
foreach ($this->bymonthday as $monthday) {
|
|
// Days to add/subtract.
|
|
$daysoffset = abs($monthday) - 1;
|
|
$dayinterval = new DateInterval("P{$daysoffset}D");
|
|
|
|
if ($monthday > 0) {
|
|
if ($eventdatetime->format('j') == $monthday) {
|
|
$filteredbymonthday[] = $time;
|
|
break;
|
|
}
|
|
} else if ($monthday < 0) {
|
|
$tmpdate = clone($eventdatetime);
|
|
// Reset to the first day of the month.
|
|
$tmpdate->modify('first day of this month');
|
|
// Then go to last day of the month.
|
|
$tmpdate->modify('last day of this month');
|
|
if ($daysoffset > 0) {
|
|
// Then subtract the monthday value.
|
|
$tmpdate->sub($dayinterval);
|
|
}
|
|
if ($eventdatetime->format('j') == $tmpdate->format('j')) {
|
|
$filteredbymonthday[] = $time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $filteredbymonthday;
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYDAY rule.
|
|
*
|
|
* @param stdClass $event The parent event.
|
|
* @param int[] $eventdates The event times to be filtered.
|
|
* @param int $until Event times generation limit date.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_day($event, $eventdates, $until) {
|
|
if (empty($this->byday)) {
|
|
return $eventdates;
|
|
}
|
|
|
|
$filteredbyday = [];
|
|
|
|
$bounds = $this->get_period_bounds_list($event->timestart, $until);
|
|
|
|
$nextmonthinterval = new DateInterval('P1M');
|
|
foreach ($eventdates as $time) {
|
|
$tmpdatetime = new DateTime(date('Y-m-d', $time));
|
|
|
|
foreach ($this->byday as $day) {
|
|
$dayname = self::DAYS_OF_WEEK[$day->day];
|
|
|
|
// Skip if they day name of the event time does not match the day part of the BYDAY rule.
|
|
if ($tmpdatetime->format('l') !== $dayname) {
|
|
continue;
|
|
}
|
|
|
|
if (empty($day->value)) {
|
|
// No modifier value. Applies to all weekdays of the given period.
|
|
$filteredbyday[] = $time;
|
|
break;
|
|
} else if ($day->value > 0) {
|
|
// Positive value.
|
|
if ($this->freq === self::FREQ_YEARLY && empty($this->bymonth)) {
|
|
// Get the first day of the year.
|
|
$firstdaydate = $tmpdatetime->format('Y') . '-01-01';
|
|
} else {
|
|
// Get the first day of the month.
|
|
$firstdaydate = $tmpdatetime->format('Y-m') . '-01';
|
|
}
|
|
$expecteddate = new DateTime($firstdaydate);
|
|
$count = $day->value;
|
|
// Get the nth week day of the year/month.
|
|
$expecteddate->modify("+$count $dayname");
|
|
if ($expecteddate->format('Y-m-d') === $tmpdatetime->format('Y-m-d')) {
|
|
$filteredbyday[] = $time;
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
// Negative value.
|
|
$count = $day->value;
|
|
if ($this->freq === self::FREQ_YEARLY && empty($this->bymonth)) {
|
|
// The -Nth week day of the year.
|
|
$eventyear = (int)$tmpdatetime->format('Y');
|
|
// Get temporary DateTime object starting from the first day of the next year.
|
|
$expecteddate = new DateTime((++$eventyear) . '-01-01');
|
|
while ($count < 0) {
|
|
// Get the start of the previous week.
|
|
$expecteddate->modify('last ' . $this->wkst);
|
|
$tmpexpecteddate = clone($expecteddate);
|
|
if ($tmpexpecteddate->format('l') !== $dayname) {
|
|
$tmpexpecteddate->modify('next ' . $dayname);
|
|
}
|
|
if ($this->in_bounds($tmpexpecteddate->getTimestamp(), $bounds)) {
|
|
$expecteddate = $tmpexpecteddate;
|
|
$count++;
|
|
}
|
|
}
|
|
if ($expecteddate->format('l') !== $dayname) {
|
|
$expecteddate->modify('next ' . $dayname);
|
|
}
|
|
if ($expecteddate->getTimestamp() == $time) {
|
|
$filteredbyday[] = $time;
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
// The -Nth week day of the month.
|
|
$expectedmonthyear = $tmpdatetime->format('F Y');
|
|
$expecteddate = new DateTime("first day of $expectedmonthyear");
|
|
$expecteddate->add($nextmonthinterval);
|
|
while ($count < 0) {
|
|
// Get the start of the previous week.
|
|
$expecteddate->modify('last ' . $this->wkst);
|
|
$tmpexpecteddate = clone($expecteddate);
|
|
if ($tmpexpecteddate->format('l') !== $dayname) {
|
|
$tmpexpecteddate->modify('next ' . $dayname);
|
|
}
|
|
if ($this->in_bounds($tmpexpecteddate->getTimestamp(), $bounds)) {
|
|
$expecteddate = $tmpexpecteddate;
|
|
$count++;
|
|
}
|
|
}
|
|
|
|
// Compare the expected date with the event's timestamp.
|
|
if ($expecteddate->getTimestamp() == $time) {
|
|
$filteredbyday[] = $time;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $filteredbyday;
|
|
}
|
|
|
|
/**
|
|
* Applies BYHOUR, BYMINUTE and BYSECOND rules to the calculated event dates.
|
|
* Defaults to the DTSTART's hour/minute/second component when not defined.
|
|
*
|
|
* @param DateTime $eventdatetime The parent event DateTime object pertaining to the DTSTART.
|
|
* @param int[] $eventdates Array of candidate event date timestamps.
|
|
* @return array List of updated event timestamps that contain the time component of the event times.
|
|
*/
|
|
protected function apply_hour_minute_second_rules(DateTime $eventdatetime, $eventdates) {
|
|
// If BYHOUR rules are not set, set the hour of the events from the DTSTART's hour component.
|
|
if (empty($this->byhour)) {
|
|
$this->byhour = [$eventdatetime->format('G')];
|
|
}
|
|
// If BYMINUTE rules are not set, set the hour of the events from the DTSTART's minute component.
|
|
if (empty($this->byminute)) {
|
|
$this->byminute = [(int)$eventdatetime->format('i')];
|
|
}
|
|
// If BYSECOND rules are not set, set the hour of the events from the DTSTART's second component.
|
|
if (empty($this->bysecond)) {
|
|
$this->bysecond = [(int)$eventdatetime->format('s')];
|
|
}
|
|
|
|
$results = [];
|
|
foreach ($eventdates as $time) {
|
|
$datetime = new DateTime(date('Y-m-d', $time));
|
|
foreach ($this->byhour as $hour) {
|
|
foreach ($this->byminute as $minute) {
|
|
foreach ($this->bysecond as $second) {
|
|
$datetime->setTime($hour, $minute, $second);
|
|
$results[] = $datetime->getTimestamp();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Filter event times based on the BYSETPOS rule.
|
|
*
|
|
* @param stdClass $event The parent event.
|
|
* @param int[] $eventtimes The event times to be filtered.
|
|
* @param int $until Event times generation limit date.
|
|
* @return int[] Array of filtered timestamps.
|
|
*/
|
|
protected function filter_by_setpos($event, $eventtimes, $until) {
|
|
if (empty($this->bysetpos)) {
|
|
return $eventtimes;
|
|
}
|
|
|
|
$filteredbysetpos = [];
|
|
$boundslist = $this->get_period_bounds_list($event->timestart, $until);
|
|
sort($eventtimes);
|
|
foreach ($boundslist as $bounds) {
|
|
// Generate a list of candidate event times based that are covered in a period's bounds.
|
|
$prospecttimes = [];
|
|
foreach ($eventtimes as $time) {
|
|
if ($time >= $bounds->start && $time < $bounds->next) {
|
|
$prospecttimes[] = $time;
|
|
}
|
|
}
|
|
if (empty($prospecttimes)) {
|
|
continue;
|
|
}
|
|
// Add the event times that correspond to the set position rule into the filtered results.
|
|
foreach ($this->bysetpos as $pos) {
|
|
$tmptimes = $prospecttimes;
|
|
if ($pos < 0) {
|
|
rsort($tmptimes);
|
|
}
|
|
$index = abs($pos) - 1;
|
|
if (isset($tmptimes[$index])) {
|
|
$filteredbysetpos[] = $tmptimes[$index];
|
|
}
|
|
}
|
|
}
|
|
return $filteredbysetpos;
|
|
}
|
|
|
|
/**
|
|
* Gets the list of period boundaries covered by the recurring events.
|
|
*
|
|
* @param int $eventtime The event timestamp.
|
|
* @param int $until The end timestamp.
|
|
* @return array List of period bounds, with start and next properties.
|
|
*/
|
|
protected function get_period_bounds_list($eventtime, $until) {
|
|
$interval = $this->get_interval();
|
|
$periodbounds = $this->get_period_boundaries($eventtime);
|
|
$periodstart = $periodbounds['start'];
|
|
$periodafter = $periodbounds['next'];
|
|
$bounds = [];
|
|
if ($until !== null) {
|
|
while ($periodstart->getTimestamp() < $until) {
|
|
$bounds[] = (object)[
|
|
'start' => $periodstart->getTimestamp(),
|
|
'next' => $periodafter->getTimestamp()
|
|
];
|
|
$periodstart->add($interval);
|
|
$periodafter->add($interval);
|
|
}
|
|
} else {
|
|
$count = $this->count;
|
|
while ($count > 0) {
|
|
$bounds[] = (object)[
|
|
'start' => $periodstart->getTimestamp(),
|
|
'next' => $periodafter->getTimestamp()
|
|
];
|
|
$periodstart->add($interval);
|
|
$periodafter->add($interval);
|
|
$count--;
|
|
}
|
|
}
|
|
|
|
return $bounds;
|
|
}
|
|
|
|
/**
|
|
* Determine whether the date-time in question is within the bounds of the periods that are covered by the RRULE.
|
|
*
|
|
* @param int $time The timestamp to be evaluated.
|
|
* @param array $bounds Array of period boundaries covered by the RRULE.
|
|
* @return bool
|
|
*/
|
|
protected function in_bounds($time, $bounds) {
|
|
foreach ($bounds as $bound) {
|
|
if ($time >= $bound->start && $time < $bound->next) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determines the start and end DateTime objects that serve as references to determine whether a calculated event timestamp
|
|
* falls on the period defined by these DateTimes objects.
|
|
*
|
|
* @param int $eventtime Unix timestamp of the event time.
|
|
* @return DateTime[]
|
|
* @throws moodle_exception
|
|
*/
|
|
protected function get_period_boundaries($eventtime) {
|
|
$nextintervalspec = null;
|
|
|
|
switch ($this->freq) {
|
|
case self::FREQ_YEARLY:
|
|
$nextintervalspec = 'P1Y';
|
|
$timestart = date('Y-01-01', $eventtime);
|
|
break;
|
|
case self::FREQ_MONTHLY:
|
|
$nextintervalspec = 'P1M';
|
|
$timestart = date('Y-m-01', $eventtime);
|
|
break;
|
|
case self::FREQ_WEEKLY:
|
|
$nextintervalspec = 'P1W';
|
|
if (date('l', $eventtime) === $this->wkst) {
|
|
$weekstarttime = $eventtime;
|
|
} else {
|
|
$weekstarttime = strtotime('last ' . $this->wkst, $eventtime);
|
|
}
|
|
$timestart = date('Y-m-d', $weekstarttime);
|
|
break;
|
|
case self::FREQ_DAILY:
|
|
$nextintervalspec = 'P1D';
|
|
$timestart = date('Y-m-d', $eventtime);
|
|
break;
|
|
case self::FREQ_HOURLY:
|
|
$nextintervalspec = 'PT1H';
|
|
$timestart = date('Y-m-d H:00:00', $eventtime);
|
|
break;
|
|
case self::FREQ_MINUTELY:
|
|
$nextintervalspec = 'PT1M';
|
|
$timestart = date('Y-m-d H:i:00', $eventtime);
|
|
break;
|
|
case self::FREQ_SECONDLY:
|
|
$nextintervalspec = 'PT1S';
|
|
$timestart = date('Y-m-d H:i:s', $eventtime);
|
|
break;
|
|
default:
|
|
// We should never get here, something is very wrong.
|
|
throw new moodle_exception('errorrrulefreq', 'calendar');
|
|
}
|
|
|
|
$eventstart = new DateTime($timestart);
|
|
$eventnext = clone($eventstart);
|
|
$nextinterval = new DateInterval($nextintervalspec);
|
|
$eventnext->add($nextinterval);
|
|
|
|
return [
|
|
'start' => $eventstart,
|
|
'next' => $eventnext,
|
|
];
|
|
}
|
|
}
|
|
|