handler.php

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

<?php
 
namespace Sale\Handlers\PaySystem;
 
use Bitrix\Main\Localization;
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Request;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Sale\Cashbox;
use Bitrix\Sale\Payment;
use Bitrix\Sale\PaymentCollection;
use Bitrix\Sale\PaySystem;
use Bitrix\Sale\PriceMaths;
use Bitrix\Sale\Services\Base\RestrictionInfo;
use Bitrix\Sale\Services\Base\RestrictionInfoCollection;
use Bitrix\Seo;
 
Localization\Loc::loadMessages(__FILE__);

class YandexCheckoutHandler
    extends PaySystem\ServiceHandler
    implements
    PaySystem\IRefund,
    PaySystem\IPartialHold,
    PaySystem\IRecurring,
    PaySystem\Cashbox\ISupportPrintCheck,
    PaySystem\Cashbox\IFiscalizationAware
{
    const CMS_NAME = 'api_1c-bitrix';

    public const PAYMENT_STATUS_WAITING_FOR_CAPTURE = 'waiting_for_capture';
    public const PAYMENT_STATUS_PENDING = 'pending';
    public const AUTH_TYPE = 'yandex';
 
    public const PAYMENT_STATUS_SUCCEEDED = 'succeeded';
    public const PAYMENT_STATUS_CANCELED = 'canceled';
 
    public const PAYMENT_METHOD_SMART = '';
    public const PAYMENT_METHOD_ALFABANK = 'alfabank';
    public const PAYMENT_METHOD_BANK_CARD = 'bank_card';
    public const PAYMENT_METHOD_YANDEX_MONEY = 'yoo_money';
    public const PAYMENT_METHOD_SBERBANK = 'sberbank';
    public const PAYMENT_METHOD_CASH = 'cash';
    public const PAYMENT_METHOD_EMBEDDED = 'embedded';
    public const PAYMENT_METHOD_TINKOFF_BANK = 'tinkoff_bank';
    public const PAYMENT_METHOD_SBP = 'sbp';
    public const PAYMENT_METHOD_SBER_LOAN = 'sber_loan';
 
    public const MODE_SMART = '';
    public const MODE_ALFABANK = 'alfabank';
    public const MODE_BANK_CARD = 'bank_card';
    public const MODE_YANDEX_MONEY = 'yoo_money';
    public const MODE_SBERBANK = 'sberbank';
    public const MODE_SBERBANK_SMS = 'sberbank_sms';
    public const MODE_SBERBANK_QR = 'sberbank_qr';
    public const MODE_CASH = 'cash';
    public const MODE_MOBILE_BALANCE = 'mobile_balance';
    public const MODE_EMBEDDED = 'embedded';
    public const MODE_TINKOFF_BANK = 'tinkoff_bank';
    public const MODE_SBP = 'sbp';
    public const MODE_SBER_LOAN = 'sber_loan';
 
    public const URL = 'https://api.yookassa.ru/v3';
 
    private const CALLBACK_IP_LIST = [
        '185.71.76.0/27',
        '185.71.77.0/27',
        '77.75.153.0/25',
        '77.75.154.128/25',
        '77.75.156.11',
        '77.75.156.35',
    ];
 
    private const CONFIRMATION_TYPE_REDIRECT = "redirect";
    private const CONFIRMATION_TYPE_EXTERNAL = "external";
    private const CONFIRMATION_TYPE_EMBEDDED = "embedded";
    private const CONFIRMATION_TYPE_QR = 'qr';
 
    private const SEND_METHOD_HTTP_POST = "POST";
    private const SEND_METHOD_HTTP_GET = "GET";
 
    use PaySystem\Cashbox\CheckTrait;

    public function initiatePay(Payment $payment, Request $request = null)
    {
        if ($request === null)
        {
            $request = Main\Context::getCurrent()->getRequest();
        }
 
        $result = new PaySystem\ServiceResult();
 
        $yandexPaymentData = [];
 
        if ($payment->getField("PS_INVOICE_ID"))
        {
            $yandexPaymentResult = $this->getYandexPayment($payment);
            if ($yandexPaymentResult->isSuccess())
            {
                $yandexPaymentData = $yandexPaymentResult->getData();
            }
        }
 
        $isNeedCreate = $this->needCreateYandexPayment($payment, $request, $yandexPaymentData);
        if ($isNeedCreate)
        {
            $createYandexPaymentResult = $this->createYandexPayment($payment, $request);
            if (!$createYandexPaymentResult->isSuccess())
            {
                return $createYandexPaymentResult;
            }
 
            $yandexPaymentData = $createYandexPaymentResult->getData();
 
            if (isset($yandexPaymentData['id']))
            {
                $result->setPsData(['PS_INVOICE_ID' => $yandexPaymentData['id']]);
            }
        }
 
        $template = $this->getTemplateName($request, $yandexPaymentData);
 
        $this->setExtraParams(
            $this->getTemplateParams($payment, $template, $yandexPaymentData)
        );
 
        $showTemplateResult = $this->showTemplate($payment, $template);
        if ($showTemplateResult->isSuccess())
        {
            $result->setTemplate($showTemplateResult->getTemplate());
        }
        else
        {
            $result->addErrors($showTemplateResult->getErrors());
        }
 
        if ($isNeedCreate && !empty($yandexPaymentData['confirmation']['confirmation_url']))
        {
            $result->setPaymentUrl($yandexPaymentData['confirmation']['confirmation_url']);
        }
 
        if (!empty($yandexPaymentData['confirmation']['confirmation_data']) && $this->isQrPaymentType())
        {
            $qrCode = self::generateQrCode($yandexPaymentData['confirmation']['confirmation_data']);
            if ($qrCode)
            {
                $result->setQr(base64_encode($qrCode));
            }
        }
 
        return $result;
    }

    protected function needCreateYandexPayment(Payment $payment, Request $request, $additionalParams = []): bool
    {
        if (($additionalParams['status'] ?? '') === self::PAYMENT_STATUS_SUCCEEDED)
        {
            return false;
        }
 
        $template = $this->getTemplateName($request, $additionalParams);
 
        return $template !== 'template_query';
    }

    protected function getTemplateParams(Payment $payment, $template, $additionalParams = []) : array
    {
        $params = [
            'SUM' => PriceMaths::roundPrecision($payment->getSum()),
            'CURRENCY' => $payment->getField('CURRENCY'),
        ];
 
        if ($template === 'template')
        {
            $params['URL'] = $additionalParams['confirmation']['confirmation_url'] ?? '';
        }
        elseif ($template === 'template_query')
        {
            $phoneFields = $this->getPhoneFields();
            $phoneFields = $phoneFields[$this->service->getField('PS_MODE')] ?? [];
 
            $params['FIELDS'] = $this->getPaymentMethodFields();
            $params['PHONE_FIELDS'] = $phoneFields;
            $params['PHONE_NUMBER'] = $this->getPhoneNumber($payment) ?? "";
            $params['PAYMENT_METHOD'] = $this->service->getField('PS_MODE');
            $params['PAYMENT_ID'] = $payment->getId();
            $params['PAYSYSTEM_ID'] = $this->service->getField('ID');
            $params['RETURN_URL'] = $this->getReturnUrl($payment);
        }
        elseif ($template === 'template_embedded')
        {
            $params['CONFIRMATION_TOKEN'] = $additionalParams['confirmation']['confirmation_token'] ?? '';
            $params['RETURN_URL'] = $this->getReturnUrl($payment);
        }
        elseif ($template === 'template_qr')
        {
            $params['URL'] = $additionalParams['confirmation']['confirmation_data'] ?? '';
            $params['QR_CODE_IMAGE'] = '';
 
            $qrCode = self::generateQrCode($params['URL']);
            if ($qrCode)
            {
                $params['QR_CODE_IMAGE'] = base64_encode($qrCode);
            }
        }
 
        return $params;
    }

    protected function getTemplateName(Request $request, $additionalParams = []): string
    {
        $template = null;
 
        if (isset($additionalParams["status"])
            && $additionalParams["status"] === self::PAYMENT_STATUS_SUCCEEDED
        )
        {
            return "template_success";
        }
 
        if ($this->hasPaymentMethodFields() &&
            !$this->isFillPaymentMethodFields($request)
        )
        {
            $template = "template_query";
        }
        elseif ($this->isSetExternalPaymentType())
        {
            $template = "template_success";
        }
        elseif ($this->isSetEmbeddedPaymentType())
        {
            $template = "template_embedded";
        }
        elseif ($this->isQrPaymentType())
        {
            $template = "template_qr";
        }
 
        return $template ?? "template";
    }

    private function isSetExternalPaymentType(): bool
    {
        $externalPayment = [
            static::MODE_ALFABANK,
            static::MODE_SBERBANK_SMS
        ];
 
        return in_array($this->service->getField('PS_MODE'), $externalPayment, true);
    }

    private function isSetEmbeddedPaymentType(): bool
    {
        return $this->service->getField('PS_MODE') === static::MODE_EMBEDDED;
    }
 
    private function isQrPaymentType(): bool
    {
        $qrPayment = [
            static::MODE_SBP,
            static::MODE_SBERBANK_QR,
        ];
 
        return in_array($this->service->getField('PS_MODE'), $qrPayment, true);
    }

    private function createYandexPayment(Payment $payment, Request $request, bool $isRepeated = false): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $url = $this->getUrl($payment, 'pay');
        $headers = $this->getHeaders($payment);
 
        if ($isRepeated)
        {
            $params = $this->getYandexRepeatedPaymentQueryParams($payment, $request);
        }
        else
        {
            $params = $this->getYandexPaymentQueryParams($payment, $request);
        }
 
        if ($this->service->canPrintCheckSelf($payment))
        {
            $receiptResult = $this->getReceipt($payment);
            if (!$receiptResult->isSuccess())
            {
                $result->addErrors($receiptResult->getErrors());
                return $result;
            }
 
            $receiptData = $receiptResult->getData();
            $params['receipt'] = $receiptData['receipt'];
 
            PaySystem\Logger::addDebugInfo(__CLASS__ . ": receipt = " . self::encode($receiptData['receipt']));
        }
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $headers, $params);
        if (!$sendResult->isSuccess())
        {
            $result->addErrors($sendResult->getErrors());
            return $result;
        }
 
        $response = $sendResult->getData();
 
        $verificationResult = $this->verifyYandexPayment($response);
        if ($verificationResult->isSuccess())
        {
            $result->setData($response);
        }
        else
        {
            $result->addErrors($verificationResult->getErrors());
        }
 
        return $result;
    }

    private function verifyYandexPayment($response): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        if ($response['status'] === static::PAYMENT_STATUS_CANCELED)
        {
            $error = Localization\Loc::getMessage(
                'SALE_HPS_YANDEX_CHECKOUT_RESPONSE_ERROR_' . mb_strtoupper($response['cancellation_details']['reason'])
            );
            if ($error)
            {
                $result->addError(
                    PaySystem\Error::createForBuyer($error, $response['cancellation_details']['party'])
                );
            }
            else
            {
                $result->addError(
                    PaySystem\Error::create(Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_PAYMENT_CANCELED'))
                );
            }
        }
 
        return $result;
    }

    private function getIdempotenceKey(): string
    {
        return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
            mt_rand(0, 0xffff), mt_rand(0, 0xffff),
            mt_rand(0, 0xffff),
            mt_rand(0, 0x0fff) | 0x4000,
            mt_rand(0, 0x3fff) | 0x8000,
            mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
        );
    }

    private function send($method, $url, array $headers, array $params = array()): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $httpClient = new HttpClient();
        foreach ($headers as $name => $value)
        {
            $httpClient->setHeader($name, $value);
        }
 
        if ($method === self::SEND_METHOD_HTTP_GET)
        {
            $response = $httpClient->get($url);
        }
        else
        {
            $postData = null;
            if ($params)
            {
                $postData = static::encode($params);
            }
 
            PaySystem\Logger::addDebugInfo(__CLASS__.': request data: '.$postData);
 
            $response = $httpClient->post($url, $postData);
        }
 
        if ($response === false)
        {
            $errors = $httpClient->getError();
            if ($errors)
            {
                $errorMessages = [];
                foreach ($errors as $code => $message)
                {
                    $errorMessages[] = "{$code}={$message}";
                }
 
                PaySystem\Logger::addDebugInfo(
                    __CLASS__ . ': response error: ' . implode(', ', $errorMessages)
                );
            }
 
            $result->addError(new Main\Error(Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_QUERY')));
            return $result;
        }
 
        PaySystem\Logger::addDebugInfo(__CLASS__.': response data: '.$response);
 
        $response = static::decode($response);
 
        $httpStatus = $httpClient->getStatus();
        if ($httpStatus === 200)
        {
            $result->setData($response);
        }
        elseif ($httpStatus !== 201)
        {
            if ($httpStatus === 401 && self::isOAuth())
            {
                $error = Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_HTTP_STATUS_OAUTH_'.$httpStatus.'');
            }
            else
            {
                $error = Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_HTTP_STATUS_'.$httpStatus);
            }
 
            if ($error)
            {
                $result->addError(PaySystem\Error::create($error));
            }
            elseif (isset($response['type']) && $response['type'] === 'error')
            {
                $result->addError(PaySystem\Error::create($response['description']));
            }
        }
 
        return $result;
    }

    private function getYandexBasePaymentQueryParams(Payment $payment): array
    {
        return [
            'description' => $this->getPaymentDescription($payment),
            'amount' => [
                'value' => (string)PriceMaths::roundPrecision($payment->getSum()),
                'currency' => $payment->getField('CURRENCY'),
            ],
            'capture' => true,
            'metadata' => [
                'BX_PAYMENT_NUMBER' => $payment->getId(),
                'BX_PAYSYSTEM_CODE' => $this->service->getField('ID'),
                'BX_HANDLER' => 'YANDEX_CHECKOUT',
                'cms_name' => static::CMS_NAME,
            ],
        ];
    }

    protected function getYandexPaymentQueryParams(Payment $payment, Request $request)
    {
        $query = $this->getYandexBasePaymentQueryParams($payment);
 
        $query['confirmation'] = [
            'type' => self::CONFIRMATION_TYPE_REDIRECT,
            'return_url' => $this->getReturnUrl($payment),
        ];
 
        $articleId = $this->getBusinessValue($payment, 'YANDEX_CHECKOUT_SHOP_ARTICLE_ID');
        if ($articleId)
        {
            $query['recipient'] = ['gateway_id' => $articleId];
        }
 
        if ($this->isSetEmbeddedPaymentType())
        {
            $query['confirmation'] = [
                'type' => self::CONFIRMATION_TYPE_EMBEDDED,
            ];
        }
        elseif ($this->isQrPaymentType())
        {
            $query['confirmation'] = [
                'type' => self::CONFIRMATION_TYPE_QR,
            ];
            $query['payment_method_data'] = [
                'type' => $this->getYandexHandlerType($this->service->getField('PS_MODE')),
            ];
        }
        elseif ($this->service->getField('PS_MODE') !== static::MODE_SMART)
        {
            $query['capture'] = true;
            $query['payment_method_data'] = [
                'type' => $this->getYandexHandlerType($this->service->getField('PS_MODE'))
            ];
 
            if ($this->isSetExternalPaymentType())
            {
                $query['confirmation'] = [
                    'type' => self::CONFIRMATION_TYPE_EXTERNAL,
                ];
            }
 
            if ($this->hasPaymentMethodFields())
            {
                $fields = $this->getPaymentMethodFields();
                if ($fields)
                {
                    foreach ($fields as $field)
                    {
                        $fieldValue = $request->get($field);
                        if ($this->isPhone($field))
                        {
                            $fieldValue = $this->normalizePhone($request->get($field));
                        }
                        $query['payment_method_data'][$field] = $fieldValue;
                    }
                }
            }
        }
 
        if ($this->isRecurring($payment) && !self::isOAuth())
        {
            $query['save_payment_method'] = true;
        }
 
        return $query;
    }
 
    private function getReceipt(Payment $payment): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $checkQueryResult = $this->buildCheckQuery($payment);
        if ($checkQueryResult->isSuccess())
        {
            $receiptData = $checkQueryResult->getData();
            if (!empty($receiptData['items']) && !empty($receiptData['customer']))
            {
                $result->setData([
                    'receipt' => $receiptData,
                ]);
            }
            else
            {
                $result->addError(PaySystem\Error::create(Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_EMPTY_RECEIPT')));
            }
        }
        else
        {
            $result->addErrors($checkQueryResult->getErrors());
        }
 
        return $result;
    }

    private function getYandexRepeatedPaymentQueryParams(Payment $payment, Request $request): array
    {
        $query = $this->getYandexBasePaymentQueryParams($payment);
        $query['payment_method_id'] = $payment->getField('PS_RECURRING_TOKEN');
 
        return $query;
    }

    private function getReturnUrl(Payment $payment)
    {
        return $this->getBusinessValue($payment, 'YANDEX_CHECKOUT_RETURN_URL') ?: $this->service->getContext()->getUrl();
    }

    protected function getPaymentDescription(Payment $payment)
    {
        $collection = $payment->getCollection();
        $order = $collection->getOrder();
        $userEmail = $order->getPropertyCollection()->getUserEmail();
 
        $description =  str_replace(
            [
                '#PAYMENT_NUMBER#',
                '#ORDER_NUMBER#',
                '#PAYMENT_ID#',
                '#ORDER_ID#',
                '#USER_EMAIL#'
            ],
            [
                $payment->getField('ACCOUNT_NUMBER'),
                $order->getField('ACCOUNT_NUMBER'),
                $payment->getId(),
                $order->getId(),
                ($userEmail) ? $userEmail->getValue() : ''
            ],
            $this->getBusinessValue($payment, 'YANDEX_CHECKOUT_DESCRIPTION')
        );
 
        return mb_substr($description, 0, 128);
    }

    private function getPhoneNumber(Payment $payment): ?string
    {
        $phoneNumber = null;

        $collection = $payment->getCollection();
        $order = $collection->getOrder();
 
        if ($order instanceof \Bitrix\Crm\Order\Order
            && $clientCollection = $order->getContactCompanyCollection()
        )
        {
            $primaryClient = $clientCollection->getPrimaryContact();
            $entityId = \CCrmOwnerType::ContactName;
 
            if ($primaryClient === null)
            {
                $primaryClient = $clientCollection->getPrimaryCompany();
                $entityId = \CCrmOwnerType::CompanyName;
            }
 
            if ($primaryClient)
            {
                $clientId = $primaryClient->getField('ENTITY_ID');
                $crmFieldMultiResult = \CCrmFieldMulti::GetList(
                    ['ID' => 'desc'],
                    [
                        'ENTITY_ID' => $entityId,
                        'ELEMENT_ID' => $clientId,
                        'TYPE_ID' => 'PHONE',
                    ]
                );
                while ($crmFieldMultiData = $crmFieldMultiResult->Fetch())
                {
                    $phoneNumber = $crmFieldMultiData['VALUE'];
                    if ($phoneNumber)
                    {
                        break;
                    }
                }
            }
        }
 
        if (!$phoneNumber)
        {
            $phoneNumberProp = $order->getPropertyCollection()->getPhone();
            if ($phoneNumberProp)
            {
                $phoneNumber = $phoneNumberProp->getValue();
            }
        }
 
        return $phoneNumber ? $this->normalizePhone($phoneNumber) : null;
    }

    private function getBasicAuthString(Payment $payment): string
    {
        return base64_encode(
            trim((string)$this->getBusinessValue($payment, 'YANDEX_CHECKOUT_SHOP_ID'))
            . ':'
            . trim((string)$this->getBusinessValue($payment, 'YANDEX_CHECKOUT_SECRET_KEY'))
        );
    }

    private static function encode(array $data)
    {
        return Main\Web\Json::encode($data, JSON_UNESCAPED_UNICODE);
    }

    private static function decode($data)
    {
        try
        {
            return Main\Web\Json::decode($data);
        }
        catch (Main\ArgumentException $exception)
        {
            return false;
        }
    }

    public function getCurrencyList()
    {
        return ['RUB'];
    }

    public function processRequest(Payment $payment, Request $request)
    {
        $result = new PaySystem\ServiceResult();
 
        $checkIpResult = $this->checkIpAddress();
        if (!$checkIpResult->isSuccess())
        {
            $result->addErrors($checkIpResult->getErrors());
            return $result;
        }
 
        $inputStream = static::readFromStream();
 
        $data = static::decode($inputStream);
        if ($data !== false)
        {
            $response = $data['object'];
            if ($response['status'] === static::PAYMENT_STATUS_SUCCEEDED)
            {
                $this->processSuccessRequest($payment, $response, $result);
            }
            elseif (
                $response['status'] === static::PAYMENT_STATUS_CANCELED
                && $payment->getField('PS_INVOICE_ID') === $response['id']
            )
            {
                $this->processCancelRequest($response, $result);
            }
        }
        else
        {
            $result->addError(PaySystem\Error::create(Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_QUERY')));
        }
 
        return $result;
    }
 
    private function processSuccessRequest(Payment $payment, array $response, PaySystem\ServiceResult $result): void
    {
        $description = Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_TRANSACTION') . $response['id'];
        $fields = [
            'PS_INVOICE_ID' => $response['id'],
            'PS_STATUS_CODE' => $response['status'],
            'PS_STATUS_DESCRIPTION' => $description,
            'PS_SUM' => $response['amount']['value'],
            'PS_STATUS' => 'N',
            'PS_CURRENCY' => $response['amount']['currency'],
            'PS_RESPONSE_DATE' => new Main\Type\DateTime()
        ];
 
        if ($response['payment_method']['saved'])
        {
            $fields['PS_RECURRING_TOKEN'] = $response['payment_method']['id'];
        }
 
        if ($this->isSumCorrect($payment, $response))
        {
            $fields["PS_STATUS"] = 'Y';
 
            PaySystem\Logger::addDebugInfo(
                __CLASS__ . ': PS_CHANGE_STATUS_PAY=' . $this->getBusinessValue($payment, 'PS_CHANGE_STATUS_PAY')
            );
 
            if ($this->getBusinessValue($payment, 'PS_CHANGE_STATUS_PAY') === 'Y')
            {
                $result->setOperationType(PaySystem\ServiceResult::MONEY_COMING);
            }
        }
        else
        {
            $error = Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_SUM');
            $fields['PS_STATUS_DESCRIPTION'] .= ' ' . $error;
            $result->addError(PaySystem\Error::create($error));
        }
 
        $result->setPsData($fields);
    }
 
    private function processCancelRequest(array $response, PaySystem\ServiceResult $result): void
    {
        $cancellationParty = $response['cancellation_details']['party'];
        $cancellationReason = $response['cancellation_details']['reason'];
 
        $party = Localization\Loc::getMessage(
            'SALE_HPS_YANDEX_CHECKOUT_REQUEST_CANCEL_PARTY_' . mb_strtoupper($cancellationParty)
        );
        if (!$party)
        {
            $party = $cancellationParty;
        }
 
        $reason = Localization\Loc::getMessage(
            'SALE_HPS_YANDEX_CHECKOUT_REQUEST_CANCEL_REASON_' . mb_strtoupper($cancellationReason)
        );
        if (!$reason)
        {
            $reason = $cancellationReason;
        }
 
        $description = implode(
            '. ',
            [
                Localization\Loc::getMessage(
                    'SALE_HPS_YANDEX_CHECKOUT_REQUEST_CANCEL_PARTY',
                    [
                        '#PARTY#' => $party,
                    ]
                ),
                Localization\Loc::getMessage(
                    'SALE_HPS_YANDEX_CHECKOUT_REQUEST_CANCEL_REASON',
                    [
                        '#REASON#' => $reason,
                    ]
                )
            ]
        );
 
        $fields = [
            'PS_STATUS_CODE' => $response['status'],
            'PS_STATUS' => 'N',
            'PS_RESPONSE_DATE' => new Main\Type\DateTime(),
            'PS_STATUS_DESCRIPTION' => $description,
        ];
 
        $result->setPsData($fields);
        $result->addError(
            PaySystem\Error::create(Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_PAYMENT_CANCELED'))
        );
    }

    private function isSumCorrect(Payment $payment, array $paymentData)
    {
        PaySystem\Logger::addDebugInfo(
            __CLASS__.': yandexSum='.PriceMaths::roundPrecision($paymentData['amount']['value'])."; paymentSum=".PriceMaths::roundPrecision($payment->getSum())
        );
 
        return PriceMaths::roundPrecision($paymentData['amount']['value']) === PriceMaths::roundPrecision($payment->getSum());
    }

    private function getYandexPayment(Payment $payment): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $url = $this->getUrl($payment, 'payment');
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_GET, $url, $headers);
        if ($sendResult->isSuccess())
        {
            $result->setData($sendResult->getData());
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    public function refund(Payment $payment, $refundableSum)
    {
        $result = new PaySystem\ServiceResult();
 
        $url = $this->getUrl($payment, 'refund');
        $params = $this->getRefundQueryParams($payment, $refundableSum);
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $headers, $params);
        if (!$sendResult->isSuccess())
        {
            $result->addErrors($sendResult->getErrors());
            return $result;
        }
 
        $response = $sendResult->getData();
 
        if ($response['status'] === static::PAYMENT_STATUS_SUCCEEDED
            && PriceMaths::roundPrecision($response['amount']['value']) === PriceMaths::roundPrecision($refundableSum)
        )
        {
            $result->setOperationType(PaySystem\ServiceResult::MONEY_LEAVING);
        }
 
        return $result;
    }

    public function cancel(Payment $payment)
    {
        $url = $this->getUrl($payment, 'cancel');
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $headers);
        if (!$sendResult->isSuccess())
        {
            $error = __CLASS__.': cancel: '.implode("\n", $sendResult->getErrorMessages());
            PaySystem\Logger::addError($error);
        }
 
        return $sendResult;
    }

    public function confirm(Payment $payment, $sum = 0)
    {
        $result = new PaySystem\ServiceResult();
 
        $url = $this->getUrl($payment, 'confirm');
        $headers = $this->getHeaders($payment);
 
        if ($sum == 0)
        {
            $sum = $payment->getSum();
        }
 
        $params = array(
            'amount' => array(
                'value' => (string)PriceMaths::roundPrecision($sum),
                'currency' => $payment->getField('CURRENCY')
            )
        );
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $headers, $params);
        if ($sendResult->isSuccess())
        {
            $response = $sendResult->getData();
            $description = Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_TRANSACTION').$response['id'];
 
            $fields = array(
                "PS_STATUS_CODE" => mb_substr($response['status'], 0, 5),
                "PS_STATUS_DESCRIPTION" => $description,
                "PS_SUM" => $response['amount']['value'],
                "PS_CURRENCY" => $response['amount']['currency'],
                "PS_RESPONSE_DATE" => new Main\Type\DateTime()
            );
 
            if ($response['status'] === static::PAYMENT_STATUS_SUCCEEDED)
            {
                $fields["PS_STATUS"] = "Y";
                $result->setOperationType(PaySystem\ServiceResult::MONEY_COMING);
            }
            else
            {
                $fields["PS_STATUS"] = "N";
            }
 
            $result->setPsData($fields);
        }
        else
        {
            $error = __CLASS__.': confirm: '.join("\n", $sendResult->getErrorMessages());
            PaySystem\Logger::addError($error);
        }
 
        return $result;
    }

    private function getHeaders(Payment $payment): array
    {
        $headers = [
            'Content-Type' => 'application/json',
            'Idempotence-Key' => $this->getIdempotenceKey(),
        ];
 
        try
        {
            $headers['Authorization'] = $this->getAuthorizationHeader($payment);
        }
        catch (\Exception $ex)
        {
            $headers['Authorization'] = 'Basic '.$this->getBasicAuthString($payment);
        }
 
        return $headers;
    }

    private function getAuthorizationHeader(Payment $payment): string
    {
        if (self::isOAuth())
        {
            $token = $this->getYandexToken();
            return 'Bearer '.$token;
        }
 
        return 'Basic '.$this->getBasicAuthString($payment);
    }

    private function getYandexToken()
    {
        if (!Main\Loader::includeModule('seo'))
        {
            return null;
        }
 
        $authAdapter = Seo\Checkout\Service::getAuthAdapter(Seo\Checkout\Service::TYPE_YOOKASSA);
        $token = $authAdapter->getToken();
        if (!$token)
        {
            $authAdapter = Seo\Checkout\Service::getAuthAdapter(Seo\Checkout\Service::TYPE_YANDEX);
            $token = $authAdapter->getToken();
        }
 
        return $token;
    }

    private function getRefundQueryParams(Payment $payment, $refundableSum)
    {
        return array(
            'payment_id' => $payment->getField('PS_INVOICE_ID'),
            'amount' => array(
                'value' => (string)PriceMaths::roundPrecision($refundableSum),
                'currency' => $payment->getField('CURRENCY'),
            ),
        );
    }

    public function getPaymentIdFromRequest(Request $request)
    {
        $inputStream = static::readFromStream();
 
        if ($inputStream)
        {
            $data = static::decode($inputStream);
            if ($data === false)
            {
                return false;
            }
 
            return $data['object']['metadata']['BX_PAYMENT_NUMBER'];
 
        }
 
        return false;
    }

    public static function getHandlerModeList()
    {
        return PaySystem\Manager::getHandlerDescription('YandexCheckout')['HANDLER_MODE_LIST'];
    }

    protected function getYandexHandlerType($psMode)
    {
        $handlersMap = [
            static::MODE_SMART => static::PAYMENT_METHOD_SMART,
            static::MODE_ALFABANK => static::PAYMENT_METHOD_ALFABANK,
            static::MODE_BANK_CARD => static::PAYMENT_METHOD_BANK_CARD,
            static::MODE_YANDEX_MONEY => static::PAYMENT_METHOD_YANDEX_MONEY,
            static::MODE_SBERBANK => static::PAYMENT_METHOD_SBERBANK,
            static::MODE_SBERBANK_SMS => static::PAYMENT_METHOD_SBERBANK,
            static::MODE_SBERBANK_QR => static::PAYMENT_METHOD_SBERBANK,
            static::MODE_CASH => static::PAYMENT_METHOD_CASH,
            static::MODE_EMBEDDED => static::PAYMENT_METHOD_EMBEDDED,
            static::MODE_TINKOFF_BANK => static::PAYMENT_METHOD_TINKOFF_BANK,
            static::MODE_SBER_LOAN => static::PAYMENT_METHOD_SBER_LOAN,
            static::MODE_SBP => static::PAYMENT_METHOD_SBP,
        ];
 
        if (array_key_exists($psMode, $handlersMap))
        {
            return $handlersMap[$psMode];
        }
 
        return $psMode;
    }

    protected function getUrlList()
    {
        return array(
            'pay' => static::URL.'/payments',
            'refund' => static::URL.'/refunds',
            'confirm' => static::URL.'/payments/#payment_id#/capture',
            'cancel' => static::URL.'/payments/#payment_id#/cancel',
            'payment' => static::URL.'/payments/#payment_id#',
            'settings' => static::URL.'/me',
        );
    }

    public static function isMyResponse(Request $request, $paySystemId)
    {
        $inputStream = static::readFromStream();
 
        if ($inputStream)
        {
            $data = static::decode($inputStream);
            if ($data === false)
            {
                return false;
            }
 
            if (isset($data['object']['metadata']['BX_HANDLER'])
                && $data['object']['metadata']['BX_HANDLER'] === 'YANDEX_CHECKOUT'
                && isset($data['object']['metadata']['BX_PAYSYSTEM_CODE'])
                && (int)$data['object']['metadata']['BX_PAYSYSTEM_CODE'] === (int)$paySystemId
            )
            {
                return true;
            }
        }
 
        return false;
    }

    private static function readFromStream()
    {
        return file_get_contents('php://input');
    }

    protected function getUrl(Payment $payment = null, $action)
    {
        $url = parent::getUrl($payment, $action);
        if ($payment !== null &&
            (
                $action === 'cancel'
                || $action === 'confirm'
                || $action === 'payment'
            )
        )
        {
            $url = str_replace('#payment_id#', $payment->getField('PS_INVOICE_ID'), $url);
        }
 
        return $url;
    }

    private function getPaymentMethodFields(): array
    {
        $paymentMethodFields = array(
            static::MODE_ALFABANK => array('login'),
            static::MODE_MOBILE_BALANCE => array('phone'),
            static::MODE_SBERBANK_SMS => array('phone'),
        );
 
        if (isset($paymentMethodFields[$this->service->getField('PS_MODE')]))
        {
            return $paymentMethodFields[$this->service->getField('PS_MODE')];
        }
 
        return [];
    }

    private function isFillPaymentMethodFields(Request $request): bool
    {
        $fields = $this->getPaymentMethodFields();
        if ($fields)
        {
            foreach ($fields as $field)
            {
                if (!$request->get($field))
                {
                    return false;
                }
            }
        }
 
        return true;
    }

    private function isPhone($field): bool
    {
        $paymentMethodPhoneFields = $this->getPhoneFields();
 
        $phoneFields = [];
        if (isset($paymentMethodPhoneFields[$this->service->getField('PS_MODE')]))
        {
            $phoneFields = $paymentMethodPhoneFields[$this->service->getField('PS_MODE')];
        }
 
        return in_array($field, $phoneFields);
    }

    private function getPhoneFields(): array
    {
        return [
            static::MODE_MOBILE_BALANCE => ['phone'],
            static::MODE_SBERBANK_SMS => ['phone'],
        ];
    }

    private function normalizePhone($number)
    {
        $normalizedNumber = \NormalizePhone($number);
 
        if ($normalizedNumber)
        {
            return $normalizedNumber;
        }
 
        return $number;
    }

    private function hasPaymentMethodFields(): bool
    {
        $fields = $this->getPaymentMethodFields();
        return (bool)$fields;
    }

    public function repeatRecurrent(Payment $payment, Request $request = null): PaySystem\ServiceResult
    {
        if ($request === null)
        {
            $request = Main\Context::getCurrent()->getRequest();
        }
 
        return $this->createYandexPayment($payment, $request, true);
    }

    public function cancelRecurrent(Payment $payment, Request $request = null): PaySystem\ServiceResult
    {
        return (new PaySystem\ServiceResult());
    }

    public function isRecurring(Payment $payment): bool
    {
        $modeList = [
            self::MODE_BANK_CARD,
            self::MODE_YANDEX_MONEY,
            self::MODE_EMBEDDED,
        ];
 
        $isPsModeSupport = in_array($this->service->getField("PS_MODE"), $modeList, true);
 
        return $this->getBusinessValue($payment, 'YANDEX_CHECKOUT_RECURRING') === 'Y'
            && $isPsModeSupport;
    }

    private function checkIpAddress(): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $isFound = false;
        $yandexIp = Main\Context::getCurrent()->getRequest()->getRemoteAddress();
        foreach (self::CALLBACK_IP_LIST as $callbackIp)
        {
            $ipAddress = new Main\Web\IpAddress($yandexIp);
            if ($ipAddress->matchRange($callbackIp))
            {
                $isFound = true;
                break;
            }
        }
 
        if (!$isFound)
        {
            $result->addError(
                PaySystem\Error::create(
                    Localization\Loc::getMessage('SALE_HPS_YANDEX_CHECKOUT_ERROR_CHECK_IP', [
                        '#IP_ADDRESS#' => $yandexIp,
                    ])
                )
            );
            return $result;
        }
 
        return $result;
    }

    private static function isOAuth(): bool
    {
        return Main\Config\Option::get('sale', 'YANDEX_CHECKOUT_OAUTH', false) == true;
    }
 
    public function getRestrictionList(): RestrictionInfoCollection
    {
        $psMode = $this->service->getField('PS_MODE');
 
        $baseRestrictions = parent::getRestrictionList();
        if ($psMode === self::PAYMENT_METHOD_SBER_LOAN)
        {
            $restrictionInfo = new RestrictionInfo('Price', [
                'MIN_VALUE' => 3000,
                'MAX_VALUE' => 600000,
            ]);
 
            $baseRestrictions->add($restrictionInfo);
        }
        elseif (
            $psMode === self::PAYMENT_METHOD_SBP
            || $this->getYandexHandlerType($psMode) === self::PAYMENT_METHOD_SBERBANK
        )
        {
            $restrictionInfo = new RestrictionInfo('Price', [
                'MIN_VALUE' => 1,
                'MAX_VALUE' => 1000000,
            ]);
 
            $baseRestrictions->add($restrictionInfo);
        }
 
        return $baseRestrictions;
    }
 
    private static function generateQrCode(string $data): ?string
    {
        return (new PaySystem\BarcodeGenerator())->generate($data);
    }
 
    public static function getCashboxClass(): string
    {
        return '\\'.Cashbox\CashboxYooKassa::class;
    }
 
    public function isFiscalizationEnabled(Payment $payment): bool
    {
        $url = $this->getUrl($payment, 'settings');
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_GET, $url, $headers);
        if ($sendResult->isSuccess())
        {
            $data = $sendResult->getData();
 
            return $data['fiscalization']['enabled'] ?? false;
        }
 
        return false;
    }
}