yf_payment user module

Fileplugins/payment/modules/yf_payment.class.php
Usemodule('payment'), URL ?object=payment

Public properties

A site sets them in its config with $PROJECT_CONF['payment']['NAME'] = ...;

PropertyDefaultDescription
$URL_REDIRECT '/payment'
$transition ['default' => ['title' => true], 'status' => ['status_message' => true], 'currency' => ['name' => true, 'short' => true, 'sign' => true]]

Public methods 14

cancel

public function cancel()
    public function cancel()
    {
        $result = $this->_operation_form();
        // import options
        is_array($_GET) && extract($_GET, EXTR_PREFIX_ALL | EXTR_REFS, '');
        // var
        $payment_api = _class('payment_api');
        $result += $payment_api->cancel_user([
            'operation_id' => ($_operation_id ?? null),
        ]);
        // result
        return  $this->_operation_tpl($result);
    }

confirmation

public function confirmation()
    public function confirmation()
    {
        $result = $this->_operation_form();
        // form handler
        if (($_POST ?? null)) {
            switch (($_POST['confirmation_action'] ?? null)) {
                case 'ok':
                    $result += $this->_confirmation_action_ok();
                    break;
                case 'cancel':
                    $result += $this->_confirmation_action_cancel();
                    break;
            }
        }
        // result
        return  $this->_operation_tpl($result);
    }

show

public function show()
    public function show()
    {
        // import options
        is_array($_GET) && extract($_GET, EXTR_PREFIX_ALL | EXTR_REFS, '');
        // route
        switch (true) {
            case $_is_confirmation ?? null:
                $result = $this->confirmation();
                break;
            case $_is_cancel ?? null:
                $result = $this->cancel();
                break;
            default:
                $result = js_redirect('/login_form', false, 'Payment action not exists');
                break;
        }
        return  $result;
    }

t

public function t(&$strs, $set = null, $level = 0)
    public function t(&$strs, $set = null, $level = 0)
    {
        if ($level > 1 || ! is_array($strs)) {
            return;
        }
        ! isset($set) && $set = 'default';
        if (empty($this->transition[$set])) {
            return;
        }
        $transition = $this->transition[$set];
        foreach ($strs as $key => &$str) {
            if (is_array($str)) {
                $this->t($str, $set, $level + 1);
            }
            if (empty($transition[$key])) {
                continue;
            }
            $str = t($str);
        }
    }

user_balance

public function user_balance($options = null)
    public function user_balance($options = null)
    {
        $result = $this->_class('user', 'balance', $options);
        return  $result;
    }

Methods starting with _ hooks and helpers; not routable as page actions

_api_balance

public function _api_balance($request, $options)
    public function _api_balance($request, $options)
    {
        // security
        $_request = [];
        foreach (['operation_id', 'amount', 'currency_id', 'provider_id', 'page', 'method_id', 'account', 'name'] as $key) {
            isset($request['options'][$key]) && $_request[$key] = &$request['options'][$key];
        }
        // route
        $api = _class('api');
        switch (($_GET['operation'] ?? null)) {
            case 'refresh':
                $response = $this->_balance_refresh($_request, $options);
                break;
            case 'recharge':
                $response = $this->_balance_recharge($_request, $options);
                break;
            case 'payin':
                $response = $this->_payin($_request, $options);
                break;
            case 'payout':
                $_request = [];
                $response = $this->_payout($request, $options);
                break;
            case 'operation':
                $response = $this->_operation($_request, $options);
                break;
            case 'cancel':
                $response = $this->_cancel($_request, $options);
                break;
            default:
                $api->_reject();
                break;
        }
        return  $response;
    }

_api_provider

public function _api_provider($request, $options)
    public function _api_provider($request, $options)
    {
        $api = _class('api');
        $payment_api = _class('payment_api');
        $provider_name = ($_GET['name'] ?? null);
        if (empty($provider_name)) {
            return  $api->_reject();
        }
        // check provider
        $object = $payment_api->provider([
            'is_service' => true,
            'name' => $provider_name,
        ]);
        if (empty($object)) {
            return  $api->_reject();
        }
        $is_server = ! empty($_GET['server']);
        // provider handler
        $provider_class = 'provider_' . $provider_name;
        switch (($_GET['operation'] ?? null)) {
            case 'authorize':
            case 'response':
            case 'server':
            case 'check':
                $method = ($_GET['operation'] ?? null);
                break;
            default:
                $api->_reject();
                break;
        }
        $result = $payment_api->_class($provider_class, '_api_' . $method, $request);
        if (($result['is_raw'] ?? null)) {
            return  $result;
        }
        @list($status, $status_message) = array_values($result);
        if ($is_server) {
            if (($status ?? null)) {
                return  ['status' => 'ok'];
            }
            $api->_error();
        }
        if (defined('DEBUG') && DEBUG) {
            var_dump($result);
            js_redirect(url($this->URL_REDIRECT), false, 'payment provider error');
        } else {
            $api->_redirect(url($this->URL_REDIRECT), $status_message);
        }
    }
