outgoingeventmanager.php

<?php
 
namespace Bitrix\Calendar\Sync\Google;
 
use Bitrix\Calendar\Core\Base\BaseException;
use Bitrix\Calendar\Core\Base\Date;
use Bitrix\Calendar\Sync\Connection\Connection;
use Bitrix\Calendar\Sync\Connection\EventConnection;
use Bitrix\Calendar\Sync\Connection\Server;
use Bitrix\Calendar\Sync\Dictionary;
use Bitrix\Calendar\Sync\Entities\InstanceMap;
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\Google\Builders\BuilderEventConnectionFromExternalEvent;
use Bitrix\Calendar\Sync\Managers\OutgoingEventManagerInterface;
use Bitrix\Calendar\Sync\Util\EventContext;
use Bitrix\Calendar\Sync\Util\Result;
use Bitrix\Calendar\Util;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\LoaderException;
use Bitrix\Main\ObjectException;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
use DateTimeInterface;
use LogicException;
 
class OutgoingEventManager extends Manager implements OutgoingEventManagerInterface
{
    public const LINE_SEPARATOR = "\r\n";
    public const BATCH_PATH = 'https://www.googleapis.com/batch/calendar/v3/';
    public const CHUNK_LENGTH = 50;
 
    public function export(SyncEventMap $syncEventMap, SyncSectionMap $syncSectionMap): Result
    {
        $result = new Result();
        $result->setData([
            'syncEventMap' => $syncEventMap,
        ]);
 
        $syncEventListForExport = [];
        $delayExportSyncEventList = [];
 
        foreach ($syncEventMap as $syncEvent)
        {
            if (
                $syncEvent->getEventConnection()
                && ($syncEvent->getEvent()->getVersion() === $syncEvent->getEventConnection()->getVersion())
            )
            {
                continue;
            }
 
            if (
                $syncEvent->isRecurrence()
                && $instanceMap =  $syncEvent->getInstanceMap()
            )
            {
                if (empty($delayExportSyncEventList[$syncEvent->getEvent()->getSection()->getId()]))
                {
                    $delayExportSyncEventList[$syncEvent->getEvent()->getSection()->getId()] = [];
                }
 
                array_push($delayExportSyncEventList[$syncEvent->getEvent()->getSection()->getId()], ...$instanceMap);
            }
 
            $syncEventListForExport[$syncEvent->getEvent()->getSection()->getId()][$syncEvent->getEvent()->getUid()] = $syncEvent;
        }
 
        foreach ($syncSectionMap as $syncSection)
        {
            if ($syncEventList = ($syncEventListForExport[$syncSection->getSection()->getId()] ?? null))
            {
                $this->exportBatch(
                    $syncEventList,
                    $syncSection,
                    $delayExportSyncEventList[$syncSection->getSection()->getId()] ?? null
                );
            }
        }
 
        return new Result();
    }
 
    private function exportBatch(array $syncEventList, SyncSection $syncSection, ?array $syncEventInstanceList = null): void
    {
 
        // single or recurrence
        foreach (array_chunk($syncEventList, self::CHUNK_LENGTH) as $batch)
        {
            $body = $this->prepareMultipartMixed($batch, $syncSection);
            // TODO: Remake it: move this logic to parent::request().
            // Or, better, in separate class.
            $this->httpClient->post(self::BATCH_PATH, $body);
 
            $this->multipartDecode($this->httpClient->getResult(), $syncEventList);
        }
 
        // instances
        if ($syncEventInstanceList !== null)
        {
            foreach (array_chunk($syncEventInstanceList, self::CHUNK_LENGTH) as $batch)
            {
                $body = $this->prepareMultipartMixed($batch, $syncSection, $syncEventList);
                // TODO: Remake it: move this logic to parent::request().
                // Or, better, in separate class.
                $this->httpClient->post(self::BATCH_PATH, $body);
 
                $this->multipartDecode($this->httpClient->getResult(), $syncEventList);
            }
        }
    }
 
