This file is part of ILIAS, a powerful learning management system published by ILIAS open source e-Learning e.V. More...

Collaboration diagram for ilCalendarRecurrenceCalculator:

Public Member Functions
	__construct (ilDatePeriod $entry, ilCalendarRecurrenceCalculation $rec)

	calculateDateList (ilDateTime $a_start, ilDateTime $a_end, int $a_limit=-1)
	calculate date list More...

Protected Member Functions
	getDuration ()
	Get duration of event. More...

	applyDurationPeriod (ilDateList $list, ilDateTime $start, ilDateTime $end)
	Apply duration period. More...

	adjustTimeZones (ilDateTime $a_start, ilDateTime $a_end)
	Adjust timezone. More...

	optimizeStartingTime ()

	optimizeEndingTime ()

	incrementByFrequency (ilDateTime $start)

	applyBYMONTHRules (ilDateList $list)

	applyBYWEEKNORules (ilDateList $list)
	Apply BYWEEKNO rules (1 to 53 and -1 to -53). More...

	applyBYYEARDAYRules (ilDateList $list)

	applyBYMONTHDAYRules (ilDateList $list)

	applyBYDAYRules (ilDateList $list)

	getYearWeekDays (ilDateTime $seed)
	get a list of year week days according to the BYMONTH rule More...

	getMonthWeekDays (int $year, int $month)

	getWeekWeekDays (array $seed_info)
	get weedays of week More...

	applyBYSETPOSRules (ilDateList $list)
	Apply BYSETPOST rules. More...

	applyLimits (ilDateList $list)
	Apply limits (count or until) More...

	applyExclusionDates ()

	initDateList ()

	createDate ($a_date, $a_format_type=IL_CAL_UNIX)

	validateRecurrence ()

Protected Attributes
string	$timezone = ilTimeZone::UTC

ilLogger	$log

bool	$limit_reached = false

ilDateList	$valid_dates = null

ilDateTime	$period_start = null

ilDateTime	$period_end = null

ilDateTime	$start = null

ilDatePeriod	$event

ilCalendarRecurrenceCalculation	$recurrence

int	$duration = 0

string	$frequence_context = ''

Detailed Description

This file is part of ILIAS, a powerful learning management system published by ILIAS open source e-Learning e.V.

ILIAS is licensed with the GPL-3.0, see https://www.gnu.org/licenses/gpl-3.0.en.html You should have received a copy of said license along with the source code, too.

If this is not the case or you just want to try ILIAS, you'll find us at: https://www.ilias.de https://github.com/ILIAS-eLearning Calculates an ilDateList for a given calendar entry and recurrence rule.

Author: Stefan Meyer meyer.nosp@m.@lei.nosp@m.fos.c.nosp@m.om

Definition at line 27 of file class.ilCalendarRecurrenceCalculator.php.

Constructor & Destructor Documentation

◆ __construct()

ilCalendarRecurrenceCalculator::__construct	(	ilDatePeriod	$entry,
		ilCalendarRecurrenceCalculation	$rec
	)

Definition at line 43 of file class.ilCalendarRecurrenceCalculator.php.

References $GLOBALS, ilDatePeriod\getEnd(), ilDatePeriod\getStart(), IL_CAL_UNIX, and ILIAS\Repository\int().

     {
         $this->log = $GLOBALS['DIC']->logger()->cal();
         $this->event = $entry;
         $this->recurrence = $rec;
 
         $this->duration = (int) $entry->getEnd()->get(IL_CAL_UNIX) - (int) $entry->getStart()->get(IL_CAL_UNIX);
     }

Here is the call graph for this function:

Member Function Documentation

◆ adjustTimeZones()

ilCalendarRecurrenceCalculator::adjustTimeZones	(	ilDateTime	$a_start,
		ilDateTime	$a_end
	)

protected

Adjust timezone.

Definition at line 179 of file class.ilCalendarRecurrenceCalculator.php.

References Vendor\Package\$e, ilTimeZone\_setDefaultTimeZone(), ILIAS\Repository\event(), ilDateTime\switchTimeZone(), and ilTimeZone\UTC.

