incomingmanager.php

<?php
 
namespace Bitrix\Calendar\Sync\Office365;
 
use Bitrix\Calendar\Core\Base\BaseException;
use Bitrix\Calendar\Sync\Connection\EventConnection;
use Bitrix\Calendar\Sync\Connection\SectionConnection;
use Bitrix\Calendar\Sync\Dictionary;
use Bitrix\Calendar\Sync\Entities\SyncEvent;
use Bitrix\Calendar\Sync\Entities\SyncEventMap;
use Bitrix\Calendar\Sync\Entities\SyncSection;
use Bitrix\Calendar\Sync\Entities\SyncSectionMap;
use Bitrix\Calendar\Sync\Exceptions\ApiException;
use Bitrix\Calendar\Sync\Exceptions\AuthException;
use Bitrix\Calendar\Sync\Exceptions\ConflictException;
use Bitrix\Calendar\Sync\Exceptions\NotFoundException;
use Bitrix\Calendar\Sync\Exceptions\RemoteAccountException;
use Bitrix\Calendar\Sync\Internals\HasContextTrait;
use Bitrix\Calendar\Sync\Managers\IncomingEventManagerInterface;
use Bitrix\Calendar\Sync\Managers\IncomingSectionManagerInterface;
use Bitrix\Calendar\Sync\Office365\Dto\DateTimeDto;
use Bitrix\Calendar\Sync\Office365\Dto\EventDto;
use Bitrix\Calendar\Sync\Office365\Dto\SectionDto;
use Bitrix\Calendar\Core;
use Bitrix\Calendar\Sync\Util\Result;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentNullException;
use Bitrix\Main\LoaderException;
use Bitrix\Main\ObjectException;
use DateTime;
use DateTimeZone;
use Exception;
 
class IncomingManager extends AbstractManager implements IncomingSectionManagerInterface, IncomingEventManagerInterface
{
    use HasContextTrait;
 
    private const IMPORT_SECTIONS_LIMIT = 10;
 
    private ?SectionConnection $lastSectionConnection = null;
 
    public function __construct(Office365Context $context)
    {
        $this->context = $context;
        parent::__construct($context->getConnection());
    }
 
    public function getSections(): Result
    {
        $result = new Result();
        $syncSectionMap = new SyncSectionMap();
        $sections = $this->context->getVendorSyncService()->getSections();
        foreach ($sections as $sectionDto)
        {
            if ($sectionDto->canShare)
            {
                $syncSectionMap->add(
                    $this->prepareSyncSection($sectionDto),
                    $sectionDto->id
                );
            }
        }
 
        return $result->setData([
            'externalSyncSectionMap' => $syncSectionMap,
        ]);
    }
 
    private function prepareSyncSection(SectionDto $sectionDto): SyncSection
    {
        $section = $this->context->getConverter()->convertSection($sectionDto);
        $section
            ->setExternalType(Helper::ACCOUNT_TYPE)
            ->setOwner($this->connection->getOwner())
            ->setCreator($this->connection->getOwner())
            ->setIsActive(true)
            ->setType('user')
        ;
        $sectionConnection = (new SectionConnection())
            ->setSection($section)
            ->setConnection($this->connection)
            ->setVendorSectionId($sectionDto->id)
            ->setActive(true)
            ->setLastSyncDate(null)
            ->setPrimary($sectionDto->isDefaultCalendar ?? false)
            ->setOwner($this->connection->getOwner())
            ->setLastSyncStatus(Dictionary::SYNC_STATUS['success'])
            ->setVersionId($sectionDto->changeKey)
        ;
 
        return (new SyncSection())
            ->setSection($section)
            ->setSectionConnection($sectionConnection)
            ->setVendorName($this->getServiceName())
            ->setAction(Dictionary::SYNC_STATUS['success'])
            ;
    }
 