public function _balance_recharge($request, $options)
    public function _balance_recharge($request, $options)
    {
        $api = _class('api');
        $payment_api = _class('payment_api');
        $balance = $payment_api->deposition_user($request);
        // need user authentication
        if ($balance['status'] === -1) {
            $api->_forbidden();
        }
        // update account, operation
        list($account_id, $account) = $payment_api->get_account();
        list($operation, $count) = $payment_api->operation($account);
        $page_per = $payment_api->OPERATION_LIMIT;
        $pages = ceil($count / $page_per);
        $response = [
            'response' => [
                'balance' => $balance,
                'payment' => [
                    'account' => $account,
                    'operation' => $operation,
                    'operation_pagination' => [
                        'count' => $count,
                        'page_per' => $page_per,
                        'pages' => $pages,
                        'page' => 1,
                    ],
                ],
            ],
        ];
        return  $response;
    }
public function _balance_refresh($request, $options)
    public function _balance_refresh($request, $options)
    {
        $api = _class('api');
        $payment_api = _class('payment_api');
        // update account, operation
        list($account_id, $account) = $payment_api->get_account();
        if (empty($account_id)) {
            $api->_reject();
        }
        list($currency_id, $currency) = $payment_api->get_currency__by_id($account);
        $this->t($currency, 'currency');
        $response = [
            'response' => [
                'balance' => [
                    'account' => $account,
                    'currency' => $currency,
                ],
            ],
        ];
        return  $response;
    }

_cancel

public function _cancel($request, $options)
    public function _cancel($request, $options)
    {
        $balance = null;
        $api = _class('api');
        $payment_api = _class('payment_api');
        $object = $payment_api->cancel_user($request);
        // need user authentication
        if ($balance['status'] === -1) {
            $api->_forbidden();
        }
        // update account, operation
        list($account_id, $account) = $payment_api->get_account();
        list($operation, $count) = $payment_api->operation($account);
        $page_per = $payment_api->OPERATION_LIMIT;
        $pages = ceil($count / $page_per);
        $response = [
            'response' => [
                'cancel' => $object,
                'payment' => [
                    'account' => $account,
                    'operation' => $operation,
                    'operation_pagination' => [
                        'count' => $count,
                        'page_per' => $page_per,
                        'pages' => $pages,
                        'page' => 1,
                    ],
                ],
            ],
        ];
        return  $response;
    }

_init

public function _init()
    public function _init()
    {
        // class
        $this->_class_path = 'modules/' . __CLASS__ . '/';
    }

_operation

public function _operation($request, $options)
    public function _operation($request, $options)
    {
        $count = null;
        $api = _class('api');
        $payment_api = _class('payment_api');
        // update account, operation
        list($account_id, $account) = $payment_api->get_account();
        // need user authentication
        if (empty($account_id)) {
            $api->_forbidden();
        }
        $page = $request['page'];
        $operation_options = [
            'account_id' => $account_id,
            'page' => $page,
            'count' => $count,
        ];
        list($operation, $count) = $payment_api->operation($operation_options);
        $this->t($operation);
        $page_per = $payment_api->OPERATION_LIMIT;
        $pages = ceil($count / $page_per);
        $response = [
            'response' => [
                'payment' => [
                    'account' => $account,
                    'operation' => $operation,
                    'operation_pagination' => [
                        'count' => $count,
                        'page_per' => $page_per,
                        'pages' => $pages,
                        'page' => $page,
                    ],
                ],
            ],
        ];
        return  $response;
    }

_payin

public function _payin($request, $options)
    public function _payin($request, $options)
    {
        $result = $this->_balance_recharge($request, $options);
        return  $result;
    }

_payout

public function _payout($request, $options)
    public function _payout($request, $options)
    {
        $api = _class('api');
        $payment_api = _class('payment_api');
        // todo
        $request = $request['options'];
        $request += [
            'operation_title' => 'Payout from account',
        ];
        $payout = $payment_api->payment_user($request);
        // need user authentication
        if ($payout['status'] === -1) {
            $api->_forbidden();
        }
        // update account, operation
        list($account_id, $account) = $payment_api->get_account();
        list($operation, $count) = $payment_api->operation($account);
        $page_per = $payment_api->OPERATION_LIMIT;
        $pages = ceil($count / $page_per);
        $response = [
            'response' => [
                'payout' => $payout,
                'payment' => [
                    'account' => $account,
                    'operation' => $operation,
                    'operation_pagination' => [
                        'count' => $count,
                        'page_per' => $page_per,
                        'pages' => $pages,
                        'page' => 1,
                    ],
                ],
            ],
        ];
        return  $response;
    }