api.php

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

<?php
 
namespace Sale\Handlers\Delivery\YandexTaxi\Api;
 
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Result;
use Bitrix\Main\Error;
use Bitrix\Main\Web\HttpClient;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\CancelInfoResult;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\Journal\EventBuilder;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\PhoneResult;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\PriceResult;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\SingleClaimResult;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\Tariff;
use Sale\Handlers\Delivery\YandexTaxi\Api\ApiResult\TariffsResult;
use Sale\Handlers\Delivery\YandexTaxi\Api\ClaimReader\ClaimReader;
use Sale\Handlers\Delivery\YandexTaxi\Api\RequestEntity\Claim;
use Sale\Handlers\Delivery\YandexTaxi\Api\RequestEntity\Estimation;
use Sale\Handlers\Delivery\YandexTaxi\Api\RequestEntity\OfferEstimation;
use Sale\Handlers\Delivery\YandexTaxi\Api\RequestEntity\TariffsOptions;
use Sale\Handlers\Delivery\YandexTaxi\Api\Transport;
use Sale\Handlers\Delivery\YandexTaxi\Common\Logger;

final class Api
{
    private const SINGLE_POINT_API_VERSION = 1;
    private const MULTI_POINT_API_VERSION = 2;
 
    private const LOG_SOURCE = 'api';

    private $transport;

    private $claimReader;

    private $eventBuilder;

    private $logger;

    public function __construct(
        Transport\Client $transport,
        ClaimReader $claimReader,
        EventBuilder $eventBuilder,
        Logger $logger
    )
    {
        $this->transport = $transport;
        $this->claimReader = $claimReader;
        $this->eventBuilder = $eventBuilder;
        $this->logger = $logger;
    }

    public function checkPrice(Estimation $estimation): PriceResult
    {
        $result = new PriceResult();
 
        try
        {
            $response = $this->transport->request(
                self::SINGLE_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'check-price',
                null,
                $estimation
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'check_price', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'check_price');
        }
 
        if (
            !isset($body['price'])
            || !isset($body['currency_rules']['code'])
            || (float)$body['price'] <= 0
        )
        {
            return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_RATE_CALCULATE_ERROR')));
        }
 
        $result
            ->setPrice((float)$body['price'])
            ->setCurrency((string)$body['currency_rules']['code'])
        ;
 
        if (isset($body['eta']))
        {
            $result->setEta((int)$body['eta']);
        }
 
        return $result;
    }