    private function prepareMultipartMixed(
        array $eventCollection,
        SyncSection $syncSection,
        array $syncEventList = []
    ): string
    {
        $boundary = $this->generateBoundary();
        $this->setContentTypeHeader($boundary);
        $data = implode('', $this->getBatchItemList(
            $eventCollection,
            $syncSection,
            $syncEventList,
            $boundary,
        ));
        $data .= "--{$boundary}--" . self::LINE_SEPARATOR;
 
        return $data;
    }
 
    private function calculateHttpMethod(SyncEvent $syncEvent): string
    {
        if (
            $syncEvent->isInstance()
            || ($syncEvent->getEventConnection() && $syncEvent->getEventConnection()->getVendorEventId())
        )
        {
            return HttpClient::HTTP_PUT;
        }
 
        if ($syncEvent->getAction() === Dictionary::SYNC_EVENT_ACTION['delete'])
        {
            return HttpClient::HTTP_DELETE;
        }
 
        return HttpClient::HTTP_POST;
    }
 
    private function multipartDecode($response, array $syncEventList): void
    {
        $boundary = $this->httpClient->getClient()->getHeaders()->getBoundary();
 
        $response = str_replace("--$boundary--", "--$boundary", $response);
        $parts = explode("--$boundary" . self::LINE_SEPARATOR, $response);
 
        foreach ($parts as $part)
        {
            $part = trim($part);
            if (!empty($part))
            {
                $partEvent = explode(self::LINE_SEPARATOR . self::LINE_SEPARATOR, $part);
                $data = $this->getMetaInfo($partEvent[1]);
 
 
                $eventId = $this->getId($partEvent[0]);
                if ($eventId === null)
                {
                    continue;
                }
 
                try
                {
                    $parsedData = Json::decode($partEvent[2]);
                }
                catch (ArgumentException $e)
                {
                    continue;
                }
 
                if ($data['status'] === 200)
                {
 
                    $syncEvent = $syncEventList[$parsedData['iCalUID']];
 
                    if ($syncEvent === null)
                    {
                        continue;
                    }
 
                    if ($syncEvent->hasInstances() && isset($parsedData['originalStartTime']))
                    {
                        $syncEvent = $this->getInstanceByOriginalDate($syncEvent, $parsedData);
 
                        // TODO: it's workaround to skip errors
                        if ($syncEvent === null)
                        {
                            continue;
                        }
                    }
 
                    $eventConnection = (new BuilderEventConnectionFromExternalEvent(
                        $parsedData,
                        $syncEvent,
                        $this->connection
                    ))->build();
 
                    $syncEvent
                        ->setEventConnection($eventConnection)
                        ->setAction(Dictionary::SYNC_EVENT_ACTION['success'])
                    ;
                }
                elseif (isset($parsedData['error']['code'], $parsedData['error']['message']))
                {
                    return;
                }
            }
        }
    }
 
    private function getMetaInfo($headers): array
    {
 
        $data = [];
        foreach (explode("\n", $headers) as $k => $header)
        {
            if($k === 0 && preg_match('#HTTP\S+ (\d+)#', $header, $find))
            {
                $data['status'] = (int)$find[1];
                continue;
            }
 
            if(mb_strpos($header, ':') !== false)
            {
                [$headerName, $headerValue] = explode(':', $header, 2);
                if(mb_strtolower($headerName) === 'etag')
                {
                    $data['etag'] = trim($headerValue);
                }
            }
        }
 
        return $data;
    }
 
    private function getId($headers): ?int
    {
        foreach (explode("\n", $headers) as $header)
        {
            if(mb_strpos($header, ':') !== false)
            {
                [$headerName, $headerValue] = explode(':', $header, 2);
                if(mb_strtolower($headerName) === 'content-id')
                {
                    $part = explode(':', $headerValue);
                    return (int)rtrim($part[1], '>');
                }
            }
        }
 
        return null;
    }
 
