handler.php

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

<?php
 
namespace Sale\Handlers\PaySystem;
 
use Bitrix\Main;
use Bitrix\Main\Entity\Result;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Request;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
use Bitrix\Sale\Payment;
use Bitrix\Sale\PaymentCollection;
use Bitrix\Sale\PaySystem;
use Bitrix\Sale\PaySystem\Logger;
use Bitrix\Sale\PaySystem\ServiceResult;
use Bitrix\Sale\PriceMaths;
 
class PlatonHandler extends PaySystem\ServiceHandler implements PaySystem\IRefund
{
    private const PAYMENT_METHOD_CODE = 'CC';
    private const REFUND_ACTION = 'CREDITVOID';
 
    private const ANALYTICS_TAG = 'api_bitrix24ua';
 
    /*
     * order: payment id
     * ext1: the name of the handler
     * ext2: pay system service ID
     * ext3: analytics tag
     */
    private const CALLBACK_ORDER_PARAM = 'order';
    private const CALLBACK_EXT1_PARAM = 'ext1';
    private const CALLBACK_EXT2_PARAM = 'ext2';
 
    private const TRANSACTION_STATUS_SALE = 'SALE';
    private const TRANSACTION_STATUS_REFUND = 'REFUND';
 
    private const REFUND_STATUS_ACCEPTED = 'ACCEPTED';
    private const REFUND_STATUS_ERROR = 'ERROR';
 
    private const PS_MODE_BANK_CARD = 'bank_card';
    private const PS_MODE_GOOGLE_PAY = 'google_pay';
    private const PS_MODE_APPLE_PAY = 'apple_pay';
    private const PS_MODE_PRIVAT24 = 'privat24';

    public function initiatePay(Payment $payment, Request $request = null)
    {
        $result = new PaySystem\ServiceResult();
 
        $params = [
            'CURRENCY' => $payment->getField('CURRENCY'),
            'SUM' => PriceMaths::roundPrecision($payment->getSum()),
            'FORM_ACTION_URL' => $this->getUrl($payment, "formActionUrl"),
            'FORM_DATA' => $this->getFormData($payment),
        ];
        $this->setExtraParams($params);
 
        $showTemplateResult = $this->showTemplate($payment, 'template');
        if ($showTemplateResult->isSuccess())
        {
            $result->setTemplate($showTemplateResult->getTemplate());
        }
        else
        {
            $result->addErrors($showTemplateResult->getErrors());
        }
 
        return $result;
    }

    private function getFormData(Payment $payment): array
    {
        $apiKey = $this->getBusinessValue($payment, 'PLATON_API_KEY');
        $paymentMethodCode = self::PAYMENT_METHOD_CODE;
        $paymentData = $this->getPaymentData($payment);
        $encodedPaymentData = $this->encodePaymentData($paymentData);
        $successUrl = $this->getSuccessUrl($payment);
        $password = $this->getBusinessValue($payment, 'PLATON_PASSWORD');
 
        $sign = $this->getPaymentFormSignature(
            $apiKey,
            $paymentMethodCode,
            $encodedPaymentData,
            $successUrl,
            $password
        );
 
        $paymentNumber = $payment->getField('ACCOUNT_NUMBER');
        $paySystemId = $this->service->getField('ID');
 
        $formData = [
            'KEY' => $apiKey,
            'PAYMENT' => $paymentMethodCode,
            'DATA' => $encodedPaymentData,
            'URL' => $successUrl,
            'REQ_TOKEN' => 'N',
            'SIGN' => $sign,
            'ORDER' => $paymentNumber,
            'EXT_1' => 'PLATON',
            'EXT_2' => $paySystemId,
            'EXT_3' => self::ANALYTICS_TAG,
        ];
 
        $email = $this->getUserEmailValue($payment);
        if ($email)
        {
            $formData['EMAIL'] = $email;
        }
 
        return $formData;
    }

    private function encodePaymentData(array $paymentData): string
    {
        return base64_encode(Json::encode($paymentData, JSON_UNESCAPED_UNICODE));
    }

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

    private function getPaymentData(Payment $payment)
    {
        $formattedPaymentSum = $this->getFormattedPaymentSum($payment);
        $paymentDescription = $this->getPaymentDescription($payment);
 
        return [
            'amount' => $formattedPaymentSum,
            'currency' => $payment->getField("CURRENCY"),
            'description' => $paymentDescription,
            'recurring' => 'N',
        ];
    }

    private function getFormattedPaymentSum(Payment $payment)
    {
        $paymentSum = PriceMaths::roundPrecision($payment->getSum());
        return $this->formatPaymentSum($paymentSum);
    }