Referenced by calculateDateList().

                                                                               : void
     {
         $this->timezone = $this->event->isFullday() ? ilTimeZone::UTC : $this->recurrence->getTimeZone();
         ilTimeZone::_setDefaultTimeZone($this->timezone);
 
         $this->period_start = clone $a_start;
         $this->period_end = clone $a_end;
         $this->start = clone $this->event->getStart();
 
         try {
             if ($this->event->isFullday()) {
                 $this->period_start->switchTimeZone(ilTimeZone::UTC);
                 $this->period_end->switchTimeZone(ilTimeZone::UTC);
                 $this->start->switchTimeZone(ilTimeZone::UTC);
             } else {
                 $this->period_start->switchTimeZone($this->recurrence->getTimeZone());
                 $this->period_end->switchTimeZone($this->recurrence->getTimeZone());
                 $this->start->switchTimeZone($this->recurrence->getTimeZone());
             }
             return;
         } catch (ilDateTimeException $e) {
             $this->log->debug(': ' . $e->getMessage());
             return;
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYDAYRules()

ilCalendarRecurrenceCalculator::applyBYDAYRules ( ilDateList $list )

protected

Definition at line 480 of file class.ilCalendarRecurrenceCalculator.php.

References $start, createDate(), ilCalendarRecurrence\FREQ_DAILY, ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_WEEKLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateList\get(), getMonthWeekDays(), getWeekWeekDays(), getYearWeekDays(), IL_CAL_DAY, IL_CAL_FKT_DATE, IL_CAL_FKT_GETDATE, ilDateTime\increment(), initDateList(), and ILIAS\Repository\int().

Referenced by calculateDateList().

                                                         : ilDateList
     {
         // return unmodified, if no byday rules are available
         if (!$this->recurrence->getBYDAYList()) {
             return $list;
         }
 
         $days_list = $this->initDateList();
 
         // generate a list of e.g all Sundays for the given year
         // or e.g a list of all week days in a give month (FREQ = MONTHLY,WEEKLY or DAILY)
         $day_array = [];
         foreach ($list->get() as $seed) {
             $seed_info = $seed->get(IL_CAL_FKT_GETDATE);
 
             // TODO: maybe not correct in dst cases
             $date_info = $seed->get(IL_CAL_FKT_GETDATE);
             $date_info['mday'] = 1;
             $date_info['mon'] = 1;
             $start = $this->createDate($date_info, IL_CAL_FKT_GETDATE);
 
             switch ($this->frequence_context) {
                 case ilCalendarRecurrence::FREQ_YEARLY:
                     $day_array = $this->getYearWeekDays($seed);
                     break;
 
                 case ilCalendarRecurrence::FREQ_MONTHLY:
                     $day_array = $this->getMonthWeekDays($seed_info['year'], $seed_info['mon']);
                     break;
 
                 case ilCalendarRecurrence::FREQ_WEEKLY:
                     // TODO or RFC bug: FREQ>WEEKLY;BYMONTH=1;BYDAY=FR returns FR 1.2.2008
                     // Ical says: apply BYMONTH rules and after that apply byday rules on that date list.
                     $day_array = $this->getWeekWeekDays($seed_info);
                     break;
 
                 case ilCalendarRecurrence::FREQ_DAILY:
                     $day_array[strtoupper(substr($seed->get(IL_CAL_FKT_DATE, 'D'), 0, 2))] = array($seed_info['yday']);
                     break;
 
             }
             foreach ($this->recurrence->getBYDAYList() as $byday) {
                 $year_day = array();
                 $day = strtoupper(substr($byday, -2));
                 $num_by_day = (int) $byday;
 
                 if ($num_by_day) {
                     if ($num_by_day > 0) {
                         if (isset($day_array[$day][$num_by_day - 1])) {
                             $year_day = array($day_array[$day][$num_by_day - 1]);
                         }
                     } elseif (isset($day_array[$day][count($day_array[$day]) + $num_by_day])) {
                         $year_day = array($day_array[$day][count($day_array[$day]) + $num_by_day]);
                     }
                 } elseif (isset($day_array[$day])) {
                     $year_day = $day_array[$day];
                 }
                 foreach ($year_day as $day) {
                     switch ($this->frequence_context) {
                         case ilCalendarRecurrence::FREQ_WEEKLY:
                         case ilCalendarRecurrence::FREQ_DAILY:
                         case ilCalendarRecurrence::FREQ_MONTHLY:
                         case ilCalendarRecurrence::FREQ_YEARLY:
                             $tmp_date = clone $start;
                             $tmp_date->increment(IL_CAL_DAY, $day);
                             $days_list->add($tmp_date);
                             break;
                     }
                 }
             }
         }
         return $days_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYMONTHDAYRules()

ilCalendarRecurrenceCalculator::applyBYMONTHDAYRules ( ilDateList $list )

protected

Definition at line 399 of file class.ilCalendarRecurrenceCalculator.php.

References $i, ilTimeZone\_getInstance(), ilCalendarUtil\_getMaxDayOfMonth(), createDate(), ilDateTime\DAY, ILIAS\Repository\event(), ilCalendarRecurrence\FREQ_DAILY, ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_WEEKLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateList\get(), IL_CAL_FKT_DATE, IL_CAL_UNIX, initDateList(), and ILIAS\Repository\int().

Referenced by calculateDateList().

                                                              : ilDateList
     {
         // return unmodified, if no byweekno rules are available
         if (!$this->recurrence->getBYMONTHDAYList()) {
             return $list;
         }
         $days_list = $this->initDateList();
         foreach ($list->get() as $seed) {
             $num_days = ilCalendarUtil::_getMaxDayOfMonth(
                 (int) $seed->get(IL_CAL_FKT_DATE, 'Y', $this->timezone),
                 (int) $seed->get(IL_CAL_FKT_DATE, 'n', $this->timezone)
             );
             foreach ($this->recurrence->getBYMONTHDAYList() as $bymonth_no) {
                 $day_no = $bymonth_no < 0 ? ($num_days + $bymonth_no + 1) : $bymonth_no;
                 if ($this->frequence_context != ilCalendarRecurrence::FREQ_YEARLY) {
                     if ($day_no < 1 or $day_no > $num_days) {
                         $this->log->debug(': Ignoring BYMONTHDAY rule: ' . $day_no . ' for month ' .
                             $seed->get(IL_CAL_FKT_DATE, 'M', $this->timezone));
                         continue;
                     }
                 }
                 $day_diff = $day_no - $seed->get(IL_CAL_FKT_DATE, 'j', $this->timezone);
                 $new_day = $this->createDate($seed->get(IL_CAL_UNIX, '', $this->timezone));
                 $new_day->increment(ilDateTime::DAY, $day_diff);
 
                 switch ($this->frequence_context) {
                     case ilCalendarRecurrence::FREQ_DAILY:
                         // Check if day matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'j', $this->timezone) == $day_no) {
                             $days_list->add($new_day);
                         }
                         break;
 
                     case ilCalendarRecurrence::FREQ_WEEKLY:
                         // Check if week matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'W', $this->timezone) == $new_day->get(
                             IL_CAL_FKT_DATE,
                             'W',
                             $this->timezone
                         )) {
                             $days_list->add($new_day);
                         }
                         break;
 
                     case ilCalendarRecurrence::FREQ_MONTHLY:
                         // seed and new day are in the same month.
                         $days_list->add($new_day);
                         break;
 
                     case ilCalendarRecurrence::FREQ_YEARLY:
                         $h = (int) ($this->event->isFullday() ? 0 : $seed->get(IL_CAL_FKT_DATE, 'H', $this->timezone));
                         $i = (int) ($this->event->isFullday() ? 0 : $seed->get(IL_CAL_FKT_DATE, 'i', $this->timezone));
                         $s = (int) ($this->event->isFullday() ? 0 : $seed->get(IL_CAL_FKT_DATE, 's', $this->timezone));
                         $y = (int) $seed->get(IL_CAL_FKT_DATE, 'Y', $this->timezone);
 
                         // TODO: the chosen monthday has to added to all months
                         for ($month = 1; $month <= 12; $month++) {
                             $num_days = ilCalendarUtil::_getMaxDayOfMonth(
                                 $y,
                                 $month
                             );
                             $day_no = $bymonth_no < 0 ? ($num_days + $bymonth_no + 1) : $bymonth_no;
                             if ($day_no < 1 or $day_no > $num_days) {
                                 $this->log->debug(': Ignoring BYMONTHDAY rule: ' . $day_no . ' for month ' . $month);
                             } else {
                                 $tz_obj = ilTimeZone::_getInstance($this->timezone);
                                 $tz_obj->switchTZ();
                                 $unix = mktime($h, $i, $s, $month, $day_no, $y);
                                 $tz_obj->restoreTZ();
                                 $new_day = $this->createDate($unix);
                                 $days_list->add($new_day);
                             }
                         }
                         break;
                 }
             }
         }
         $this->frequence_context = ilCalendarRecurrence::FREQ_DAILY;
         return $days_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYMONTHRules()

ilCalendarRecurrenceCalculator::applyBYMONTHRules ( ilDateList $list )

protected

Definition at line 257 of file class.ilCalendarRecurrenceCalculator.php.

References createDate(), ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateList\get(), IL_CAL_FKT_DATE, IL_CAL_UNIX, initDateList(), and ilDateTime\MONTH.

Referenced by calculateDateList().

                                                           : ilDateList
     {
         // return unmodified, if no bymonth rules are available
         if (!$this->recurrence->getBYMONTHList()) {
             return $list;
         }
         $month_list = $this->initDateList();
         foreach ($list->get() as $date) {
             foreach ($this->recurrence->getBYMONTHList() as $month) {
                 // YEARLY rules extend the seed to every month given in the BYMONTH rule
                 // Rules < YEARLY must match the month of the seed
                 if ($this->recurrence->getFrequenceType() == ilCalendarRecurrence::FREQ_YEARLY) {
                     $month_date = $this->createDate($date->get(IL_CAL_UNIX, '', $this->timezone));
                     $month_date->increment(
                         ilDateTime::MONTH,
                         -($date->get(IL_CAL_FKT_DATE, 'n', $this->timezone) - $month)
                     );
 
                     #echo "BYMONTH: ".$month_date;
                     $month_list->add($month_date);
                 } elseif ($date->get(IL_CAL_FKT_DATE, 'n', $this->timezone) == $month) {
                     $month_list->add($date);
                 }
             }
         }
         // decrease the frequence_context for YEARLY rules
         if ($this->recurrence->getFrequenceType() == ilCalendarRecurrence::FREQ_YEARLY) {
             $this->frequence_context = ilCalendarRecurrence::FREQ_MONTHLY;
         }
         return $month_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYSETPOSRules()

ilCalendarRecurrenceCalculator::applyBYSETPOSRules ( ilDateList $list )

protected

Apply BYSETPOST rules.

Definition at line 628 of file class.ilCalendarRecurrenceCalculator.php.

References ilDateList\get(), ilDateList\getAtPosition(), initDateList(), and ilDateList\sort().

Referenced by calculateDateList().

                                                            : ilDateList
     {
         // return unmodified, if no bysetpos rules are available
         if (!$this->recurrence->getBYSETPOSList()) {
             return $list;
         }
         $pos_list = $this->initDateList();
         $list->sort();
         $candidates = $list->get();
         $candidates_count = count($candidates);
         foreach ($this->recurrence->getBYSETPOSList() as $position) {
             if ($position > 0 and $date = $list->getAtPosition($position)) {
                 $pos_list->add($date);
             }
             if ($position < 0 and $date = $list->getAtPosition($candidates_count + $position + 1)) {
                 $pos_list->add($date);
             }
         }
         return $pos_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYWEEKNORules()

ilCalendarRecurrenceCalculator::applyBYWEEKNORules ( ilDateList $list )

protected

Apply BYWEEKNO rules (1 to 53 and -1 to -53).

This rule can only be applied to YEARLY rules (RFC 2445 4.3.10)

Definition at line 293 of file class.ilCalendarRecurrenceCalculator.php.

References createDate(), ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_WEEKLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateList\get(), IL_CAL_FKT_DATE, IL_CAL_UNIX, initDateList(), ILIAS\Repository\int(), and ilDateTime\WEEK.

Referenced by calculateDateList().

                                                            : ilDateList
     {
         if ($this->recurrence->getFrequenceType() != ilCalendarRecurrence::FREQ_YEARLY) {
             return $list;
         }
         // return unmodified, if no byweekno rules are available
         if (!$this->recurrence->getBYWEEKNOList()) {
             return $list;
         }
         $weeks_list = $this->initDateList();
         foreach ($list->get() as $seed) {
             $weeks_in_year = date('W', mktime(0, 0, 0, 12, 28, $seed->get(IL_CAL_FKT_DATE, 'Y', $this->timezone)));
             $this->log->debug(': Year ' . $seed->get(
                 IL_CAL_FKT_DATE,
                 'Y',
                 $this->timezone
             ) . ' has ' . $weeks_in_year . ' weeks');
             foreach ($this->recurrence->getBYWEEKNOList() as $week_no) {
                 $week_no = $week_no < 0 ? ((int) $weeks_in_year + $week_no + 1) : $week_no;
 
                 switch ($this->frequence_context) {
                     case ilCalendarRecurrence::FREQ_MONTHLY:
                         $this->log->debug(': Handling BYWEEKNO in MONTHLY context');
                         // Check if week matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'W', $this->timezone) == $week_no) {
                             $weeks_list->add($seed);
                         }
                         break;
 
                     case ilCalendarRecurrence::FREQ_YEARLY:
                         $this->log->debug(': Handling BYWEEKNO in YEARLY context');
                         $week_diff = $week_no - $seed->get(IL_CAL_FKT_DATE, 'W', $this->timezone);
 
                         // TODO: think about tz here
                         $new_week = $this->createDate($seed->get(IL_CAL_UNIX, '', $this->timezone));
                         $new_week->increment(ilDateTime::WEEK, $week_diff);
                         $weeks_list->add($new_week);
                         break;
                 }
             }
         }
         $this->frequence_context = ilCalendarRecurrence::FREQ_WEEKLY;
         return $weeks_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyBYYEARDAYRules()

ilCalendarRecurrenceCalculator::applyBYYEARDAYRules ( ilDateList $list )

protected

Definition at line 338 of file class.ilCalendarRecurrenceCalculator.php.

References createDate(), ilDateTime\DAY, ilCalendarRecurrence\FREQ_DAILY, ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_WEEKLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateList\get(), IL_CAL_FKT_DATE, IL_CAL_UNIX, initDateList(), and ILIAS\Repository\int().

Referenced by calculateDateList().

                                                             : ilDateList
     {
         // return unmodified, if no byweekno rules are available
         if (!$this->recurrence->getBYYEARDAYList()) {
             return $list;
         }
         $days_list = $this->initDateList();
         foreach ($list->get() as $seed) {
             $num_days = date('z', mktime(0, 0, 0, 12, 31, $seed->get(IL_CAL_FKT_DATE, 'Y', $this->timezone)));
             $this->log->debug(': Year ' . $seed->get(
                 IL_CAL_FKT_DATE,
                 'Y',
                 $this->timezone
             ) . ' has ' . $num_days . ' days.');
 
             foreach ($this->recurrence->getBYYEARDAYList() as $day_no) {
                 $day_no = $day_no < 0 ? ((int) $num_days + $day_no + 1) : $day_no;
 
                 $day_diff = $day_no - $seed->get(IL_CAL_FKT_DATE, 'z', $this->timezone);
                 $new_day = $this->createDate($seed->get(IL_CAL_UNIX, '', $this->timezone));
                 $new_day->increment(ilDateTime::DAY, $day_diff);
 
                 switch ($this->frequence_context) {
                     case ilCalendarRecurrence::FREQ_DAILY:
                         // Check if day matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'z', $this->timezone) == $day_no) {
                             $days_list->add($new_day);
                         }
                         break;
                     case ilCalendarRecurrence::FREQ_WEEKLY:
                         // Check if week matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'W', $this->timezone) == $new_day->get(
                             IL_CAL_FKT_DATE,
                             'W',
                             $this->timezone
                         )) {
                             $days_list->add($new_day);
                         }
                         break;
                     case ilCalendarRecurrence::FREQ_MONTHLY:
                         // Check if month matches
                         if ($seed->get(IL_CAL_FKT_DATE, 'n', $this->timezone) == $new_day->get(
                             IL_CAL_FKT_DATE,
                             'n',
                             $this->timezone
                         )) {
                             $days_list->add($new_day);
                         }
                         break;
                     case ilCalendarRecurrence::FREQ_YEARLY:
                         // Simply add
                         $days_list->add($new_day);
                         break;
                 }
             }
         }
 
         $this->frequence_context = ilCalendarRecurrence::FREQ_DAILY;
         return $days_list;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyDurationPeriod()

ilCalendarRecurrenceCalculator::applyDurationPeriod	(	ilDateList	$list,
		ilDateTime	$start,
		ilDateTime	$end
	)

protected

Apply duration period.

Definition at line 155 of file class.ilCalendarRecurrenceCalculator.php.

References ilDateTime\_after(), ilDateTime\_before(), getDuration(), ilDateTime\MINUTE, and ilDateList\remove().

Referenced by calculateDateList().

                                                                                                 : void
     {
         $list_copy = clone $list;
         foreach ($list_copy as $start_date) {
             $end_date = clone $start_date;
             $end_date->increment(ilDateTime::MINUTE, $this->getDuration() / 60);
 
             if (
                 (
                     ilDateTime::_after($start_date, $this->period_end)
                 ) ||
                 (
                     ilDateTime::_before($end_date, $this->period_start)
                 )
             ) {
                 $this->log->debug('Removed invalid date ' . $start_date . ' <-> ' . $end_date);
                 $list->remove($start_date);
             }
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyExclusionDates()

ilCalendarRecurrenceCalculator::applyExclusionDates ( )

protected

Definition at line 690 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by calculateDateList().

                                             : void
     {
         if (!$this->recurrence->getExclusionDates()) {
             return;
         }
         foreach ($this->recurrence->getExclusionDates() as $excl) {
             $this->valid_dates->removeByDAY($excl->getDate());
         }
     }

Here is the caller graph for this function:

◆ applyLimits()

ilCalendarRecurrenceCalculator::applyLimits ( ilDateList $list )

protected

Apply limits (count or until)

Definition at line 652 of file class.ilCalendarRecurrenceCalculator.php.

References $res, ilDateTime\_after(), ilDateTime\_before(), ILIAS\Repository\event(), ilDateList\get(), IL_CAL_DAY, ilDateList\remove(), and ilDateList\sort().

Referenced by calculateDateList().

                                                     : bool
     {
         $list->sort();
         // Check valid dates before starting time
         foreach ($list->get() as $check_date) {
             if (ilDateTime::_before($check_date, $this->event->getStart(), IL_CAL_DAY)) {
                 $this->log->debug('Removed invalid date: ' . $check_date . ' before starting date:  ' . $this->event->getStart());
                 $list->remove($check_date);
             }
         }
 
         // Check count if given
         if ($this->recurrence->getFrequenceUntilCount()) {
             foreach ($list->get() as $res) {
                 // check smaller than since the start time counts as one
                 if (count($this->valid_dates->get()) < $this->recurrence->getFrequenceUntilCount()) {
                     $this->valid_dates->add($res);
                 } else {
                     $this->limit_reached = true;
                     return false;
                 }
             }
             return true;
         } elseif ($this->recurrence->getFrequenceUntilDate()) {
             $date = $this->recurrence->getFrequenceUntilDate();
             foreach ($list->get() as $res) {
                 if (ilDateTime::_after($res, $date, IL_CAL_DAY)) {
                     $this->limit_reached = true;
                     return false;
                 }
                 $this->valid_dates->add($res);
             }
             return true;
         }
         $this->valid_dates->merge($list);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateDateList()

ilCalendarRecurrenceCalculator::calculateDateList	(	ilDateTime	$a_start,
		ilDateTime	$a_end,
		int	$a_limit = `-1`
	)

calculate date list

Parameters

ilDateTime	ilDateTime start of period
ilDateTime	ilDateTime end of period
int	limit number of returned dates

Returns: ilDateList List of recurring dates

Definition at line 67 of file class.ilCalendarRecurrenceCalculator.php.

References $period_end, $period_start, $valid_dates, ilDateTime\_after(), ilDateTime\_before(), ilDateTime\_equals(), ilTimeZone\_restoreDefaultTimeZone(), adjustTimeZones(), applyBYDAYRules(), applyBYMONTHDAYRules(), applyBYMONTHRules(), applyBYSETPOSRules(), applyBYWEEKNORules(), applyBYYEARDAYRules(), applyDurationPeriod(), applyExclusionDates(), applyLimits(), ILIAS\Repository\event(), IL_CAL_DAY, incrementByFrequency(), initDateList(), optimizeEndingTime(), optimizeStartingTime(), and validateRecurrence().

Referenced by ilConsultationHoursGUI\createAppointments(), and ilObjSessionGUI\createRecurringSessions().

                                                                                                 : ilDateList
     {
         $this->valid_dates = $this->initDateList();
 
         // Check invalid settings: e.g no frequence given, invalid start/end dates ...
         if (!$this->validateRecurrence()) {
             $this->valid_dates->add($this->event->getStart());
             return $this->valid_dates;
         }
 
         // Performance fix: Switching the timezone for many dates seems to be
         // quite time consuming.
         // Therfore we adjust the timezone of all input dates (start,end, event start)
         // to the same tz (UTC for fullday events, Recurrence tz for all others).
         $this->adjustTimeZones($a_start, $a_end);
 
         // Add start of event if it is in the period
         if ((ilDateTime::_after($this->event->getStart(), $this->period_start, IL_CAL_DAY) and
                 ilDateTime::_before($this->event->getStart(), $this->period_end, IL_CAL_DAY)) or
             ilDateTime::_equals($this->event->getStart(), $this->period_start, IL_CAL_DAY)) {
             // begin-patch aptar
             $this->valid_dates->add($this->event->getStart());
             #$this->valid_dates->add($this->event->getStart());
             // end patch aptar
         }
 
         // Calculate recurrences based on frequency (e.g. MONTHLY)
         $time = microtime(true);
 
         $start = $this->optimizeStartingTime();
         $end = $this->optimizeEndingTime();
 
         #echo "ZEIT: ADJUST: ".(microtime(true) - $time).'<br>';
         $counter = 0;
         do {
             ++$counter;
             // initialize context for applied rules
             // E.g
             // RRULE:FREQ=YEARLY;BYMONTH=1;BYWEEKNO=1,50        => context for BYWERKNO is monthly because it filters to the weeks in JAN
             // RRULE:FREQ=YEARLY;BYWEEKNO=1,50                          => context for BYWERKNO is yearly because it adds all weeks.
             $this->frequence_context = $this->recurrence->getFrequenceType();
 
             $freq_res = $this->initDateList();
             $freq_res->add($start);
 
             // Fixed sequence of applying rules (RFC 2445 4.3.10)
             $freq_res = $this->applyBYMONTHRules($freq_res);
             #echo "BYMONTH: ".$freq_res;
 
             $freq_res = $this->applyBYWEEKNORules($freq_res);
             #echo "BYWEEKNO: ".$freq_res;
 
             $freq_res = $this->applyBYYEARDAYRules($freq_res);
             #echo "BYYEARDAY: ".$freq_res;
 
             $freq_res = $this->applyBYMONTHDAYRules($freq_res);
             #echo "BYMONTHDAY: ".$freq_res;
 
             #$time = microtime(true);
             $freq_res = $this->applyBYDAYRules($freq_res);
             #echo "ZEIT: ".(microtime(true) - $time);
             #echo "BYDAY: ".$freq_res;
 
             $freq_res = $this->applyBYSETPOSRules($freq_res);
             #echo "BYSETPOS: ".$freq_res;
 
             $freq_res = $this->applyLimits($freq_res);
             #echo $freq_res;
 
             $start = $this->incrementByFrequency($start);
 
             if (ilDateTime::_after($start, $end) || $this->limit_reached) {
                 break;
             }
         } while (true);
 
         $this->applyExclusionDates();
         $this->applyDurationPeriod($this->valid_dates, $this->period_start, $this->period_end);
         $this->valid_dates->sort();
 
         // Restore default timezone
         ilTimeZone::_restoreDefaultTimeZone();
         return $this->valid_dates;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ createDate()

ilCalendarRecurrenceCalculator::createDate	(	$a_date,
		$a_format_type = `IL_CAL_UNIX`
	)

protected

Definition at line 705 of file class.ilCalendarRecurrenceCalculator.php.

References ILIAS\Repository\event().

Referenced by applyBYDAYRules(), applyBYMONTHDAYRules(), applyBYMONTHRules(), applyBYWEEKNORules(), applyBYYEARDAYRules(), and optimizeStartingTime().

                                                                         : ilDateTime
     {
         if ($this->event->isFullday()) {
             return new ilDate($a_date, $a_format_type);
         } else {
             // TODO: the timezone for this recurrence must be stored in the db
             return new ilDateTime($a_date, $a_format_type, $this->timezone);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDuration()

ilCalendarRecurrenceCalculator::getDuration ( )

protected

Get duration of event.

Definition at line 55 of file class.ilCalendarRecurrenceCalculator.php.

References $duration.

Referenced by applyDurationPeriod().

                                     : int
     {
         return $this->duration;
     }

Here is the caller graph for this function:

◆ getMonthWeekDays()

ilCalendarRecurrenceCalculator::getMonthWeekDays	(	int	$year,
		int	$month
	)

protected

Definition at line 582 of file class.ilCalendarRecurrenceCalculator.php.

References $i, ilCalendarUtil\_getMaxDayOfMonth(), IL_CAL_DATE, and IL_CAL_FKT_GETDATE.

Referenced by applyBYDAYRules().

                                                               : array
     {
         static $month_days = array();
 
         if (isset($month_days[$year][$month])) {
             return $month_days[$year][$month];
         }
 
         $month_str = $month < 10 ? ('0' . $month) : $month;
         $begin_month = new ilDate($year . '-' . $month_str . '-01', IL_CAL_DATE);
         $begin_month_info = $begin_month->get(IL_CAL_FKT_GETDATE);
 
         $days = array(0 => 'SU', 1 => 'MO', 2 => 'TU', 3 => 'WE', 4 => 'TH', 5 => 'FR', 6 => 'SA');
         for ($i = 0; $i < $begin_month_info['wday']; $i++) {
             next($days);
         }
         for ($i = $begin_month_info['yday']; $i < $begin_month_info['yday'] + ilCalendarUtil::_getMaxDayOfMonth(
             $year,
             $month
         ); $i++) {
             if (!($current_day = current($days))) {
                 $current_day = reset($days);
             }
             $month_days[$year][$month][$current_day][] = $i;
             next($days);
         }
         return $month_days[$year][$month];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getWeekWeekDays()

ilCalendarRecurrenceCalculator::getWeekWeekDays ( array $seed_info )

protected

get weedays of week

Definition at line 614 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by applyBYDAYRules().

                                                         : array
     {
         $days = array(0 => 'SU', 1 => 'MO', 2 => 'TU', 3 => 'WE', 4 => 'TH', 5 => 'FR', 6 => 'SA');
 
         $start_day = $seed_info['yday'] - $seed_info['wday'];
         foreach ($days as $num => $day) {
             $week_days[$day][] = $start_day++;
         }
         return $week_days;
     }

Here is the caller graph for this function:

◆ getYearWeekDays()

ilCalendarRecurrenceCalculator::getYearWeekDays ( ilDateTime $seed )

protected

get a list of year week days according to the BYMONTH rule

Definition at line 557 of file class.ilCalendarRecurrenceCalculator.php.

References $i, ilCalendarUtil\_isLeapYear(), ilDateTime\get(), IL_CAL_DATE, and IL_CAL_FKT_DATE.

Referenced by applyBYDAYRules().

                                                         : array
     {
         $time = microtime(true);
 
         $year_days = array();
 
         $current_year = $seed->get(IL_CAL_FKT_DATE, 'Y');
         $start = new ilDate($current_year . '-01-01', IL_CAL_DATE);
         $offset = $start->get(IL_CAL_FKT_DATE, 'w');
         $days = array(0 => 'SU', 1 => 'MO', 2 => 'TU', 3 => 'WE', 4 => 'TH', 5 => 'FR', 6 => 'SA');
         for ($i = 0; $i < $offset; $i++) {
             next($days);
         }
 
         $num_days = ilCalendarUtil::_isLeapYear($current_year) ? 366 : 365;
         for ($i = 0; $i < $num_days; $i++) {
             if (!($current_day = current($days))) {
                 $current_day = reset($days);
             }
             $year_days[$current_day][] = $i;
             next($days);
         }
         return $year_days;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ incrementByFrequency()

ilCalendarRecurrenceCalculator::incrementByFrequency ( ilDateTime $start )

protected

Definition at line 231 of file class.ilCalendarRecurrenceCalculator.php.

References $start, ilDateTime\DAY, ilCalendarRecurrence\FREQ_DAILY, ilCalendarRecurrence\FREQ_MONTHLY, ilCalendarRecurrence\FREQ_WEEKLY, ilCalendarRecurrence\FREQ_YEARLY, ilDateTime\increment(), ilDateTime\MONTH, ilDateTime\WEEK, and ilDateTime\YEAR.

Referenced by calculateDateList(), optimizeEndingTime(), and optimizeStartingTime().

                                                               : ilDateTime
     {
         switch ($this->recurrence->getFrequenceType()) {
             case ilCalendarRecurrence::FREQ_YEARLY:
                 $start->increment(ilDateTime::YEAR, $this->recurrence->getInterval());
                 break;
 
             case ilCalendarRecurrence::FREQ_MONTHLY:
                 $start->increment(ilDateTime::MONTH, $this->recurrence->getInterval());
                 break;
 
             case ilCalendarRecurrence::FREQ_WEEKLY:
                 $start->increment(ilDateTime::WEEK, $this->recurrence->getInterval());
                 break;
 
             case ilCalendarRecurrence::FREQ_DAILY:
                 $start->increment(ilDateTime::DAY, $this->recurrence->getInterval());
                 break;
 
             default:
                 $this->log->warning('No frequence defined.');
                 break;
         }
         return $start;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initDateList()

ilCalendarRecurrenceCalculator::initDateList ( )

protected

Definition at line 700 of file class.ilCalendarRecurrenceCalculator.php.

References ILIAS\Repository\event(), ilDateList\TYPE_DATE, and ilDateList\TYPE_DATETIME.

Referenced by applyBYDAYRules(), applyBYMONTHDAYRules(), applyBYMONTHRules(), applyBYSETPOSRules(), applyBYWEEKNORules(), applyBYYEARDAYRules(), and calculateDateList().

                                      : ilDateList
     {
         return new ilDateList($this->event->isFullday() ? ilDateList::TYPE_DATE : ilDateList::TYPE_DATETIME);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ optimizeEndingTime()

ilCalendarRecurrenceCalculator::optimizeEndingTime ( )

protected

Definition at line 221 of file class.ilCalendarRecurrenceCalculator.php.

References $period_end, $period_start, ilDateTime\_before(), ilDateTime\DAY, and incrementByFrequency().

Referenced by calculateDateList().

                                            : ilDateTime
     {
         $end = clone $this->period_start;
         $end = $this->incrementByFrequency($end);
         if (ilDateTime::_before($this->period_end, $end, ilDateTime::DAY)) {
             return $end;
         }
         return $this->period_end;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ optimizeStartingTime()

ilCalendarRecurrenceCalculator::optimizeStartingTime ( )

protected

Definition at line 205 of file class.ilCalendarRecurrenceCalculator.php.

References $start, ilDateTime\_before(), createDate(), IL_CAL_UNIX, and incrementByFrequency().

Referenced by calculateDateList().

                                              : ilDateTime
     {
         // starting time cannot be optimzed if RRULE UNTIL is given.
         // In that case we have to calculate all dates until "UNTIL" is reached.
         if ($this->recurrence->getFrequenceUntilCount() > 0) {
             // Switch the date to the original defined timzone for this recurrence
             return $this->createDate($this->start->get(IL_CAL_UNIX, '', $this->timezone));
         }
         $optimized = $start = $this->createDate($this->start->get(IL_CAL_UNIX, '', $this->timezone));
         while (ilDateTime::_before($start, $this->period_start)) {
             $optimized = clone $start;
             $start = $this->incrementByFrequency($start);
         }
         return $optimized;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateRecurrence()

ilCalendarRecurrenceCalculator::validateRecurrence ( )

protected

Definition at line 715 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by calculateDateList().

                                            : bool
     {
         return $this->recurrence->validate();
     }

Here is the caller graph for this function:

Field Documentation

◆ $duration

int ilCalendarRecurrenceCalculator::$duration = 0

protected

Definition at line 40 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by getDuration().

◆ $event

ilDatePeriod ilCalendarRecurrenceCalculator::$event

protected

Definition at line 38 of file class.ilCalendarRecurrenceCalculator.php.

◆ $frequence_context

string ilCalendarRecurrenceCalculator::$frequence_context = ''

protected

Definition at line 41 of file class.ilCalendarRecurrenceCalculator.php.

◆ $limit_reached

bool ilCalendarRecurrenceCalculator::$limit_reached = false

protected

Definition at line 32 of file class.ilCalendarRecurrenceCalculator.php.

◆ $log

ilLogger ilCalendarRecurrenceCalculator::$log

protected

Definition at line 30 of file class.ilCalendarRecurrenceCalculator.php.

◆ $period_end

ilDateTime ilCalendarRecurrenceCalculator::$period_end = null

protected

Definition at line 35 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by calculateDateList(), and optimizeEndingTime().

◆ $period_start

ilDateTime ilCalendarRecurrenceCalculator::$period_start = null

protected

Definition at line 34 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by calculateDateList(), and optimizeEndingTime().

◆ $recurrence

ilCalendarRecurrenceCalculation ilCalendarRecurrenceCalculator::$recurrence

protected

Definition at line 39 of file class.ilCalendarRecurrenceCalculator.php.

◆ $start

ilDateTime ilCalendarRecurrenceCalculator::$start = null

protected

Definition at line 36 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by applyBYDAYRules(), incrementByFrequency(), and optimizeStartingTime().

◆ $timezone

string ilCalendarRecurrenceCalculator::$timezone = ilTimeZone::UTC

protected

Definition at line 29 of file class.ilCalendarRecurrenceCalculator.php.

◆ $valid_dates

ilDateList ilCalendarRecurrenceCalculator::$valid_dates = null

protected

Definition at line 33 of file class.ilCalendarRecurrenceCalculator.php.

Referenced by calculateDateList().

The documentation for this class was generated from the following file:

Services/Calendar/classes/class.ilCalendarRecurrenceCalculator.php

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ adjustTimeZones()

◆ applyBYDAYRules()

◆ applyBYMONTHDAYRules()

◆ applyBYMONTHRules()

◆ applyBYSETPOSRules()

◆ applyBYWEEKNORules()

◆ applyBYYEARDAYRules()

◆ applyDurationPeriod()

◆ applyExclusionDates()

◆ applyLimits()

◆ calculateDateList()

◆ createDate()

◆ getDuration()

◆ getMonthWeekDays()

◆ getWeekWeekDays()

◆ getYearWeekDays()

◆ incrementByFrequency()

◆ initDateList()

◆ optimizeEndingTime()

◆ optimizeStartingTime()

◆ validateRecurrence()

Field Documentation

◆ $duration

◆ $event

◆ $frequence_context

◆ $limit_reached

◆ $log

◆ $period_end

◆ $period_start

◆ $recurrence

◆ $start

◆ $timezone

◆ $valid_dates