    private function prepareEventContextForInstance(
        ?SyncEvent $masterEvent,
        SyncEvent $syncEvent,
        EventContext $eventContext
    ): void
    {
        if ($masterEvent && $masterEvent->isSuccessAction())
        {
            $masterVendorEventId = $masterEvent->getVendorEventId();
        }
        else
        {
            //todo handle instance. possible write to log
            return;
        }
 
        $prefix = $syncEvent->getEvent()->isFullDayEvent()
            ? $syncEvent->getEvent()->getOriginalDateFrom()->format('Ymd')
            : $syncEvent->getEvent()->getOriginalDateFrom()->setTimeZone(Util::prepareTimezone())->format('Ymd\THis\Z')
        ;
        $eventContext->setEventConnection(
            (new EventConnection())
                ->setVendorEventId(
                    $masterVendorEventId
                    . '_'
                    . $prefix
                )
                ->setRecurrenceId($masterVendorEventId)
        );
    }
 
    private function getEventConverter(SyncEvent $syncEvent): EventConverter
    {
        return new EventConverter(
            $syncEvent->getEvent(),
            $syncEvent->getEventConnection(),
            $syncEvent->getInstanceMap()
        );
    }
 
    private function getInstanceByOriginalDate(SyncEvent $masterEvent, $event): ?SyncEvent
    {
        if (isset($event['originalStartTime']['dateTime']))
        {
            $eventOriginalStart = Date::createDateTimeFromFormat(
                $event['originalStartTime']['dateTime'],
                DateTimeInterface::ATOM
            );
        }
        elseif (isset($event['originalStartTime']['date']))
        {
            $eventOriginalStart = Date::createDateFromFormat(
                $event['originalStartTime']['date'],
                Helper::DATE_FORMAT
            );
        }
 
        return $masterEvent
            ->getInstanceMap()
            ->getItem(InstanceMap::getKeyByDate($eventOriginalStart));
    }
 
    private function prepareEventForInstance(SyncEvent $masterEvent, SyncEvent $syncEvent): void
    {
        if ($syncEvent->getEvent()->getVersion() < $masterEvent->getEvent()->getVersion())
        {
            $syncEvent->getEvent()->setVersion($masterEvent->getEvent()->getVersion());
        }
    }
 
    private function prepareContextForHttpQuery(
        SyncEvent $syncEvent,
        SyncSection $syncSection,
        array $syncEventList,
        EventManager $eventManager
    ): array
    {
        $method = $this->calculateHttpMethod($syncEvent);
 
        $eventContext = (new EventContext())->setSectionConnection($syncSection->getSectionConnection());
        if ($syncEvent->isInstance())
        {
            if ($eventConnection = $syncEvent->getEventConnection())
            {
                $eventContext->setEventConnection($eventConnection);
            }
            else
            {
                $this->prepareEventContextForInstance($syncEventList[$syncEvent->getUid()], $syncEvent, $eventContext);
                $this->prepareEventForInstance($syncEventList[$syncEvent->getUid()], $syncEvent);
                $syncEvent->setEventConnection($eventContext->getEventConnection());
            }
 
            if (
                ($eventContext->getSectionConnection() === null)
                || ($eventContext->getEventConnection() === null)
            )
            {
                throw new LogicException('you should set event or section info');
            }
 
            $methodHeader = $method . ' ' . $eventManager->prepareUpdateUrl($eventContext) . self::LINE_SEPARATOR;
            $converter = $this->getEventConverter($syncEvent);
            $vendorEvent = $converter->convertForUpdate();
        }
        elseif ($syncEvent->getEventConnection() !== null)
        {
            $eventContext->setEventConnection($syncEvent->getEventConnection());
            $methodHeader = $method . ' ' . $eventManager->prepareUpdateUrl($eventContext) . self::LINE_SEPARATOR;
            $converter = $this->getEventConverter($syncEvent);
            $vendorEvent = $converter->convertForUpdate();
        }
        elseif ($method !== Dictionary::SYNC_EVENT_ACTION['delete'])
        {
            $methodHeader = $method . ' ' . $eventManager->prepareCreateUrl($eventContext) . self::LINE_SEPARATOR;
            $converter = $this->getEventConverter($syncEvent);
            $vendorEvent = $converter->convertForCreate();
        }
        else
        {
            throw new LogicException('do not detect action');
        }
 
        return [$methodHeader, $vendorEvent];
    }
 
