eventmanager.php

См. документацию.

<?php
 
namespace Bitrix\Calendar\Sync\Google;
 
use Bitrix\Calendar\Core;
use Bitrix\Calendar\Core\Base\BaseException;
use Bitrix\Calendar\Core\Event\Event;
use Bitrix\Calendar\Sync\Dictionary;
use Bitrix\Calendar\Sync\Connection\EventConnection;
use Bitrix\Calendar\Sync\Entities\SyncEvent;
use Bitrix\Calendar\Sync\Connection\SectionConnection;
use Bitrix\Calendar\Sync\Connection\Server;
use Bitrix\Calendar\Sync\Exceptions\ConflictException;
use Bitrix\Calendar\Sync\Managers\EventManagerInterface;
use Bitrix\Calendar\Sync\Util\Context;
use Bitrix\Calendar\Sync\Util\EventContext;
use Bitrix\Calendar\Util;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\DI\ServiceLocator;
use Bitrix\Main\Error;
use Bitrix\Main\LoaderException;
use Bitrix\Main\ObjectException;
use Bitrix\Main\SystemException;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Calendar\Sync\Util\Result;
use Bitrix\Main\Web\Json;
 
class EventManager extends Manager implements EventManagerInterface
{
    public const CREATE_PATH = '/calendars/%CALENDAR_ID%/events/';
    public const EVENT_PATH = '/calendars/%CALENDAR_ID%/events/%EVENT_ID%';

    public function create(Core\Event\Event $event, EventContext $context): Result
    {
        $result = new Result();
 
        try
        {
            // TODO: Remake it: move this logic to parent::request().
            // Or, better, in separate class.
            $converter = new EventConverter(
                event: $event,
            );
            $this->httpClient->post(
                $this->prepareCreateUrl($context),
                $this->encode($converter->convertForCreate())
            );
 
            if ($this->isRequestSuccess())
            {
                $requestResult = $this->prepareResult($this->httpClient->getResult(), $event);
 
                $result->setData($requestResult);
            }
            else
            {
                $response = Json::decode($this->httpClient->getResult());
                if (!empty($response['error']))
                {
                    $error = $response['error'];
                    switch ($error['code'])
                    {
                        case 409:
                            throw new ConflictException($error['message'], $error['code']);
                        case 401:
                            $this->handleUnauthorize($this->connection);
                            $result->addError(new Error($error['message'], $error['code']));
                            break;
                        default:
                            if (!empty($error['code']))
                            {
                                $result->addError(new Error($error['message'], $error['code']));
                            }
                            else
                            {
                                $result->addError(new Error('Uncknown Google API error', 400));
                            }
                    }
                }
            }
        }
        catch (ConflictException $e)
        {
            if ($event->getUid())
            {
                $event->setUid(null);
 
                return $this->create($event, $context);
            }
 
            $result->addError(new Error($e->getMessage(), $e->getCode()));
        }
        catch (ArgumentException $e)
        {
            $result->addError(new Error('failed to create an event in google'));
        }
        catch (ObjectException $e)
        {
            $result->addError(new Error('failed to convert event'));
        }
 
        return $result;
    }

    public function update(Core\Event\Event $event, EventContext $context): Result
    {
        $result = new Result();
 
        try
        {
            // TODO: Remake it: move this logic to parent::request().
            // Or, better, in separate class.
            $converter = new EventConverter(
                event: $event,
                eventConnection: $context->getEventConnection(),
            );
            $this->httpClient->query(
                HttpClient::HTTP_PUT,
                $this->prepareUpdateUrl($context),
                $this->encode($converter->convertForUpdate())
            );
 
            if ($this->isRequestSuccess())
            {
                $requestResult = $this->prepareResult($this->httpClient->getResult(), $event);
                // TODO: move it to core
                if ($childList = ($context->sync['childList'] ?? null))
                {
                    foreach ($childList as $eventId => $childEvent)
                    {
                        $childResult = $this->createInstance($childEvent, $context);
                        if ($childResult->isSuccess())
                        {
                            $data = $childResult->getData()['event'];
                            $mapper = new Core\Mappers\EventConnection();
                            $link = $mapper->getMap([
                                '=EVENT_ID' => $childEvent->getId(),
                                '=CONNECTION_ID' => $this->connection->getId(),
                            ])->fetch();
                            if ($link)
                            {
                                $link
                                    ->setVendorEventId($data['id'])
                                    ->setEntityTag($data['etag'])
                                    ->setVendorVersionId($data['version'])
                                    ->setRecurrenceId($requestResult['event']['id'])
                                    ;
                                $mapper->update($link);
                            }
                        }
                    }
                }
                $result->setData($requestResult);
            }
            else
            {
                $response = Json::decode($this->httpClient->getResult());
                if (!empty($response['error']) && $response['error']['code'] === 401)
                {
                    $this->handleUnauthorize($this->connection);
                    $result->addError(new Error($response['error']['message'], $response['error']['code']));
                }
                else
                {
                    $result->addError(new Error('error of updating event', $this->httpClient->getStatus()));
                }
            }
        }
        catch (ArgumentException $e)
        {
            $result->addError(new Error('failed to update an event in google'));
        }
        catch (ObjectException $e)
        {
            $result->addError(new Error('failed to convert event'));
        }
 
        return $result;
    }

