recurrence.php

<?php
 
namespace Bitrix\Calendar\Core\Event\Tools;
 
use Bitrix\Calendar\Core\Base\BaseException;
use Bitrix\Calendar\Core\Event\Event;
use Bitrix\Calendar\Core;
use Bitrix\Main\Type\Date;
use DateTime;
use Exception;
 
class Recurrence
{
    public const PERIOD_TYPES = [
        'WEEKLY' => 'WEEKLY',
        'HOURLY' => 'HOURLY',
        'DAILY' => 'DAILY',
        'MONTHLY' => 'MONTHLY',
        'YEARLY' => 'YEARLY',
    ];
 
    private const UNIT_MAP = [
        'WEEKLY' => 'week',
        // 'HOURLY' => 'hour',
        'DAILY' => 'day',
        'MONTHLY' => 'month',
        'YEARLY' => 'year',
    ];
 
    private const WEEK_DAYS_SHORT = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
 
    private const WEEK_DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
 
    public function getEventOccurenceDates(Event $event, array $params = []): array
    {
        $limits = $this->prepareLimits($event, $params);
 
        $result = [];
        $counter = 0;
 
        $pushToResult = function (DateTime $date) use (&$result, &$counter)
        {
            $result[$date->format('d.m.Y')] = $date;
            $counter++;
        };
 
        $start = clone $event->getStart();
        $start->resetTime();
        $date = $this->convertBitrixDateToPhpDate($start);
 
        while ($this->isDateWithinLimits($date, $limits, $counter))
        {
            if ($event->getRecurringRule()->getFrequency() === self::PERIOD_TYPES['WEEKLY'])
            {
                if (empty($started))
                {
                    $started = true;
                    // return array like [0, 2, 5] for sunday, tuesday, friday
                    $weekDays = $weekDays ?? $this->prepareWeekDays($event->getRecurringRule()->getByday());
                    $weekDay = (int)$date->format('w');
                    if (!in_array($weekDay, $weekDays))
                    {
                        $this->moveToNextWeekDay($date, $weekDays);
                    }
                }
                else
                {
                    $pushToResult(clone $date);
                    $this->moveToNextWeekDay($date, $weekDays);
                }
            }
            else
            {
                $pushToResult(clone $date);
                $unit = self::UNIT_MAP[$event->getRecurringRule()->getFrequency()] ?? null;
                if ($unit === null)
                {
                    throw new BaseException(
                        "Unsupported frequency type: " . $event->getRecurringRule()->getFrequency(),
                        406,
                        __FILE__,
                        __LINE__
                    );
                }
 
                $date->modify('+' . $event->getRecurringRule()->getInterval() . ' ' . $unit);
            }
        }
 
        $this->removeExcludedDates($event, $result);
 
        return $result;
    }
 
    private function prepareWeekDays(array $getByday): array
    {
        $days = array_flip(self::WEEK_DAYS_SHORT);
        return array_map(function ($val) use ($days) {
            return $days[$val];
        }, $getByday);
    }
 
    private function moveToNextWeekDay(DateTime $date, array $weekDays): void
    {
        $current = (int)$date->format('w');
        foreach ($weekDays as $weekDay)
        {
            if ($weekDay > $current)
            {
                $nextDay = $weekDay;
                break;
            }
        }
        $nextDayIndex = $nextDay ?? reset($weekDays);
        $nextDayName = self::WEEK_DAYS[$nextDayIndex];
        $date->modify("next $nextDayName");
    }
 
    private function prepareLimits(Event $event, array $params): array
    {
        $getCount = static function (Event $event, array $params)
        {
            return $params['limitCount']
                ?? $event->getRecurringRule()
                    ? $event->getRecurringRule()->getCount()
                    : null
                ;
        };
 
        $getFrom = function (Event $event, array $params)
        {
            if (!empty($params['limitDateFrom']))
            {
                return max(
                    $this->convertBitrixDateToPhpDate($params['limitDateFrom']),
                    $this->convertBitrixDateToPhpDate($event->getStart())
                );
            }
            else
            {
                return $this->convertBitrixDateToPhpDate($event->getStart());
            }
        };
 
        $getTo = function (Event $event, array $params)
        {
            $until = (!is_null($event->getRecurringRule()) && $event->getRecurringRule()->hasUntil())
                ? $this->convertBitrixDateToPhpDate($event->getRecurringRule()->getUntil())
                : null;
            if (empty($params['limitDateTo']))
            {
                return $until;
            }
            elseif ($until)
            {
                return min(
                    $this->convertBitrixDateToPhpDate($params['limitDateTo']),
                    $until
                );
            }
            else
            {
                return $params['limitDateTo'];
            }
        };
 
        return [
            'count' => $getCount($event, $params),
            'from' => $getFrom($event, $params),
            'to' => $getTo($event, $params),
        ];
    }
 
    private function convertBitrixDateToPhpDate($date): DateTime
    {
        return new DateTime($date->format('c'));
    }
 
    private function isDateWithinLimits(DateTime $date, array $limits, int $counter): bool
    {
        return (empty($limits['count']) || $counter < $limits['count'])
            && ($date->format('Ymd') >= $limits['from']->format('Ymd'))
            && (empty($limits['to']) || $date->format('Ymd') <= $limits['to']->format('Ymd'))
            ;
    }
 
    private function removeExcludedDates(Event $event, array &$result): void
    {
        if ($event->getExcludedDateCollection() && $event->getExcludedDateCollection()->count())
        {
            foreach ($event->getExcludedDateCollection() as $excludedDate)
            {
                $key = $excludedDate->format('d.m.Y');
                if (array_key_exists($key, $result))
                {
                    unset($result[$key]);
                }
            }
        }
    }
}