handler.php

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

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

class BePaidHandler extends PaySystem\ServiceHandler implements
    PaySystem\IRefund,
    PaySystem\Domain\Verification\IVerificationable
{
    private const MODE_CHECKOUT = 'checkout';
    private const MODE_WIDGET = 'widget';
 
    private const CHECKOUT_API_URL = 'https://checkout.bepaid.by';
    private const GATEWAY_API_URL = 'https://gateway.bepaid.by';
    private const API_VERSION = '2.1';
 
    private const TRACKING_ID_DELIMITER = '#';
 
    private const STATUS_SUCCESSFUL_CODE = 'successful';
    private const STATUS_ERROR_CODE = 'error';
 
    private const SEND_METHOD_HTTP_POST = "POST";
    private const SEND_METHOD_HTTP_GET = "GET";

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

    public function initiatePay(Payment $payment, Request $request = null): ServiceResult
    {
        $result = new ServiceResult();
 
        $createPaymentTokenResult = $this->createPaymentToken($payment);
        if (!$createPaymentTokenResult->isSuccess())
        {
            $result->addErrors($createPaymentTokenResult->getErrors());
            return $result;
        }
 
        $createPaymentTokenData = $createPaymentTokenResult->getData();
        if (!empty($createPaymentTokenData['checkout']['token']))
        {
            $result->setPsData(['PS_INVOICE_ID' => $createPaymentTokenData['checkout']['token']]);
        }
 
        if ($this->isCheckoutMode())
        {
            $result->setPaymentUrl($createPaymentTokenData['checkout']['redirect_url']);
        }
 
        $this->setExtraParams($this->getTemplateParams($payment, $createPaymentTokenData));
 
        $showTemplateResult = $this->showTemplate($payment, $this->getTemplateName());
        if ($showTemplateResult->isSuccess())
        {
            $result->setTemplate($showTemplateResult->getTemplate());
        }
        else
        {
            $result->addErrors($showTemplateResult->getErrors());
        }
 
        return $result;
    }

    private function getTemplateName(): string
    {
        return (string)$this->service->getField('PS_MODE');
    }

    private function getTemplateParams(Payment $payment, array $paymentTokenData): array
    {
        $params = [
            'sum' => (string)(PriceMaths::roundPrecision($payment->getSum())),
            'currency' => $payment->getField('CURRENCY'),
        ];
 
        if ($this->isWidgetMode())
        {
            $params['checkout_url'] = self::CHECKOUT_API_URL;
            $params['token'] = $paymentTokenData['checkout']['token'];
            $params['checkout'] = [
                'iframe' => true,
                'test' => $this->isTestMode($payment),
                'transaction_type' => 'payment',
                'order' => [
                    'amount' => (string)(PriceMaths::roundPrecision($payment->getSum()) * 100),
                    'currency' => $payment->getField('CURRENCY'),
                    'description' => $this->getPaymentDescription($payment),
                    'tracking_id' => $payment->getId().self::TRACKING_ID_DELIMITER.$this->service->getField('ID'),
                    'additional_data' => self::getAdditionalData(),
                ],
                'settings' => [
                    'success_url' => $this->getSuccessUrl($payment),
                    'decline_url' => $this->getDeclineUrl($payment),
                    'notification_url' => $this->getBusinessValue($payment, 'BEPAID_NOTIFICATION_URL'),
                    'language' => LANGUAGE_ID,
                ],
            ];
        }
        else
        {
            $params['url'] = $paymentTokenData['checkout']['redirect_url'];
        }
 
        return $params;
    }

    private function createPaymentToken(Payment $payment): ServiceResult
    {
        $result = new ServiceResult();
 
        $url = $this->getUrl($payment, 'getPaymentToken');
        $params = [
            'checkout' => [
                'version' => self::API_VERSION,
                'test' => $this->isTestMode($payment),
                'transaction_type' => 'payment',
                'order' => [
                    'amount' => (string)(PriceMaths::roundPrecision($payment->getSum()) * 100),
                    'currency' => $payment->getField('CURRENCY'),
                    'description' => $this->getPaymentDescription($payment),
                    'tracking_id' => $payment->getId().self::TRACKING_ID_DELIMITER.$this->service->getField('ID'),
                    'additional_data' => self::getAdditionalData(),
                ],
                'settings' => [
                    'success_url' => $this->getSuccessUrl($payment),
                    'decline_url' => $this->getDeclineUrl($payment),
                    'fail_url' => $this->getFailUrl($payment),
                    'cancel_url' => $this->getCancelUrl($payment),
                    'notification_url' => $this->getBusinessValue($payment, 'BEPAID_NOTIFICATION_URL'),
                    'language' => LANGUAGE_ID,
                ],
            ],
        ];
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $params, $headers);
        if ($sendResult->isSuccess())
        {
            $paymentTokenData = $sendResult->getData();
            $verifyResponseResult = $this->verifyResponse($paymentTokenData);
            if ($verifyResponseResult->isSuccess())
            {
                $result->setData($paymentTokenData);
            }
            else
            {
                $result->addErrors($verifyResponseResult->getErrors());
            }
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    private function getBePaidPayment(Payment $payment): ServiceResult
    {
        $result = new ServiceResult();
 
        $url = $this->getUrl($payment, 'getPaymentStatus');
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_GET, $url, [], $headers);
        if ($sendResult->isSuccess())
        {
            $paymentData = $sendResult->getData();
            $verifyResponseResult = $this->verifyResponse($paymentData);
            if ($verifyResponseResult->isSuccess())
            {
                $result->setData($paymentData);
            }
            else
            {
                $result->addErrors($verifyResponseResult->getErrors());
            }
        }
        else
        {
            $result->addErrors($sendResult->getErrors());
        }
 
        return $result;
    }

    public function refund(Payment $payment, $refundableSum): ServiceResult
    {
        $result = new ServiceResult();
 
        $bePaidPaymentResult = $this->getBePaidPayment($payment);
        if (!$bePaidPaymentResult->isSuccess())
        {
            $result->addErrors($bePaidPaymentResult->getErrors());
            return $result;
        }
 
        $bePaidPaymentData = $bePaidPaymentResult->getData();
 
        $url = $this->getUrl($payment, 'refund');
        $params = [
            'request' => [
                'parent_uid' => $bePaidPaymentData['checkout']['gateway_response']['payment']['uid'],
                'amount' => (string)(PriceMaths::roundPrecision($refundableSum) * 100),
                'reason' => $payment->getField('PAY_RETURN_COMMENT') ?: Loc::getMessage('SALE_HPS_BEPAID_REFUND_REASON'),
            ],
        ];
        $headers = $this->getHeaders($payment);
 
        $sendResult = $this->send(self::SEND_METHOD_HTTP_POST, $url, $params, $headers);
        if (!$sendResult->isSuccess())
        {
            $result->addErrors($sendResult->getErrors());
            return $result;
        }
 
        $refundData = $sendResult->getData();
        $verifyResponseResult = $this->verifyResponse($refundData);
        if ($verifyResponseResult->isSuccess())
        {
            if ($refundData['transaction']['status'] === static::STATUS_SUCCESSFUL_CODE
                && PriceMaths::roundPrecision($refundData['transaction']['amount'] / 100) === PriceMaths::roundPrecision($refundableSum)
            )
            {
                $result->setOperationType(PaySystem\ServiceResult::MONEY_LEAVING);
            }
        }
        else
        {
            $result->addErrors($verifyResponseResult->getErrors());
        }
 
        return $result;
    }

    private function send(string $method, string $url, array $params = [], array $headers = []): ServiceResult
    {
        $result = new 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();
            foreach ($errors as $code => $message)
            {
                $result->addError(PaySystem\Error::create($message, $code));
            }
 
            return $result;
        }
 
        PaySystem\Logger::addDebugInfo(__CLASS__.': response data: '.$response);
 
        $response = static::decode($response);
        if ($response)
        {
            $result->setData($response);
        }
        else
        {
            $result->addError(PaySystem\Error::create(Loc::getMessage('SALE_HPS_BEPAID_RESPONSE_DECODE_ERROR')));
        }
 
        return $result;
    }

    private function verifyResponse(array $response): ServiceResult
    {
        $result = new ServiceResult();
 
        if (!empty($response['errors']))
        {
            $result->addError(PaySystem\Error::create($response['message']));
        }
        elseif (!empty($response['response']['errors']))
        {
            $result->addError(PaySystem\Error::create($response['response']['message']));
        }
        elseif (!empty($response['response']['status']) && $response['response']['status'] === self::STATUS_ERROR_CODE)
        {
            $result->addError(PaySystem\Error::create($response['response']['message']));
        }
        elseif (!empty($response['checkout']['status']) && $response['checkout']['status'] === self::STATUS_ERROR_CODE)
        {
            $result->addError(PaySystem\Error::create($response['checkout']['message']));
        }
 
        return $result;
    }

    public function getCurrencyList(): array
    {
        return ['BYN', 'USD', 'EUR', 'RUB'];
    }

    public function processRequest(Payment $payment, Request $request): ServiceResult
    {
        $result = new ServiceResult();
 
        $inputStream = static::readFromStream();
        $data = static::decode($inputStream);
        $transaction = $data['transaction'];
 
        $bePaidPaymentResult = $this->getBePaidPayment($payment);
        if ($bePaidPaymentResult->isSuccess())
        {
            $bePaidPaymentData = $bePaidPaymentResult->getData();
            if ($bePaidPaymentData['checkout']['status'] === self::STATUS_SUCCESSFUL_CODE)
            {
                $description = Loc::getMessage('SALE_HPS_BEPAID_TRANSACTION', [
                    '#ID#' => $transaction['uid'],
                ]);
                $fields = [
                    'PS_STATUS_CODE' => $transaction['status'],
                    'PS_STATUS_DESCRIPTION' => $description,
                    'PS_SUM' => $transaction['amount'] / 100,
                    'PS_STATUS' => 'N',
                    'PS_CURRENCY' => $transaction['currency'],
                    'PS_RESPONSE_DATE' => new Main\Type\DateTime()
                ];
 
                if ($this->isSumCorrect($payment, $transaction['amount'] / 100))
                {
                    $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 = Loc::getMessage('SALE_HPS_BEPAID_ERROR_SUM');
                    $fields['PS_STATUS_DESCRIPTION'] .= '. '.$error;
                    $result->addError(PaySystem\Error::create($error));
                }
 
                $result->setPsData($fields);
            }
        }
        else
        {
            $result->addErrors($bePaidPaymentResult->getErrors());
        }
 
        return $result;
    }

    private function isSumCorrect(Payment $payment, $sum): bool
    {
        PaySystem\Logger::addDebugInfo(
            __CLASS__.': bePaidSum='.PriceMaths::roundPrecision($sum)."; paymentSum=".PriceMaths::roundPrecision($payment->getSum())
        );
 
        return PriceMaths::roundPrecision($sum) === PriceMaths::roundPrecision($payment->getSum());
    }

    public static function isMyResponse(Request $request, $paySystemId): bool
    {
        $inputStream = static::readFromStream();
        if ($inputStream)
        {
            $data = static::decode($inputStream);
            if ($data === false)
            {
                return false;
            }
 
            if (isset($data['transaction']['tracking_id']))
            {
                [, $trackingPaySystemId] = explode(self::TRACKING_ID_DELIMITER, $data['transaction']['tracking_id']);
                return (int)$trackingPaySystemId === (int)$paySystemId;
            }
        }
 
        return false;
    }

    public function getPaymentIdFromRequest(Request $request)
    {
        $inputStream = static::readFromStream();
        if ($inputStream)
        {
            $data = static::decode($inputStream);
            if (isset($data['transaction']['tracking_id']))
            {
                [$trackingPaymentId] = explode(self::TRACKING_ID_DELIMITER, $data['transaction']['tracking_id']);
                return (int)$trackingPaymentId;
            }
        }
 
        return false;
    }

    private 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, 'BEPAID_PAYMENT_DESCRIPTION')
        );
 
        return $description;
    }

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

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

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

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

    private function getHeaders(Payment $payment): array
    {
        $headers = [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Basic '.$this->getBasicAuthString($payment),
            'RequestID' => $this->getIdempotenceKey(),
        ];
 
        if ($this->isWidgetMode())
        {
            $headers['X-API-Version'] = 2;
        }
 
        return $headers;
    }

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

    private function isWidgetMode(): bool
    {
        return $this->service->getField('PS_MODE') === self::MODE_WIDGET;
    }

    private function isCheckoutMode(): bool
    {
        return $this->service->getField('PS_MODE') === self::MODE_CHECKOUT;
    }

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

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

    protected function getUrlList(): array
    {
        return [
            'getPaymentToken' => self::CHECKOUT_API_URL.'/ctp/api/checkouts',
            'getPaymentStatus' => self::CHECKOUT_API_URL.'/ctp/api/checkouts/#payment_token#',
            'refund' => self::GATEWAY_API_URL.'/transactions/refunds',
        ];
    }

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

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

    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;
        }
    }
 
    private static function getAdditionalData(): array
    {
        $additionalData = [
            'platform_data' => self::getPlatformData(),
        ];
 
        $integrationData = self::getIntegrationData();
        if ($integrationData)
        {
            $additionalData['integration_data'] = $integrationData;
        }
 
        return $additionalData;
    }
 
    private static function getPlatformData(): string
    {
        if (Main\ModuleManager::isModuleInstalled('bitrix24'))
        {
            $platformType = 'Bitrix24';
        }
        elseif (Main\ModuleManager::isModuleInstalled('intranet'))
        {
            $platformType = 'Self-hosted';
        }
        else
        {
            $platformType = 'Bitrix Site Manager';
        }
 
        return $platformType;
    }
 
    private static function getIntegrationData(): ?string
    {
        $version = self::getSaleModuleVersion();
        if (!$version)
        {
            return null;
        }
 
        return 'bePaid system module v' . $version;
    }
 
    private static function getSaleModuleVersion(): ?string
    {
        $modulePath = getLocalPath('modules/sale/install/version.php');
        if ($modulePath === false)
        {
            return null;
        }
 
        $arModuleVersion = array();
        include $_SERVER['DOCUMENT_ROOT'].$modulePath;
        return (isset($arModuleVersion['VERSION']) ? (string)$arModuleVersion['VERSION'] : null);
    }
 
    public static function getModeList(): array
    {
        return array_keys(self::getHandlerModeList());
    }
}