apiservice.php

<?php
 
namespace Bitrix\Calendar\Sync\Office365;
 
use Bitrix\Calendar\Core\Base\BaseException;
use Bitrix\Calendar\Sync\Dictionary;
use Bitrix\Calendar\Sync\Exceptions\ApiException;
use Bitrix\Calendar\Sync\Exceptions\AuthException;
use Bitrix\Calendar\Sync\Exceptions\ConflictException;
use Bitrix\Calendar\Sync\Exceptions\GoneException;
use Bitrix\Calendar\Sync\Exceptions\NotFoundException;
use Bitrix\Calendar\Sync\Exceptions\PreconditionFailedException;
use Bitrix\Calendar\Sync\Exceptions\RemoteAccountException;
use Bitrix\Calendar\Sync\Internals\ContextInterface;
use Bitrix\Calendar\Sync\Internals\HasContextTrait;
use Bitrix\Calendar\Sync\Office365\Dto\EventDto;
use Bitrix\Calendar\Sync\Office365\Dto\SectionDto;
use Bitrix\Calendar\Sync\Connection\SectionConnection;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentNullException;
use Bitrix\Main\LoaderException;
use CCalendar;
use Generator;
 
class ApiService
{
    use HasContextTrait;
 
    private $helper;
    private $apiClient;
 
    public function __construct(ContextInterface $context)
    {
        $this->context = $context;
        $this->apiClient = $this->context->getApiClient();
        $this->helper = $this->context->getHelper();
    }
 
    public function getCalendarList(array $params): array
    {
        $response = $this->apiClient->get('me/calendars', $params);
 
        return (array) $response['value'];
    }
 
    public function getEventList(array $params): array
    {
        $response = $this->apiClient->get(
            'me/calendars/' . $params['filter']['section_id'] . '/events',
            $params
        );
 
        return (array) $response['value'];
    }
 
    public function createSection(SectionDto $sectionDto): array
    {
        return $this->apiClient->post('me/calendars?', array_filter($sectionDto->toArray()));
    }
 
    public function updateSection(SectionDto $sectionDto): array
    {
        return $this->apiClient->patch('me/calendars/' . $sectionDto->id, array_filter($sectionDto->toArray()));
    }
 
    public function createEvent(EventDto $eventDto, string $sectionId): array
    {
        return $this->apiClient->post(
            'me/calendars/' . $sectionId . '/events',
            array_filter($eventDto->toArray(true), static function ($val) {
                return $val !== [] && $val !== null;
            })
        );
    }
 
    public function getCalendarDelta(SectionConnection $sectionConnection): Generator
    {
        $baseUri = 'me/calendars/' . $sectionConnection->getVendorSectionId() . '/calendarView/delta?';
        $breakingFlag = false;
        do {
            $uri = $this->getDeltaUri($sectionConnection, $baseUri);
 
            try
            {
                $response = $this->apiClient->get($uri);
                if (!empty($response))
                {
                    $breakingFlag = $this->processResponseAfterDelta($sectionConnection, $response);
                }
                if (!empty($response['value']))
                {
                    yield $response['value'];
                }
                else
                {
                    break;
                }
            }
            catch(GoneException $e)
            {
                if ($sectionConnection->getPageToken())
                {
                    $sectionConnection->setPageToken(null);
                }
                elseif ($sectionConnection->getSyncToken())
                {
                    $sectionConnection->setSyncToken(null);
                }
            }
        }
        while(!$breakingFlag);
    }
 
    private function getUriParam(string $uri, string $name): ?string
    {
        $result = null;
        if ($urlData = parse_url($uri))
        {
            parse_str($urlData['query'], $params);
            $result = $params[$name] ?? null;
        }
 
        return $result;
    }
 
    public function getEvent(array $params): array
    {
        return $this->apiClient->get(
            'me/events/' . $params['filter']['event_id'],
            $params
        );
    }
 