    private function prepareBatchItem(
        string $boundary,
        SyncEvent $syncEvent,
        array $vendorEvent,
        string $methodHeader
    ): string
    {
        $data = '--' . $boundary . self::LINE_SEPARATOR;
 
        $data .= 'Content-Type: application/http' . self::LINE_SEPARATOR;
 
        $id = $syncEvent->getEvent()->getId();
        $data .= "Content-ID: item{$id}:{$id}" . self::LINE_SEPARATOR . self::LINE_SEPARATOR;
 
        $content = Json::encode($vendorEvent, JSON_UNESCAPED_SLASHES);
 
        $data .= $methodHeader;
        $data .= 'Content-type: application/json' . self::LINE_SEPARATOR;
        $data .= 'Content-Length: ' . mb_strlen($content) . self::LINE_SEPARATOR . self::LINE_SEPARATOR;
 
        $data .= $content;
        $data .= self::LINE_SEPARATOR . self::LINE_SEPARATOR;
 
        return $data;
    }
 
    private function getBatchItemList(
        array $eventCollection,
        SyncSection $syncSection,
        array $syncEventList,
        string $boundary
    ): array
    {
        $batchItems = [];
        /*** @var SyncEvent $syncEvent */
        foreach ($eventCollection as $syncEvent)
        {
            try
            {
                $eventManager = new EventManager($this->connection, $this->userId);
                [$methodHeader, $vendorEvent] = $this->prepareContextForHttpQuery(
                    $syncEvent,
                    $syncSection,
                    $syncEventList,
                    $eventManager
                );
 
                $batchItems[] = $this->prepareBatchItem($boundary, $syncEvent, $vendorEvent, $methodHeader);
            }
            catch (LogicException $e)
            {
                // $syncEvent->setAction($this->calculateAction($syncEvent));
                continue;
            }
        }
 
        return $batchItems;
    }
 
    private function generateBoundary(): string
    {
        return 'BXC' . md5(mt_rand() . time());
    }
 
    private function setContentTypeHeader(string $boundary): void
    {
        $this->httpClient->getClient()->setHeader('Content-type', 'multipart/mixed; boundary=' . $boundary);
    }
 
    private function findSyncEvent(array $syncEventList, int $eventId): array
    {
        return array_filter($syncEventList, function (SyncEvent $syncEvent) use ($eventId) {
            if ($syncEvent->getEventId() === $eventId)
            {
                return true;
            }
 
            if ($syncEvent->hasInstances())
            {
                foreach ($syncEvent->getInstanceMap() as $instance)
                {
                    if ($syncEvent->getEventId() === $eventId)
                    {
                        return true;
                    }
                }
            }
 
            return false;
        });
    }
 
    private function calculateLastSyncStatusForFailedSyncEvent(SyncEvent $syncEvent, array $error)
    {
        if ($error['code'] === 404)
        {
            if (
                ($error['message'] === 'Not Found')
                && $syncEvent->getAction() === Dictionary::SYNC_EVENT_ACTION['update']
            )
            {
                $syncEvent->getEventConnection()->setLastSyncStatus(Dictionary::SYNC_STATUS['create']);
            }
        }
    }
 
    // /**
    //  * @param SyncEvent $syncEvent
    //  * @return void
    //  */
    // private function calculateAction(SyncEvent $syncEvent)
    // {
    //  $syncEvent->setAction(Dictionary::SYNC_EVENT_ACTION['success']);
    // }
}