handler.php

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

<?php
 
namespace Sale\Handlers\PaySystem;
 
use Bitrix\Main,
    Bitrix\Main\Request,
    Bitrix\Main\Localization\Loc,
    Bitrix\Main\Web\HttpClient,
    Bitrix\Sale\Payment,
    Bitrix\Sale\PaySystem,
    Bitrix\Sale\PriceMaths,
    Bitrix\Sale\PaymentCollection,
    Bitrix\Sale\BusinessValue;
 
Loc::loadMessages(__FILE__);

class SkbHandler
    extends PaySystem\ServiceHandler
    implements PaySystem\IRefund
{
    private const MODE_SKB = 'skb';
    private const MODE_DELOBANK = 'delobank';
    private const MODE_GAZENERGOBANK = 'gazenergobank';
 
    private const TAG_BITRIX_24 = 'Bitrix24';
 
    private const RESPONSE_CODE_SUCCESS = [
        '0',
        'RQ00000'
    ];
 
    private const HTTP_CODE_OK = 200;
    private const HTTP_CODE_LOCKED = 423;
 
    private const PAYMENT_STATUS_NOT_STARTED = 'NTST';
    private const PAYMENT_STATUS_ACCEPTED = 'ACWP';
    private const PAYMENT_STATUS_REJECTED = 'RJCT';

    public function initiatePay(Payment $payment, Request $request = null): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $createPaymentResult = $this->createPayment($payment);
        if (!$createPaymentResult->isSuccess())
        {
            $result->addErrors($createPaymentResult->getErrors());
            return $result;
        }
 
        $result->setPsData($createPaymentResult->getPsData());
        $paymentData = $createPaymentResult->getData();
 
        $params['CURRENCY'] = $payment->getField('CURRENCY');
        $params['SUM'] = PriceMaths::roundPrecision($payment->getSum());
        $params['URL'] = $paymentData['payload'];
        $params['QR_CODE_IMAGE'] = $paymentData['qrImage'];
        $this->setExtraParams($params);
 
        $showTemplateResult = $this->showTemplate($payment, 'template');
        if ($showTemplateResult->isSuccess())
        {
            $result->setTemplate($showTemplateResult->getTemplate());
        }
        else
        {
            $result->addErrors($showTemplateResult->getErrors());
        }
 
        return $result;
    }

    private function changeUserPassword(Payment $payment): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $params = [
            'login' => $this->getBusinessValue($payment, 'SKB_LOGIN'),
            'password' => $this->getBusinessValue($payment, 'SKB_PASSWORD'),
            'newPassword' => Main\Security\Random::getString(10, true),
        ];
 
        $sendResult = $this->send($payment, 'changeUserPassword', $params);
        if ($sendResult->isSuccess())
        {
            $updatePasswordResult = $this->updatePassword($payment, $params['newPassword']);
            if (!$updatePasswordResult->isSuccess())
            {
                $result->addErrors($updatePasswordResult->getErrors());
            }
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    private function updatePassword(Payment $payment, string $password): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $oldMapping = BusinessValue::getMapping('SKB_PASSWORD', $this->service->getConsumerName(), $payment->getPersonTypeId());
        $updateMappingResult = BusinessValue::updateMapping(
            'SKB_PASSWORD',
            $oldMapping,
            [
                'PROVIDER_KEY' => 'VALUE',
                'PROVIDER_VALUE' => $password,
            ]
        );
        if (!$updateMappingResult->isSuccess())
        {
            $result->addErrors($updateMappingResult->getErrors());
        }
 
        return $result;
    }

    private function createPayment(Payment $payment): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $params = [
            'messageId' => self::getMessageId(),
            'agentId' => $this->getAgentId(),
            'merchantId' => $this->getBusinessValue($payment, 'SKB_MERCHANT_ID'),
            'paymentId' => (string)$payment->getId(),
            'amount' => (string)($payment->getSum() * 100),
            'currency' => $payment->getField('CURRENCY'),
            'paymentPurpose' => $this->getAdditionalInfo($payment),
            'templateVersion' => '01',
            'qrcType' => '02',
            'mediaType' => 'image/png',
            'width' => 450,
            'height' => 450,
        ];
 
        $sendResult = $this->send($payment, 'register', $params);
        if (!$sendResult->isSuccess())
        {
            $result->addErrors($sendResult->getErrors());
            return $result;
        }
 
        $sendData = $sendResult->getData();
        $result->setPsData(['PS_INVOICE_ID' => $sendData['qrcId']]);
        $result->setData($sendData);
 
        return $result;
    }

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

    public function processRequest(Payment $payment, Request $request): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $secretKey = $this->getBusinessValue($payment, 'SKB_SECRET_KEY');
        if ($secretKey && !$this->isSignCorrect($request, $secretKey))
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_SIGN')));
            return $result;
        }
 
        $paymentStatusResult = $this->getSkbPaymentStatus($payment);
        if (!$paymentStatusResult->isSuccess())
        {
            $result->addErrors($paymentStatusResult->getErrors());
            return $result;
        }
 
        return $this->processSkbPaymentStatus($payment, $paymentStatusResult);
    }

    private function getSkbPaymentStatus(Payment $payment): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $params = [
            'messageId' => self::getMessageId(),
            'agentId' => $this->getAgentId(),
            'qrcIds' => [
                $payment->getField('PS_INVOICE_ID'),
            ],
        ];
 
        $sendResult = $this->send($payment, 'getPaymentsStatus', $params);
        if (!$sendResult->isSuccess())
        {
            $result->addErrors($sendResult->getErrors());
            return $result;
        }
 
        $sendData = $sendResult->getData();
        if (empty($sendData['payments']))
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_EMPTY_PAYMENTS')));
        }
 
        $result->setData($sendData);
 
        return $result;
    }
 
    private function processSkbPaymentStatus(Payment $payment, PaySystem\ServiceResult $paymentStatusResult): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $paymentStatusData = $paymentStatusResult->getData();
        $skbPayment = current($paymentStatusData['payments']);
 
        if (!empty($skbPayment['status']))
        {
            $status = $skbPayment['status'];
            $fields = [
                'PS_STATUS_CODE' => $status,
                'PS_SUM' => $payment->getSum(),
                'PS_CURRENCY' => $payment->getField('CURRENCY'),
                'PS_RESPONSE_DATE' => new Main\Type\DateTime(),
                'PS_STATUS' => 'N',
            ];
 
            $psStatusDescription = Loc::getMessage('SALE_HPS_SKB_STATUS_DESCRIPTION_' . $status);
            if ($psStatusDescription)
            {
                $fields['PS_STATUS_DESCRIPTION'] = $psStatusDescription;
            }
 
            $additionalPsStatusDescription = '';
            if (!empty($skbPayment['trxId']))
            {
                $additionalPsStatusDescription = Loc::getMessage('SALE_HPS_SKB_OPERATION_ID_DESCRIPTION', [
                    '#TX_ID#' => $skbPayment['trxId'],
                ]);
            }
            elseif (!empty($skbPayment['qrcId']))
            {
                $additionalPsStatusDescription = Loc::getMessage('SALE_HPS_SKB_QR_CODE_ID_DESCRIPTION', [
                    '#QR_CODE_ID#' => $skbPayment['qrcId'],
                ]);
            }
 
            if ($additionalPsStatusDescription)
            {
                $fields['PS_STATUS_DESCRIPTION'] =
                    !empty($fields['PS_STATUS_DESCRIPTION'])
                        ? $fields['PS_STATUS_DESCRIPTION'] . ' ' . $additionalPsStatusDescription
                        : $additionalPsStatusDescription
                ;
            }
 
            if ($status === self::PAYMENT_STATUS_ACCEPTED)
            {
                $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);
                }
            }
            elseif ($status === self::PAYMENT_STATUS_NOT_STARTED)
            {
                $result->addError(
                    new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_STATUS_NOT_STARTED'))
                );
            }
            elseif ($status === self::PAYMENT_STATUS_REJECTED)
            {
                $result->addError(
                    new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_STATUS_REJECTED'))
                );
            }
 
            $result->setPsData($fields);
 
            if (!$result->isSuccess())
            {
                $result->setOperationType(PaySystem\ServiceResult::MONEY_LEAVING);
            }
        }
        else
        {
            $result->addError(
                new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_STATUS_NOT_FOUND'))
            );
        }
 
        return $result;
    }

    public function getPaymentIdFromRequest(Request $request)
    {
        return $request->get('paymentId');
    }

    public static function getIndicativeFields(): array
    {
        return ['qrcId', 'paymentId', 'txStatus', 'txId', 'debitorId', 'amount', 'timestamp', 'sign'];
    }

    protected function isSignCorrect(Request $request, $secretKey): bool
    {
        $hash = md5(
            $request->get('qrcId')
            . $request->get('timestamp')
            . $request->get('txId')
            . $request->get('amount')
            . $secretKey
        );
 
        return $hash === $request->get('sign');
    }

    public function refund(Payment $payment, $refundableSum): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $checkRefundTransferResult = $this->checkRefundTransfer($payment, $refundableSum);
        if (!$checkRefundTransferResult->isSuccess())
        {
            $result->addErrors($checkRefundTransferResult->getErrors());
            return $result;
        }
 
        $checkRefundTransferData = $checkRefundTransferResult->getData();
        if (!$checkRefundTransferData['corelationId'])
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_CORELATION_ID')));
            return $result;
        }
 
        $approveRefundTransferResult = $this->approveRefundTransfer($payment, $checkRefundTransferData['corelationId']);
        if (!$approveRefundTransferResult->isSuccess())
        {
            $result->addErrors($approveRefundTransferResult->getErrors());
            return $result;
        }
 
        $approveRefundTransferData = $approveRefundTransferResult->getData();
        if ($approveRefundTransferData['status'] === static::PAYMENT_STATUS_ACCEPTED)
        {
            $result->setOperationType(PaySystem\ServiceResult::MONEY_LEAVING);
        }
 
        return $result;
    }

    private function checkRefundTransfer(Payment $payment, $refundableSum): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $paymentStatusResult = $this->getSkbPaymentStatus($payment);
        if (!$paymentStatusResult->isSuccess())
        {
            $result->addErrors($paymentStatusResult->getErrors());
            return $result;
        }
 
        $paymentStatusData = $paymentStatusResult->getData();
        $skbPayment = current($paymentStatusData['payments']);
 
        $params = [
            'messageId' => self::getMessageId(),
            'trxId' => $skbPayment['trxId'],
            'amount' => (string)($refundableSum * 100),
        ];
 
        $sendResult = $this->send($payment, 'checkRefundTransfer', $params);
        if ($sendResult->isSuccess())
        {
            $result->setData($sendResult->getData());
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    private function approveRefundTransfer(Payment $payment, string $corelationId): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $params = [
            'messageId' => self::getMessageId(),
            'corelationId' => $corelationId,
        ];
 
        $sendResult = $this->send($payment, 'approveRefundTransfer', $params);
        if ($sendResult->isSuccess())
        {
            $result->setData($sendResult->getData());
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    private function send(Payment $payment, $action, array $params = []): PaySystem\ServiceResult
    {
        $url = $this->getUrl($payment, $action);
 
        $result = $this->makeQuery($url, $params, $this->getHeaders($payment));
        if (!$result->isSuccess() && $result->getErrorCollection()->getErrorByCode(self::HTTP_CODE_LOCKED))
        {
            $changeUserPasswordResult = $this->changeUserPassword($payment);
            if (!$changeUserPasswordResult->isSuccess())
            {
                $result->addErrors($changeUserPasswordResult->getErrors());
                return $result;
            }
 
            $result = $this->makeQuery($url, $params, $this->getHeaders($payment));
        }
 
        if (!$result->isSuccess())
        {
            return $result;
        }
 
        $sendData = $result->getData();
        $verifyResult = $this->verifyResponse($sendData['response']);
        if ($verifyResult->isSuccess())
        {
            $result->setData(static::decode($sendData['response']));
        }
        else
        {
            $result->addErrors($verifyResult->getErrors());
        }
 
        return $result;
    }

    private function makeQuery($url, array $params = [], array $headers = []): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $httpClient = new HttpClient();
        $httpClient->setHeaders($headers);
 
        $postData = static::encode($params);
        PaySystem\Logger::addDebugInfo(__CLASS__ . ': request data: ' . $postData);
 
        $response = $httpClient->post($url, $postData);
        if ($response === false)
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_EMPTY_RESPONSE')));
            foreach ($httpClient->getError() as $code => $message)
            {
                $result->addError(new Main\Error($message, $code));
            }
 
            return $result;
        }
 
        PaySystem\Logger::addDebugInfo(__CLASS__ . ': response data: ' . $response);
 
        $httpStatus = $httpClient->getStatus();
        if ($httpStatus === self::HTTP_CODE_OK)
        {
            $result->setData(['response' => $response]);
        }
        else
        {
            $errorMessage = Loc::getMessage('SALE_HPS_SKB_ERROR_STATUS_'.$httpStatus);
            if (!$errorMessage)
            {
                $errorMessage = Loc::getMessage(
                    'SALE_HPS_SKB_ERROR_STATUS_UNKNOWN',
                    [
                        '#STATUS#' => $httpStatus,
                    ]
                );
            }
 
            $result->addError(new Main\Error($errorMessage, $httpStatus));
        }
 
        return $result;
    }

    private function verifyResponse($response): PaySystem\ServiceResult
    {
        $result = new PaySystem\ServiceResult();
 
        $responseData = static::decode($response);
        if ($response && !$responseData)
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_SKB_ERROR_DECODE_RESPONSE')));
            return $result;
        }
 
        if (isset($responseData['errCode']) && !\in_array($responseData['errCode'], self::RESPONSE_CODE_SUCCESS, true))
        {
            $result->addError(new Main\Error($responseData['errMess'], $responseData['errCode']));
        }
        elseif (isset($responseData['moreInformation'], $responseData['httpCode']))
        {
            $result->addError(new Main\Error($responseData['moreInformation'], $responseData['httpCode']));
        }
 
        return $result;
    }

    protected function isTestMode(Payment $payment = null): bool
    {
        return $this->getBusinessValue($payment, 'SKB_TEST_MODE') === 'Y';
    }

    protected function getUrlList(): array
    {
        $testUrl = 'https://test.api.sinara.ru:443/';
        $activeUrl = 'https://public.api.sinara.ru:443/';
 
        return [
            'register' => [
                self::TEST_URL => $testUrl . 'qr/register',
                self::ACTIVE_URL => $activeUrl . 'qr/register',
            ],
            'getPaymentsStatus' => [
                self::TEST_URL => $testUrl . 'qr/getpaymentsstatus',
                self::ACTIVE_URL => $activeUrl . 'qr/getpaymentsstatus',
            ],
            'checkRefundTransfer' => [
                self::TEST_URL => $testUrl . 'refund/CheckRefundTransfer',
                self::ACTIVE_URL => $activeUrl . 'refund/CheckRefundTransfer',
            ],
            'approveRefundTransfer' => [
                self::TEST_URL => $testUrl . 'refund/ApproveRefundTransfer',
                self::ACTIVE_URL => $activeUrl . 'refund/ApproveRefundTransfer',
            ],
            'changeUserPassword' => [
                self::TEST_URL => $testUrl . 'user/changeUserPassword',
                self::ACTIVE_URL => $activeUrl . 'user/changeUserPassword',
            ],
        ];
    }

    protected function getAdditionalInfo(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, 'SKB_ADDITIONAL_INFO')
        );
 
        return mb_substr($description, 0, 140);
    }

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

    private function getHeaders(Payment $payment): array
    {
        return [
            'Authorization' => 'Basic ' . $this->getBasicAuthString($payment),
            'Content-Type' => 'application/json',
            'User-Agent' => self::TAG_BITRIX_24,
        ];
    }

    private static function getMessageId(): 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 getAgentId(): string
    {
        $agentList = [
            self::MODE_SKB => 'A00000000001',
            self::MODE_DELOBANK => 'A00000000001',
            self::MODE_GAZENERGOBANK => 'A00000000023',
        ];
 
        return $agentList[$this->service->getField('PS_MODE')];
    }

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

    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;
        }
    }
}