    public function delete(Core\Event\Event $event, EventContext $context): Result
    {
        $result = new Result();
 
        try
        {
            // TODO: Remake it: move this logic to parent::request().
            // Or, better, in separate class.
            $converter = new EventConverter($event);
 
            $this->httpClient->query(
                HttpClient::HTTP_DELETE,
                $this->prepareUpdateUrl($context),
                $this->encode($converter->convertForDelete())
            );
 
            if ($this->isRequestDeleteSuccess())
            {
                if ($response = $this->httpClient->getResult())
                {
                    $requestResult = Json::decode($response);
                    $result->setData($requestResult);
                }
            }
            else
            {
                $response = Json::decode($this->httpClient->getResult());
                if (!empty($response['error']) && $response['error']['code'] === 401)
                {
                    $this->handleUnauthorize($this->connection);
                    $result->addError(new Error($response['error']['message'], $response['error']['code']));
                }
                else
                {
                    $result->addError(new Error('error of deleting event'));
                }
            }
 
        }
        catch (ArgumentException $e)
        {
            $result->addError(new Error('failed to delete an event in google'));
        }
        catch (ObjectException $e)
        {
            $result->addError(new Error('failed to convert event'));
        }
 
        return $result;
    }

    public function createInstance(Core\Event\Event $event, EventContext $context): Result
    {
        $result = new Result();
 
        $instanceContext = $this->prepareContextForInstance($event, $context);
        if ($instanceContext === null)
        {
            return $result->addError(new Error('failed to create an instance in google'));
        }
 
        try
        {
            // TODO: Remake it: move this logic to parent::request().
            // Or, better, in separate class.
 
            $converter = new EventConverter(
                event: $event,
                eventConnection: $instanceContext->getEventConnection()
            );
            $this->httpClient->query(
                HttpClient::HTTP_PUT,
                $this->prepareUpdateUrl($instanceContext),
                $this->encode($converter->convertForUpdate())
            );
 
            if ($this->isRequestSuccess())
            {
                $requestResult = $this->prepareResult($this->httpClient->getResult(), $event);
 
                $result->setData($requestResult);
            }
            else
            {
                $response = Json::decode($this->httpClient->getResult());
                if (!empty($response['error']) && $response['error']['code'] === 401)
                {
                    $this->handleUnauthorize($this->connection);
                    $result->addError(new Error($response['error']['message'], $response['error']['code']));
                }
                else
                {
                    $result->addError(new Error('error of creating instance'));
                }
            }
        }
        catch (ArgumentException $e)
        {
            $result->addError(new Error('failed to create an instance in google'));
        }
 
        return $result;
    }

    public function updateInstance(Event $event, EventContext $context): Result
    {
        $eventLink = $context->sync['instanceLink'];
 
        if ($eventLink)
        {
            $eventContext = (new EventContext())
                ->setSectionConnection($context->getSectionConnection())
                ->setEventConnection($eventLink)
            ;
 
            $result = $this->update($event, $eventContext);
            if (!$result->isSuccess() && $result->getErrorCollection()->getErrorByCode(403))
            {
                // TODO: implement it
            }
 
            return $result;
        }
 
        return (new Result())->addError(new Error('Not found link for instance'));
    }