    public function updateEvent(EventDto $eventDto, string $vendorEventId): array
    {
        if ($eventDto->isCancelled)
        {
            $response = $this->apiClient->post(
                'me/events/' . $vendorEventId . '/cancel',
                [
                    'Comment' => 'Deleted from Bitrix',
                ]
            );
        }
        else
        {
            try
            {
                $response = $this->apiClient->patch(
                    'me/events/' . $vendorEventId,
                    array_filter($eventDto->toArray(true), static function ($val) {
                        return $val !== [] && $val !== null;
                    })
                );
            }
            catch (NotFoundException|PreconditionFailedException $exception)
            {
                return [];
            }
        }
 
        return $response;
    }
 
    public function getEventInstances(array $params): array
    {
        return $this->apiClient->get(
            'me/events/' . $params['filter']['event_id'] . '/instances',
            [
                'startDateTime' => $params['filter']['from'],
                'endDateTime' => $params['filter']['to'],
            ]
        );
    }
 
    public function deleteEvent(string $vendorEventId)
    {
        try
        {
            $this->apiClient->delete(
                'me/events/' . $vendorEventId,
            );
        }
        catch (NotFoundException $exception)
        {
            return;
        }
    }
 
    public function deleteSection(string $vendorSectionId)
    {
        $this->apiClient->delete(
            'me/calendars/' . $vendorSectionId,
        );
    }
 
    public function addSectionSubscription(string $vendorSectionId, string $state = ''): array
    {
        $data = [
            'changeType' => 'created,updated,deleted',
            'notificationUrl' => $this->getNotificationUrl(),
            'resource' => "me/calendars/$vendorSectionId/events",
            'expirationDateTime' => $this->getExpirationDateTime(),
            'clientState' => $state,
            'latestSupportedTlsVersion' => 'v1_2',
        ];
 
        return $this->apiClient->post('subscriptions', $data);
    }
 
    public function renewSectionSubscription(string $subscriptionId): array
    {
        return $this->apiClient->patch('subscriptions/' . $subscriptionId, [
            'expirationDateTime' => $this->getExpirationDateTime(),
        ]);
    }
 
    public function deleteSectionSubscription(string $subscriptionId): array
    {
        try
        {
            return $this->apiClient->delete('subscriptions/' . $subscriptionId);
        }
        catch (NotFoundException|AuthException $exception)
        {
            return [];
        }
    }
 
    public function getDeltaUri(SectionConnection $sectionConnection, string $baseUri): string
    {
        if ($sectionConnection->getPageToken())
        {
            $uri = $baseUri . '$skiptoken=' . $sectionConnection->getPageToken();
        }
        elseif ($sectionConnection->getSyncToken())
        {
            $uri = $baseUri . '$deltatoken=' . $sectionConnection->getSyncToken();
        }
        else
        {
            $interval = $this->helper->getDeltaInterval();
            $uri = $baseUri . 'startDateTime=' . $interval['from']->format($this->helper::TIME_FORMAT_LONG)
                . '&endDateTime=' . $interval['to']->format($this->helper::TIME_FORMAT_LONG);
        }
        return $uri;
    }
 
    private function processResponseAfterDelta(SectionConnection $sectionConnection, array $response): bool
    {
        $sectionConnection->setLastSyncStatus(Dictionary::SYNC_STATUS['success']);
        $breakingFlag = true;
 
        if ($token = $this->getPageToken($response))
        {
            $sectionConnection->setPageToken($token);
            $breakingFlag = false;
        }
        elseif ($token = $this->getSyncToken($response))
        {
            $sectionConnection->setPageToken(null);
            $sectionConnection->setSyncToken($token);
        }
        else
        {
            $sectionConnection->setPageToken(null);
            $sectionConnection->setSyncToken(null);
        }
 
        return $breakingFlag;
    }
 
    private function getPageToken(array $response): ?string
    {
        return !empty($response['@odata.nextLink'])
            ? $this->getUriParam($response['@odata.nextLink'], '$skiptoken')
            : null
            ;
    }
    private function getSyncToken(array $response): ?string
    {
        return !empty($response['@odata.deltaLink'])
            ? $this->getUriParam($response['@odata.deltaLink'], '$deltatoken')
            : null
            ;
    }
 
    private function getNotificationUrl(): string
    {
        return str_replace('http:', 'https:', CCalendar::GetServerPath())
            . $this->helper::PUSH_PATH;
    }
 
    private function getExpirationDateTime(): string
    {
        $time = time() + 70 * 60 * 60;
        return date("c", $time);
    }
}