apiclient.php

<?php
 
namespace Bitrix\Calendar\Sync\Office365;
 
use Bitrix\Calendar\Sync\Exceptions\PreconditionFailedException;
use Bitrix\Calendar\Sync\Office365\Util\ObjectStatusTrait;
use Bitrix\Calendar\Sync\Exceptions\ApiException;
use Bitrix\Calendar\Sync\Exceptions\AuthException;
use Bitrix\Calendar\Sync\Exceptions\GoneException;
use Bitrix\Calendar\Sync\Internals\ContextInterface;
use Bitrix\Calendar\Sync\Internals\HasContextTrait;
use Bitrix\Calendar\Sync\Exceptions\ConflictException;
use Bitrix\Calendar\Sync\Exceptions\NotFoundException;
use Bitrix\Calendar\Sync\Util\RequestLogger;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
use Exception;
 
class ApiClient
{
    use ObjectStatusTrait, HasContextTrait;
 
    protected HttpClient $httpClient;
    protected RequestLogger $logger;
 
    public function __construct(HttpClient $httpClient, ContextInterface $context)
    {
        $this->httpClient = $httpClient;
        $this->context = $context;
    }
 
    public function request(string $method, string $uri, array $params): array
    {
        $getLogContext = static function (int $statusCode, $response, string $error = '' )
            use ($method, $uri, $params): array
        {
            return [
                'serviceName' => Helper::ACCOUNT_TYPE,
                'host' => Helper::SERVER_PATH,
                'method' => $method,
                'url' => $uri,
                'requestParams' => $params,
                'statusCode' => $statusCode,
                'error' => $error,
                'response' => $response,
            ];
        };
        $this->getStatus()->resetErrors();
        try
        {
            $response = [];
            $paramString = $this->prepareParams($params);
 
            $uri = Helper::SERVER_PATH . $uri;
 
            $this->httpClient->waitResponse(true);
            $this->httpClient->query($method, $uri, $paramString);
 
            if ($this->httpClient->getStatus() < 300)
            {
                $response = $this->prepareResponse();
                $this->context->getLogger()
                    ->debug("API office365 success" . $this->httpClient->getStatus()
                        , $getLogContext(
                            $this->httpClient->getStatus(),
                            $this->httpClient->getResult(),
                        )
                    );
            }
            else
            {
                try
                {
                    $error = Json::decode($this->httpClient->getResult());
                    $this->getStatus()->addError(
                        "CONNECTION",
                        "[" . $error['error']['code'] . "] " . $error['error']['message'],
                    );
                    $this->context->getLogger()
                        ->warning("API office365 returned error code "
                                . $this->httpClient->getStatus()
                                . ": " . $error['error']['message'],
                            $getLogContext(
                                $this->httpClient->getStatus(),
                                $this->httpClient->getResult(),
                                $error['error']['message']
                            )
                        );
                    switch ($this->httpClient->getStatus())
                    {
                        case 401:
                            throw new AuthException(
                                $error['error']['code'],
                                401,
                                __FILE__,
                                __LINE__
                            );
                        case 404:
                            throw new NotFoundException(
                                $error['error']['code'],
                                404,
                                __FILE__,
                                __LINE__
                            );
                        case 409:
                            throw new ConflictException(
                                $error['error']['code'],
                                409,
                                __FILE__,
                                __LINE__
                            );
                        case 410:
                            throw new GoneException(
                                $error['error']['code'],
                                410,
                                __FILE__,
                                __LINE__
                            );
                        case 412:
                            throw new PreconditionFailedException(
                                $error['error']['code'],
                                412,
                                __FILE__,
                                __LINE__
                            );
                        default:
                            throw new ApiException(
                                $error['error']['code'],
                                $this->httpClient->getStatus(),
                                __FILE__,
                                __LINE__
                            );
                    }
                }
                catch (ArgumentException $exception)
                {
                    $this->context->getLogger()
                        ->error("ArgumentException from office365", $getLogContext(
                            $this->httpClient->getStatus(),
                            $this->httpClient->getResult(),
                            $exception->getMessage()
                        ));
                    foreach($this->httpClient->getError() as $code => $error)
                    {
                        $this->getStatus()->addError($code, $error);
                    }
                }
            }
        }
        catch (ApiException $e)
        {
            $this->context->getLogger()
                ->error("ApiException from office365", $getLogContext(
                    $e->getCode(),
                    '',
                    $e->getMessage()
                    )
                );
            throw $e;
        }
        catch (Exception $e)
        {
            $this->context->getLogger()
                ->error("Exception from office365: " . $e->getMessage(), $getLogContext(
                    $e->getCode(),
                    '',
                    $e->getMessage()
                    )
                );
            throw $e;
        }
 
        return $response;
    }
 