    public function deleteInstance(Event $event, EventContext $context): Result
    {
        $result = new Result();
        $excludeDate = $context->sync['excludeDate'] ?? null;
        $originalDate = $context->sync['originalDate'] ?? null;
 
        $instance = $this->getInstanceForDay($event, $excludeDate, $originalDate);
        $instanceContext = $this->prepareContextForInstance($instance, $context);
 
        if ($instanceContext === null)
        {
            return $result->addError(new Error('failed to delete an instance in google'));
        }
 
        try
        {
            $converter = new EventConverter(
                event: $instance,
                eventConnection: $instanceContext->getEventConnection()
            );
            $this->httpClient->query(
                HttpClient::HTTP_PUT,
                $this->prepareUpdateUrl($instanceContext),
                $this->encode($converter->convertForDeleteInstance())
            );
 
            if ($this->isRequestSuccess())
            {
                $requestResult = $this->prepareResult($this->httpClient->getResult(), $event);
 
                $result->setData($requestResult);
            }
            else
            {
                $response = Json::decode($this->httpClient->getResult());
                if (!empty($response['error']) && $response['error']['code'] === 401)
                {
                    $this->handleUnauthorizeException();
                }
 
                $result->addError(new Error('error of delete instance'));
            }
        }
 
        catch (ArgumentException $e)
        {
            $result->addError(new Error('failed to delete an instance in google'));
        }
 
        return $result;
    }

    public function prepareCreateUrl(EventContext $context): string
    {
        return Server::mapUri(
            $this->connection->getServer()->getFullPath() . self::CREATE_PATH,
            [
                '%CALENDAR_ID%' => Server::getEncodePath($context->getSectionConnection()->getVendorSectionId()),
            ]
        );
    }

    public function prepareUpdateUrl(EventContext $context): string
    {
        return Server::mapUri(
            $this->connection->getServer()->getFullPath() . self::EVENT_PATH,
            [
                '%CALENDAR_ID%' => Server::getEncodePath($context->getSectionConnection()->getVendorSectionId()),
                '%EVENT_ID%' => Server::getEncodePath($context->getEventConnection()->getVendorEventId()),
            ]
        );
    }

    public function saveRecurrence(
        SyncEvent $recurrenceEvent,
        SectionConnection $sectionConnection,
        Context $context
    ): Result
    {
        $result = new Result();
 
        if ($recurrenceEvent->getEventConnection())
        {
            $masterResult = $this->updateRecurrenceEntity($recurrenceEvent, $context);
        }
        else
        {
            $masterResult = $this->createRecurrenceEntity($recurrenceEvent, $sectionConnection, $context);
        }
 
        if (!$masterResult->isSuccess())
        {
            $result->addErrors($masterResult->getErrors());
            return $result;
        }
 
        if ($recurrenceEvent->getInstanceMap())
        {
            foreach ($recurrenceEvent->getInstanceMap()->getCollection() as $instance)
            {
                if ($instance->getEventConnection())
                {
                    $instanceResult = $this->updateRecurrenceEntity($instance, $context, $recurrenceEvent->getEventConnection());
                }
                else
                {
                    $instanceResult = $this->createRecurrenceEntity(
                        $instance,
                        $sectionConnection,
                        $context,
                        $recurrenceEvent->getEventConnection()
                    );
                }
 
                if (!$result->isSuccess())
                {
                    $result->addErrors($instanceResult->getErrors());
                }
            }
        }
 
        return $result;
    }

    public function createRecurrence(
        SyncEvent $recurrenceEvent,
        SectionConnection $sectionConnection,
        Context $context
    ): Result
    {
        return $this->saveRecurrence($recurrenceEvent, $sectionConnection, $context);
    }

    public function updateRecurrence(
        SyncEvent $recurrenceEvent,
        SectionConnection $sectionConnection,
        Context $context
    ): Result
    {
        return $this->saveRecurrence($recurrenceEvent, $sectionConnection, $context);
    }
 

    public function prepareContextForInstance(Event $event, EventContext $context): ?EventContext
    {
        if (
            ($context->getEventConnection() === null)
            || ($context->getSectionConnection() === null)
        )
        {
            return null;
        }
 
        $masterVendorEventId = $context->getEventConnection()->getVendorEventId();
 
        if ($context->getEventConnection()->getEvent()->getVersion() > $event->getVersion())
        {
            $event->setVersion($context->getEventConnection()->getEvent()->getVersion());
        }
 
        return (new EventContext())
            ->setSectionConnection($context->getSectionConnection())
            ->setEventConnection(
                (new EventConnection())
                    ->setVendorEventId(
                        $this->getInstanceId($masterVendorEventId, $event)
                    )
                    ->setRecurrenceId($masterVendorEventId)
            );
    }