    private function formatPaymentSum($paymentSum): string
    {
        return number_format($paymentSum, 2, '.', '');
    }

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

    private function getPaymentDescription(Payment $payment)
    {
        $collection = $payment->getCollection();
        $order = $collection->getOrder();
        $userEmail = $order->getPropertyCollection()->getUserEmail();
 
        $descriptionTemplate = $this->getBusinessValue($payment, 'PLATON_PAYMENT_DESCRIPTION');
        $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() : '',
            ],
            $descriptionTemplate
        );
 
        return $description;
    }

    private function getPaymentFormSignature(
        string $apiKey,
        string $paymentMethodCode,
        string $encodedPaymentData,
        string $successUrl,
        string $password
    ): string
    {
        return md5(
            mb_strtoupper(
                strrev($apiKey)
                . strrev($paymentMethodCode)
                . strrev($encodedPaymentData)
                . strrev($successUrl)
                . strrev($password)
            )
        );
    }

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

    public function processRequest(Payment $payment, Request $request)
    {
        $result = new PaySystem\ServiceResult();
        Logger::addDebugInfo(__CLASS__ . ': request payload: ' . Json::encode($request->getValues(), JSON_UNESCAPED_UNICODE));
 
        $signatureCheckResult = $this->checkCallbackSignature($payment, $request);
        if ($signatureCheckResult->isSuccess())
        {
            $transactionId = $request->get('id');
            $transactionStatus = $request->get('status');
 
            if ($transactionId && $transactionStatus === self::TRANSACTION_STATUS_SALE)
            {
                $description = Loc::getMessage('SALE_HPS_PLATON_TRANSACTION_DESCRIPTION', [
                    '#ID#' => $request->get('id'),
                    '#PAYMENT_NUMBER#' => $request->get('order'),
                ]);
                $requestSum = $request->get('amount');
                $paymentFields = [
                    'PS_INVOICE_ID' => $transactionId,
                    'PS_STATUS_CODE' => $transactionStatus,
                    'PS_STATUS_DESCRIPTION' => $description,
                    'PS_SUM' => $requestSum,
                    'PS_CURRENCY' => $request->get('currency'),
                    'PS_RESPONSE_DATE' => new Main\Type\DateTime(),
                    'PS_STATUS' => 'N',
                    'PS_CARD_NUMBER' => $request->get('card'),
                ];
 
                if ($this->checkPaymentSum($payment, $requestSum))
                {
                    $paymentFields['PS_STATUS'] = 'Y';
 
                    $result->setOperationType(PaySystem\ServiceResult::MONEY_COMING);
                    $result->setPsData($paymentFields);
                }
                else
                {
                    $errorMessage = Loc::getMessage('SALE_HPS_PLATON_SUM_MISMATCH');
                    $paymentFields['PS_STATUS_DESCRIPTION'] .= $description . ' ' . $errorMessage;
                    $result->addError(new Main\Error($errorMessage));
                }
            }
            elseif ($transactionStatus === self::TRANSACTION_STATUS_REFUND)
            {
                $oldDescription = $payment->getField('PS_STATUS_DESCRIPTION');
                $newDescription = str_replace(
                    ' ' . Loc::getMessage('SALE_HPS_PLATON_REFUND_IN_PROCESS'),
                    '',
                    $oldDescription
                );
                $payment->setField('PS_STATUS_DESCRIPTION', $newDescription);
                $result->setOperationType(PaySystem\ServiceResult::MONEY_LEAVING);
            }
            else
            {
                $errorMessage = $request->get('error_message');
                if (!isset($errorMessage))
                {
                    $errorMessage = Loc::getMessage('SALE_HPS_PLATON_REQUEST_ERROR');
                }
                $result->addError(new Main\Error($errorMessage));
            }
        }
        else
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_PLATON_SIGNATURE_MISMATCH')));
        }
 
        return $result;
    }

    private function checkCallbackSignature(Payment $payment, Request $request): PaySystem\ServiceResult
    {
        $result = new ServiceResult();
 
        $callbackSignature = $request->get('sign');
 
        $email = $this->getUserEmailValue($payment);
 
        $password = $this->getBusinessValue($payment, 'PLATON_PASSWORD');
        $order = $payment->getField('ACCOUNT_NUMBER');
        $card = $request->get('card');
        $localSignature = $this->getCallbackSignature($email, $password, $order, $card);
 
        Logger::addDebugInfo(__CLASS__ . ": local signature: $localSignature, callback signature: $callbackSignature");
        if ($callbackSignature !== $localSignature)
        {
            $result->addError(new Main\Error('signature mismatch'));
        }
 
        return $result;
    }

    private function checkPaymentSum(Payment $payment, $requestSum): bool
    {
        $roundedRequestSum = PriceMaths::roundPrecision($requestSum);
        $roundedPaymentSum = PriceMaths::roundPrecision($payment->getSum());
        Logger::addDebugInfo(__CLASS__ . ": request sum: $roundedRequestSum, payment sum: $roundedPaymentSum");
 
        return $roundedRequestSum === $roundedPaymentSum;
    }

    public static function getIndicativeFields()
    {
        return [
            self::CALLBACK_ORDER_PARAM,
            self::CALLBACK_EXT1_PARAM,
            self::CALLBACK_EXT2_PARAM,
        ];
    }

    protected static function isMyResponseExtended(Request $request, $paySystemId)
    {
        return (int)$request->get(self::CALLBACK_EXT2_PARAM) === (int)$paySystemId;
    }

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

    public function refund(Payment $payment, $refundableSum)
    {
        $result = new PaySystem\ServiceResult();
 
        $transactionId = $payment->getField('PS_INVOICE_ID');
        $cardNumber = $payment->getField('PS_CARD_NUMBER');
 
        if ($cardNumber)
        {
            $formattedPaymentSum = $this->getFormattedPaymentSum($payment);
            $apiKey = $this->getBusinessValue($payment, 'PLATON_API_KEY');
            $email = $this->getUserEmailValue($payment);
 
            $password = $this->getBusinessValue($payment, 'PLATON_PASSWORD');
 
            $signature = $this->getCallbackSignature($email, $password, $transactionId, $cardNumber);
 
            $fields = [
                'action' => self::REFUND_ACTION,
                'client_key' => $apiKey,
                'trans_id' => $transactionId,
                'amount' => $formattedPaymentSum,
                'hash' => $signature,
            ];
 
            $responseResult = $this->send($this->getUrl($payment, "requestUrl"), $fields);
            if (!$responseResult->isSuccess())
            {
                $result->addErrors($responseResult->getErrors());
                return $result;
            }
 
            $responseData = $responseResult->getData();
 
            Logger::addDebugInfo(__CLASS__ . ': refund payload: ' . Json::encode($responseData, JSON_UNESCAPED_UNICODE));
            switch ($responseData['result'])
            {
                case self::REFUND_STATUS_ACCEPTED:
                    $newDescription = $payment->getField('PS_STATUS_DESCRIPTION') . ' ' . Loc::getMessage('SALE_HPS_PLATON_REFUND_IN_PROCESS');
                    $payment->setField('PS_STATUS_DESCRIPTION', $newDescription);
                    $result->setData($responseData);
                    break;
                case self::REFUND_STATUS_ERROR:
                    $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_PLATON_RESPONSE_ERROR', [
                        '#PS_RESPONSE#' => $responseData['error_message'],
                    ])));
                    break;
                default:
                    $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_PLATON_REFUND_ERROR')));
            }
        }
        else
        {
            $result->addError(new Main\Error(Loc::getMessage('SALE_HPS_PLATON_ERROR_CARD_NOT_FOUND')));
        }
 
        return $result;
    }

    private function send(string $url, array $params): Result
    {
        $result = new Result();
 
        $httpClient = new HttpClient();
        $response = $httpClient->post($url, $params);
        if ($response === false)
        {
            $errors = $httpClient->getError();
            foreach ($errors as $code =>$message)
            {
                $result->addError(new Main\Error($message, $code));
            }
        }
        else
        {
            $responseData = $this->decode($response);
            $result->setData($responseData);
        }
 
        return $result;
    }

    private function getCallbackSignature(string $email, string $password, string $transactionId, string $cardNumber): string
    {
        return md5(
            mb_strtoupper(
                strrev($email)
                . $password
                . $transactionId
                . strrev(
                    mb_substr($cardNumber, 0, 6)
                    . mb_substr($cardNumber, -4)
                )
            )
        );
    }

    private function getUserEmailValue(Payment $payment): string
    {
        $email = '';
        $emailProperty = $payment->getOrder()->getPropertyCollection()->getUserEmail();
        if ($emailProperty)
        {
            $email = $emailProperty->getValue();
        }
 
        return $email ?? '';
    }
 
    protected function getUrlList()
    {
        return [
            'formActionUrl' => 'https://secure.platononline.com/payment/auth',
            'requestUrl' => 'https://secure.platononline.com/post-unq/',
        ];
    }

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