    public function offersCalculate(OfferEstimation $estimation): Result
    {
        $result = new PriceResult();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'offers/calculate',
                null,
                $estimation
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'offers/calculate', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'offers/calculate');
        }
 
        if (
            !isset($body['offers'])
            || !is_array($body['offers'])
        )
        {
            return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_RATE_CALCULATE_ERROR')));
        }
 
        $maxOfferByPrice  = null;
 
        foreach ($body['offers'] as $offer)
        {
            if (
                !isset($offer['price']['total_price_with_vat'])
                || !isset($offer['price']['currency'])
                || !isset($offer['payload'])
                || (float)$offer['price']['total_price_with_vat'] < 0
            )
            {
                continue;
            }
 
            if (is_null($maxOfferByPrice))
            {
                $maxOfferByPrice = $offer;
 
                continue;
            }
 
            if ((float)$offer['price']['total_price_with_vat'] > (float)$maxOfferByPrice['price']['total_price_with_vat'])
            {
                $maxOfferByPrice = $offer;
            }
        }
 
        if (is_null($maxOfferByPrice))
        {
            return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_RATE_CALCULATE_ERROR')));
        }
 
        $result
            ->setPrice((float)$maxOfferByPrice['price']['total_price_with_vat'])
            ->setCurrency((string)$maxOfferByPrice['price']['currency'])
            ->setData(['offerPayload' => (string)$maxOfferByPrice['payload']])
        ;
 
        return $result;
    }

    public function getTariffs(TariffsOptions $tariffsOptions): TariffsResult
    {
        $result = new TariffsResult();
 
        try
        {
            $response = $this->transport->request(
                self::SINGLE_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'tariffs',
                null,
                $tariffsOptions
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'tariffs', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'tariffs');
        }
 
        if (isset($body['available_tariffs']) && is_array($body['available_tariffs']))
        {
            foreach ($body['available_tariffs'] as $tariff)
            {
                if (!isset($tariff['name']))
                {
                    continue;
                }
 
                $tariffObject = new Tariff($tariff['name']);
 
                if (isset($tariff['supported_requirements']) && is_array($tariff['supported_requirements']))
                {
                    foreach ($tariff['supported_requirements'] as $supportedRequirement)
                    {
                        if (!isset($supportedRequirement['name']))
                        {
                            continue;
                        }
 
                        if ($supportedRequirement['name'] === 'cargo_options')
                        {
                            if (isset($supportedRequirement['options']) && is_array($supportedRequirement['options']))
                            {
                                foreach ($supportedRequirement['options'] as $option)
                                {
                                    if (isset($option['value']) && !empty($option['value']))
                                    {
                                        $tariffObject->addSupportedRequirement($option['value']);
                                    }
                                }
                            }
                        }
                        else
                        {
                            $tariffObject->addSupportedRequirement($supportedRequirement['name']);
                        }
                    }
                }
 
                $result->addTariff($tariffObject);
            }
        }
 
        return $result;
    }

    public function createClaim(Claim $claim): SingleClaimResult
    {
        $result = new SingleClaimResult();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/create',
                ['request_id' => uniqid('', true)],
                $claim
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'create_claim', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'create');
        }
 
        $claimReadResult = $this->claimReader->readFromArray($body);
        if ($claimReadResult->isSuccess())
        {
            return $result->setClaim($claimReadResult->getClaim());
        }
 
        return $result;
    }

    public function acceptClaim(string $claimId, int $version): Result
    {
        $result = new Result();
 
        try
        {
            $response = $this->transport->request(
                self::SINGLE_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/accept',
                ['claim_id' => $claimId],
                ['version' => $version]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'accept_claim', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'accept');
        }
 
        return $result;
    }

    public function cancelClaim(string $claimId, int $version, string $cancelState): Result
    {
        $result = new Result();
 
        try
        {
            $response = $this->transport->request(
                self::SINGLE_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/cancel',
                ['claim_id' => $claimId],
                [
                    'version' => $version,
                    'cancel_state' => $cancelState,
                ]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'cancel_claim', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'cancel');
        }
 
        return $result;
    }

    public function getCancelInfo(string $claimId): CancelInfoResult
    {
        $result = new CancelInfoResult();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/cancel-info',
                ['claim_id' => $claimId]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'cancel_info', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'cancel_info');
        }
 
        if (empty($body['cancel_state']))
        {
            return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_CANCELLATION_FATAL_ERROR')));
        }
 
        return $result->setCancelState($body['cancel_state']);
    }

    public function getClaim(string $claimId): SingleClaimResult
    {
        $result = new SingleClaimResult();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/info',
                ['claim_id' => $claimId]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'get_claim', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'info');
        }
 
        $claimReadResult = $this->claimReader->readFromArray($body);
        if ($claimReadResult->isSuccess())
        {
            return $result->setClaim($claimReadResult->getClaim());
        }
 
        return $result;
    }

    public function getPhone(string $claimId): PhoneResult
    {
        $result = new PhoneResult();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'driver-voiceforwarding',
                null,
                ['claim_id' => $claimId]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'get_phone', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'driver-voiceforwarding');
        }
 
        if (isset($body['phone']))
        {
            $result->setPhone($body['phone']);
        }
        if (isset($body['ext']))
        {
            $result->setExt($body['ext']);
        }
        if (isset($body['ttl_seconds']))
        {
            $result->setTtlSeconds($body['ttl_seconds']);
        }
 
        return $result;
    }

    public function getJournalRecords($cursor): ApiResult\Journal\Result
    {
        $result = new ApiResult\Journal\Result();
 
        try
        {
            $response = $this->transport->request(
                self::MULTI_POINT_API_VERSION,
                HttpClient::HTTP_POST,
                'claims/journal',
                null,
                is_null($cursor) ? new \stdClass() : ['cursor' => $cursor]
            );
        }
        catch (Transport\Exception $requestException)
        {
            return $this->respondTransportError($result);
        }
 
        $statusCode = $response->getStatus();
        $body = $response->getBody();
 
        if ($statusCode !== 200)
        {
            $this->logger->log(static::LOG_SOURCE, 'get_journal_records_1', $response->toString());
            return $this->respondStatusError($result, $statusCode, 'journal');
        }
 
        if (!is_array($body) || !isset($body['cursor']) || !isset($body['events']))
        {
            $this->logger->log(static::LOG_SOURCE, 'get_journal_records_2', $response->toString());
 
            return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_NETWORK_ERROR_UNEXPECTED_ERROR')));
        }
 
        $result->setCursor($body['cursor']);
 
        if (is_array($body['events']))
        {
            foreach ($body['events'] as $event)
            {
                $event = $this->eventBuilder->build($event);
                if (is_null($event))
                {
                    continue;
                }
 
                $result->addEvent($event);
            }
        }
 
        return $result;
    }

    private function respondStatusError($result, int $statusCode, string $method)
    {
        $error = Loc::getMessage('SALE_YANDEX_TAXI_NETWORK_ERROR_UNEXPECTED_ERROR');
 
        if ($statusCode == 401)
        {
            $error = Loc::getMessage('SALE_YANDEX_TAXI_AUTHENTICATION_ERROR');
        }
        elseif ($statusCode == 404)
        {
            $error = Loc::getMessage('SALE_YANDEX_TAXI_ORDER_NOT_FOUND_ERROR');
        }
        elseif ($statusCode == 409)
        {
            $error = Loc::getMessage('SALE_YANDEX_TAXI_OPERATION_REJECTED');
        }
 
        return $result->addError(new Error($error));
    }

    private function respondTransportError($result)
    {
        return $result->addError(new Error(Loc::getMessage('SALE_YANDEX_TAXI_NETWORK_ERROR')));
    }

    public function getTransport(): Transport\Client
    {
        return $this->transport;
    }
}