    private function getInstanceId(string $masterId, Event $event): string
    {
        $base = $masterId . '_';
        if ($event->isFullDayEvent())
        {
            return $base . $event->getOriginalDateFrom()->setTimezone(Util::prepareTimezone())->format('Ymd');
        }
        else
        {
            return $base . $event->getOriginalDateFrom()->setTimezone(Util::prepareTimezone())->format('Ymd\THis\Z');
        }
    }

    public function getInstanceForDay(
        Event $event,
        Core\Base\Date $excludeDate,
        ?Core\Base\Date $originalDate = null
    ): Event
    {
        $instanceEvent = clone $event;
 
        $instanceEvent->getStart()->getDate()->setDate(
            $excludeDate->getYear(),
            $excludeDate->getMonth(),
            $excludeDate->getDay()
        );
        $instanceEvent->getEnd()->getDate()->setDate(
            $excludeDate->getYear(),
            $excludeDate->getMonth(),
            $excludeDate->getDay()
        );
        $instanceEvent
            ->setOriginalDateFrom($originalDate ?? $event->getStart())
            ->setRecurringRule(null)
        ;
 
        return $instanceEvent;
    }

    private function createRecurrenceEntity(
        SyncEvent $syncEvent,
        SectionConnection $sectionConnection,
        Context $context,
        EventConnection $masterLink = null
    ): Result
    {
        $eventContext = new EventContext();
        $eventContext->merge($context);
 
        $eventContext->setSectionConnection($sectionConnection);
 
        if ($masterLink)
        {
            $eventContext->setEventConnection($masterLink);
            $result = $this->createInstance($syncEvent->getEvent(), $eventContext);
        }
        else
        {
            $result = $this->create($syncEvent->getEvent(), $eventContext);
        }
 
        if ($result->isSuccess())
        {
            if (!$syncEvent->getEvent()->isDeleted())
            {
                $link = (new EventConnection())
                    ->setEvent($syncEvent->getEvent())
                    ->setConnection($sectionConnection->getConnection())
                    ->setVersion($syncEvent->getEvent()->getVersion())
                    ->setVendorEventId($result->getData()['event']['id'])
                    ->setEntityTag($result->getData()['event']['etag'])
                ;
                $syncEvent->setEventConnection($link);
            }
            else
            {
                $syncEvent->setAction(Dictionary::SYNC_EVENT_ACTION['delete']);
            }
        }
 
        return $result;
    }

    private function updateRecurrenceEntity(
        SyncEvent $syncEvent,
        Context $context,
        EventConnection $masterLink = null
    ): Result
    {
        $eventContext = new EventContext();
        $eventContext->merge($context);
        if ($masterLink)
        {
            $eventContext->setEventConnection($masterLink);
            $result = $this->updateInstance($syncEvent->getEvent(), $eventContext);
        }
        else
        {
            $eventContext->setEventConnection($syncEvent->getEventConnection());
            $result = $this->update($syncEvent->getEvent(), $eventContext);
        }
        if ($result->isSuccess())
        {
            $syncEvent->getEventConnection()->setEntityTag($result->getData()['event']['etag']);
        }
 
        return $result;
    }

    private function encode(array $event)
    {
        return Json::encode($event, JSON_UNESCAPED_SLASHES);
    }

    private function prepareResult(string $result, Event $event): array
    {
        $externalEvent = Json::decode($result);
 
        // $eventConnection = (new Sync\Google\Builders\BuilderEventConnectionFromExternalEvent($externalEvent, $event, $this->connection))->build();
        // $syncEvent =
        //  (new Sync\Entities\SyncEvent())
        //      ->setEvent($event)
        //      ->setEventConnection($eventConnection)
        // ;
 
        return ['event' => [
            'id' => $externalEvent['id'],
            'etag' => $externalEvent['etag'],
            'version' => $externalEvent['etag'],
            'recurrence' => $externalEvent['recurringEventId'] ?? null,
        ]];
    }
 
    private function handleUnauthorizeException()
    {
        $this->handleUnauthorize($this->connection);
    }
}