eventcomparemanager.php

<?php
 
namespace Bitrix\Calendar\Core\Managers\Compare;
 
use Bitrix\Calendar\Core\Event\Event;
use Bitrix\Calendar\Core\Event\Properties\RemindCollection;
 
class EventCompareManager implements CompareManager
{
    public const SIGNIFICANT_FIELDS = [
        'name' => 'name',
        'attendees' => 'attendees',
        'start' => 'start',
        'end' => 'end',
        'location' => 'location',
        'recurringRule' => 'recurringRule',
        'creatorId' => 'creatorId',
        'hostId' => 'hostId',
        'excludedDates' => 'excludedDates',
    ];
 
    public const COMPARE_FIELDS = [
        'name' => 'name',
        'recurringRule' => 'recurringRule',
        'start' => 'start',
        'end' => 'end',
        'startTimezone' => 'startTimezone',
        'endTimezone' => 'endTimezone',
        'location' => 'location',
        'attendees' => 'attendees',
        'description' => 'description',
        'ownerId' => 'ownerId',
        'creatorId' => 'creatorId',
        'accessibility' => 'accessibility',
        'transparent' => 'transparent',
        'isPrivate' => 'isPrivate',
        'importance' => 'importance',
        'calendarType' => 'calendarType',
        'specialLabel' => 'specialLabel',
        'isFullDay' => 'isFullDay',
        'color' => 'color',
        'section' => 'section',
        'uid' => 'uid',
        'isActive' => 'isActive',
        'deleted' => 'deleted',
        'originalDateFrom' => 'originalDateFrom',
        //          'excludedDates' => 'excludedDates',
        //          'version' => 'version',
        //          'recurrenceId' => 'recurrenceId',
        //          'dateCreate' => 'dateCreate',
        //          'dateModified' => 'dateModified',
        //          'reminds' => 'reminds',
        //          'hostId' => 'hostId',
        //          'meetingDescription' => 'meetingDescription',
    ];
 
    private array $differenceFields = [];
    protected array $difference = [];
    protected array $eventValueForCompare;
    protected array $originalValueForCompare;
    protected array $significantFields;
    protected Event $event;
    protected Event $originalEvent;
 
    public function __construct(Event $event, Event $originalEvent)
    {
        $this->event = $event;
        $this->originalEvent = $originalEvent;
 
        $this->compare();
    }
 
    public function compare(): EventCompareManager
    {
        $this->eventValueForCompare = $this->transformValuesForCompare($this->event);
        $this->originalValueForCompare = $this->transformValuesForCompare($this->originalEvent);
        $this->compareFields();
 
        $this->significantFields = array_intersect($this->getDifferenceKeyFields(), $this->getSignificantFields());
 
        return $this;
    }
 
    public function hasDifferenceFields(): bool
    {
        return (bool)$this->differenceFields;
    }
 
    public function hasSignificantFields(): bool
    {
        return (bool)$this->significantFields;
    }
 
    public function getSignificantChanges(): array
    {
        return $this->significantFields;
    }
 
    private function getFields(): array
    {
        return [
            'NAME',
            'DESCRIPTION',
            'RRULE',
            'EXDATE',
            'DATE_FROM',
            'DATE_TO',
            'LOCATION',
            'SECTION',
        ];
    }
 
    public function getDifferenceKeyFields(): array
    {
        return array_keys($this->differenceFields);
    }
 
    public function getDifferenceFieldsWithOriginalValue(): array
    {
        return [
            'event' => $this->differenceFields,
            'originalEvent' => array_intersect_key($this->originalValueForCompare, $this->differenceFields),
        ];
    }
 
    private function transformValuesForCompare(Event $event): array
    {
        return [
            'name' => $event->getName(),
            'recurringRule' => $event->isRecurrence() ? $event->getRecurringRule()->toString() : null,
            'start' => (string)$event->getStart(),
            'end' => (string)$event->getEnd(),
            'startTimeZone' => $event->getStartTimeZone() ? (string)$event->getStartTimeZone() : null,
            'endTimeZone' => $event->getEndTimeZone() ? (string)$event->getEndTimeZone() : null,
            'location' => $event->getLocation() ? (string) $event->getLocation()->toString() : '',
            'attendees' => (string) $event->getAttendeesCollection(),
            'description' => trim($event->getDescription()),
            'ownerId' => $event->getOwner() ? $event->getOwner()->getId() : null,
            'creatorId' => $event->getCreator() ? $event->getCreator()->getId(): null,
            'hostId' => $event->getEventHost() ? $event->getEventHost()->getId() : null,
            'meetingDescription' => $event->getMeetingDescription() ? (string)$event->getMeetingDescription() : null,
            'accessibility' => (string)$event->getAccessibility(),
            'transparent' => (string)$event->getTransparent(),
            'isPrivate' => (string)$event->getIsPrivate(),
            'importance' => (string)$event->getImportance(),
            'calendarType' => (string)$event->getCalendarType(),
            'specialLabel' => (string)$event->getSpecialLabel(),
            'excludedDates' => (string)$event->getExcludedDateCollection(),
            'isFullDay' => $event->isFullDayEvent(),
            'color' => (string)$event->getColor(),
            'section' => $event->getSection()->getId(),
            'version' => $event->getVersion(),
            'uid' => (string)$event->getUid(),
            'isActive' => $event->isActive(),
            'deleted' => $event->isDeleted(),
            'recurrenceId' => $event->getRecurrenceId(),
            'originalDateFrom' => $event->getOriginalDateFrom(),
            'dateCreate' => (string)$event->getDateCreate(),
            'dateModified' => (string)$event->getDateModified(),
            'reminds' => (string)$event->getRemindCollection(),
        ];
    }
 
    private function getSignificantFields(): array
    {
        return self::SIGNIFICANT_FIELDS;
    }
 
    private function getCompareFields(): array
    {
        return self::COMPARE_FIELDS;
    }
 
    private function compareFields(): void
    {
        $this->compareHandler();
        $this->compareExcludedDates();
        $this->compareReminders();
    }
 
    private function compareHandler(): void
    {
        foreach ($this->getCompareFields() as $field)
        {
            if (($this->eventValueForCompare[$field] ?? null) != ($this->originalValueForCompare[$field] ?? null))
            {
                $this->differenceFields[$field] = $this->eventValueForCompare[$field] ?? null;
            }
        }
    }
 
    protected function compareExcludedDates(): void
    {
        if ($this->originalEvent->getExcludedDateCollection() || $this->event->getExcludedDateCollection())
        {
            $excludedDatesManager = ExcludedDateCompareManager::createInstance(
                $this->originalEvent->getExcludedDateCollection(),
                $this->event->getExcludedDateCollection()
            );
            if (!$excludedDatesManager->isEqual())
            {
                $this->differenceFields['excludedDates'] = $excludedDatesManager
                    ->getDiffCollection()->toString(';');
            }
        }
    }
 
    protected function compareReminders(): void
    {
        $remindersCompareManager = RemindCompareManager::createInstance(
            $this->event->getRemindCollection() ?? new RemindCollection([]),
            $this->originalEvent->getRemindCollection() ?? new RemindCollection([])
        );
        if (!$remindersCompareManager->isEqual())
        {
            $this->differenceFields['reminds'] = $remindersCompareManager->getDiffCollection()->toString(';');
        }
    }
 
    public function getDiff(): array
    {
        return $this->differenceFields;
    }
}