    protected function multipartDecode(string $response, string $boundary): array
    {
        $events = [];
 
        $response = str_replace("--$boundary--", "--$boundary", $response);
        $parts = explode("--$boundary\r\n", $response);
 
        foreach ($parts as $part)
        {
            $part = trim($part);
            if (!empty($part))
            {
                $partEvent = explode("\r\n\r\n", $part);
                $data = $this->getMetaInfo($partEvent[1]);
                $id = $this->getId($partEvent[0]);
 
                if ($data['status'] === 200)
                {
                    if ($id === null)
                    {
                        continue;
                    }
 
                    try
                    {
                        $event = Json::decode($partEvent[2]);
                    }
                    catch(Exception $exception)
                    {
                        continue;
                    }
 
                    $event['etag'] = $data['etag'];
                    $events[$id] = $event;
                }
                else
                {
                    AddMessage2Log('Event sync error. ID: ' . ($id ?? 'unknown'));
                }
            }
        }
 
        return $events;
    }
 
    private function getMetaInfo($headers): array
    {
        $data = [];
        foreach (explode("\n", $headers) as $k => $header)
        {
            if($k === 0)
            {
                if(preg_match('#HTTP\S+ (\d+)#', $header, $find))
                {
                    $data['status'] = (int)$find[1];
                }
            }
            elseif(mb_strpos($header, ':') !== false)
            {
                [$headerName, $headerValue] = explode(':', $header, 2);
                if(mb_strtolower($headerName) === 'etag')
                {
                    $data['etag'] = trim($headerValue);
                }
            }
        }
 
        return $data;
    }
 
    private function getId(string $headers): ?int
    {
        $id = null;
        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);
                    $id = (int) rtrim($part[1], ">");
                    break;
                }
            }
        }
 
        return $id;
    }
 
 
    protected function prepareParams(array $params): ?string
    {
        return $this->formatParams($params);
    }
 
    protected function formatParams(array $params): ?string
    {
        return $params ? Json::encode($params, JSON_UNESCAPED_SLASHES) : null;
    }
 
    public function get(string $uri, array $params = []): array
    {
        if ($params)
        {
            $uri .= (strpos($uri, '?') ? '&' : '?')
                . http_build_query($params)
            ;
        }
        return $this->request(HttpClient::HTTP_GET, $uri, $params);
    }
 
    public function post(string $uri, array $params = []): array
    {
        return $this->request(HttpClient::HTTP_POST, $uri, $params);
    }
 
    public function delete(string $uri, array $params = []): array
    {
        return $this->request(HttpClient::HTTP_DELETE, $uri, $params);
    }
 
    public function put(string $uri, array $params = []): array
    {
        return $this->request(HttpClient::HTTP_PUT, $uri, $params);
    }
 
    public function patch(string $uri, array $params = []): array
    {
        return $this->request(HttpClient::HTTP_PATCH, $uri, $params);
    }
 
    protected function prepareResponse()
    {
        $contentType = $this->httpClient->getHeaders()->getContentType();
 
        if ($contentType === 'multipart/mixed')
        {
            $response = $this->multipartDecode(
                $this->httpClient->getResult(),
                $this->httpClient->getHeaders()->getBoundary()
            );
        }
        else
        {
            $response = $this->httpClient->getResult()
                ? Json::decode($this->httpClient->getResult())
                : [];
        }
 
        return $response;
    }
}