    public function getEvents(SyncSection $syncSection): Result
    {
        $syncEventMap = new SyncEventMap();
        $result = (new Result())->setData([
            'externalSyncEventMap' => $syncEventMap,
        ]);
        $service = $this->context->getVendorSyncService();
        $this->lastSectionConnection = $syncSection->getSectionConnection();
        foreach ($service->getCalendarDelta($syncSection->getSectionConnection()) as $eventId => $eventPack)
        {
            if ($dto = ($eventPack[Helper::EVENT_TYPES['deleted']] ?? null))
            {
                $this->pushIntoSyncEventMap(
                    $syncEventMap,
                    $eventId,
                    $this->prepareDeletedSyncEvent($dto, $syncSection),
                    'delete' // change to dictionary constant
                );
            }
            elseif ($dto = ($eventPack[Helper::EVENT_TYPES['single']] ?? null))
            {
                $this->pushIntoSyncEventMap($syncEventMap, $eventId, $this->prepareSyncEvent($dto, $syncSection));
            }
            elseif ($dto = ($eventPack[Helper::EVENT_TYPES['series']] ?? null))
            {
                $master = $this->prepareSyncEvent($dto, $syncSection);
                $this->pushIntoSyncEventMap($syncEventMap, $eventId, $master);
                if ($master->getEvent()->getRecurringRule())
                {
                    $master->getEvent()
                        ->setExcludedDateCollection(new Core\Event\Properties\ExcludedDatesCollection([]));
                    if ($exceptions = ($eventPack[Helper::EVENT_TYPES['exception']] ?? null))
                    {
                        foreach ($exceptions as $exceptionDto)
                        {
                            $exception = $this->prepareSyncEvent($exceptionDto, $syncSection)
                                ->setAction(Dictionary::SYNC_EVENT_ACTION['create'])
                            ;
                            $master->addInstance($exception);
                        }
                    }
                    $instances = array_map(function (DateTimeDto $val) use ($master) {
                        $result = (new DateTime(
                            $val->dateTime,
                            new DateTimeZone($val->timeZone)
                        ))->setTimezone($master->getEvent()->getStartTimeZone()->getTimeZone());
 
                        return $result->format('d.m.Y');
                    }, ($eventPack[Helper::EVENT_TYPES['occurrence']] ?? []));
                    $deltaPeriod = $this->context->getHelper()->getDeltaInterval();
                    $computedInstances = (new Core\Event\Tools\Recurrence())->getEventOccurenceDates(
                        $master->getEvent(),
                        [
                            'limitDateFrom' => $deltaPeriod['from'],
                            'limitDateTo' => $deltaPeriod['to'],
                        ]
                    );
                    foreach ($computedInstances as $date => $dateTime)
                    {
                        if (!in_array($date, $instances))
                        {
                            $master->getEvent()->getExcludedDateCollection()->add(
                                Core\Base\Date::createDateFromFormat($date, 'd.m.Y')
                                    ->resetTime()
                                    ->setDateTimeFormat('d.m.Y')
                            );
                        }
                    }
                }
            }
        }
 
        return $result;
    }
 
    private function pushIntoSyncEventMap(
        SyncEventMap $map,
        string $key,
        SyncEvent $event,
        string $action = 'save'
    )
    {
        $event->setAction($action);
        $map->add($event, $key);
    }
 
    private function prepareSyncEvent(
        EventDto $eventDto,
        SyncSection $section
    ): SyncEvent
    {
 
        $event = $this->context->getConverter()
            ->convertEvent($eventDto, $section->getSection());
        $eventConnection = (new EventConnection())
            ->setEvent($event)
            ->setConnection($section->getSectionConnection()->getConnection())
            ->setVendorEventId($eventDto->id)
            ->setVendorVersionId($eventDto->changeKey)
            ->setEntityTag($eventDto->etag)
            ->setRecurrenceId($eventDto->seriesMasterId ?: null)
            ->setData($this->prepareCustomData($eventDto))
            ->setLastSyncStatus(Dictionary::SYNC_STATUS['success'])
        ;
 
        return (new SyncEvent())
            ->setEvent($event)
            ->setEventConnection($eventConnection);
    }
 
    private function prepareCustomData(EventDto $eventDto): array
    {
        $data = [];
        if (!empty($eventDto->location))
        {
            $data['location'] = $eventDto->location->toArray(true);
        }
        if (!empty($eventDto->locations))
        {
            foreach ($eventDto->locations as $location)
            {
                $data['locations'][] = $location->toArray(true);
            }
        }
 
        if (!empty($eventDto->attendees))
        {
            $data['attendees'] = [];
            foreach ($eventDto->attendees as $attendee)
            {
                $data['attendees'][] = $attendee->toArray(true);
            }
        }
 
        return $data;
    }
 
    public function getSectionConnection(): Result
    {
        return (new Result())->setData(['sectionConnection' => new SectionConnection()]);
    }
 
    public function getPageToken(): ?string
    {
        if ($this->lastSectionConnection)
        {
            return $this->lastSectionConnection->getPageToken();
        }
        return null;
    }
 
    public function getEtag(): ?string
    {
        if ($this->lastSectionConnection)
        {
            return $this->lastSectionConnection->getVersionId();
        }
        return null;
    }
 
    public function getSyncToken(): ?string
    {
        if ($this->lastSectionConnection)
        {
            return $this->lastSectionConnection->getSyncToken();
        }
        return null;
    }
 
    public function getStatus(): ?string
    {
        if ($this->lastSectionConnection)
        {
            return $this->lastSectionConnection->getLastSyncStatus();
        }
        return null;
    }
 
    public function getConnection(): Result
    {
        return (new Result())->setData([
            'connection' => $this->context->getConnection(),
        ]);
    }
 
    private function prepareDeletedSyncEvent(EventDto $dto, SyncSection $syncSection): SyncEvent
    {
        $event = new Core\Event\Event();
        $eventConnection = (new EventConnection())
            ->setEvent($event)
            ->setConnection($syncSection->getSectionConnection()->getConnection())
            ->setVendorEventId($dto->id)
        ;
 
        return (new SyncEvent())
            ->setEvent($event)
            ->setEventConnection($eventConnection);
    }
}