rexdigitalshop.tar

Application.php000066600000000622137160236230007527 0ustar00<?php
/**
 * @brief		Rex Digital Shop Application Class
 * @author		<a href='https://shop.rexdigital.group'>Rex Digital Shop</a>
 * @copyright	(c) 2020 Rex Digital Shop
 * @package		Invision Community
 * @subpackage	Rex Digital Shop
 * @since		18 Jul 2020
 * @version		
 */
 
namespace IPS\rexdigitalshop;

/**
 * Rex Digital Shop Application Class
 */
class _Application extends \IPS\Application
{
	
}data/acpmenu.json000066600000000022137160236230010001 0ustar00{
    "gift": []
}data/acprestrictions.json000066600000000022137160236230011565 0ustar00{
    "gift": []
}data/acpsearch.json000066600000000002137160236230010300 0ustar00{}data/application.json000066600000000435137160236230010664 0ustar00{
    "application_title": "Rex Digital Shop",
    "app_author": "Rex Digital Shop",
    "app_directory": "rexdigitalshop",
    "app_protected": 0,
    "app_website": "https:\/\/shop.rexdigital.group",
    "app_update_check": "https:\/\/shop.rexdigital.group\/integrations\/ip-board"
}data/emails.xml000066600000000061137160236230007455 0ustar00<?xml version="1.0" encoding="UTF-8"?>
<emails/>
data/hooks.json000066600000000144137160236230007501 0ustar00{
    "RegisterGatewayHook": {
        "type": "C",
        "class": "\\IPS\\nexus\\Gateway"
    }
}data/index.html000066600000000000137160236230007447 0ustar00data/javascript.xml000066600000000112137160236230010346 0ustar00<?xml version="1.0" encoding="UTF-8"?>
<javascript app="rexdigitalshop"/>
data/lang.xml000066600000000702137160236230007126 0ustar00<?xml version="1.0" encoding="UTF-8"?>
<language>
 <app key="rexdigitalshop" version="10000">
  <word key="__app_rexdigitalshop" js="0">Rex Digital Shop</word>
  <word key="rexdigitalshop_api_key" js="0">Api Key</word>
  <word key="rexdigitalshop_secret_key" js="0">Secret</word>
  <word key="rexdigitalshop_payment_methods" js="0">Payment Methods</word>
  <word key="rexshop_payment_method" js="0">Select A Payment Method</word>
 </app>
</language>
data/modules.json000066600000000002137160236230010017 0ustar00[]data/schema.json000066600000000002137160236230007607 0ustar00[]data/settings.json000066600000000002137160236230010207 0ustar00[]data/tasks.json000066600000000002137160236230007474 0ustar00[]data/theme.xml000066600000000231137160236230007304 0ustar00<?xml version="1.0" encoding="UTF-8"?>
<theme name="Default" author_name="Invision Power Services, Inc" author_url="https://www.invisioncommunity.com"/>
data/themesettings.json000066600000000002137160236230011232 0ustar00[]data/versions.json000066600000000030137160236230010220 0ustar00{
    "10000": "0.0.1"
}data/widgets.json000066600000000002137160236230010015 0ustar00[]extensions/core/index.html000066600000000000137160236230011665 0ustar00extensions/index.html000066600000000000137160236230010735 0ustar00hooks/index.html000066600000000000137160236230007661 0ustar00hooks/RegisterGatewayHook.php000066600000001364137160236230012342 0ustar00//<?php

    /* To prevent PHP errors (extending class does not exist) revealing path */
    if (!\defined('\IPS\SUITE_UNIQUE_KEY')) {
        exit;
    }

    class rexdigitalshop_hook_RegisterGatewayHook extends _HOOK_CLASS_
    {
        /**
         * @return  array
         */
        public static function gateways()
        {
	try
	{
	            $gateways = parent::gateways();
	
	            $gateways['RexDigitalShop'] = 'IPS\rexdigitalshop\RexDigitalShop';
	
	            return $gateways;
	}
	catch ( \RuntimeException $e )
	{
		if ( method_exists( get_parent_class(), __FUNCTION__ ) )
		{
			return \call_user_func_array( 'parent::' . __FUNCTION__, \func_get_args() );
		}
		else
		{
			throw $e;
		}
	}
        }
    }
interface/gateway.php000066600000005724137160236230010675 0ustar00<?php

if (!file_exists('../../../init.php')) {
    header('HTTP/1.1 404 Not Found');
    die;
}

header('HTTP/1.1 200 OK');

require_once '../../../init.php';

$request = json_decode(file_get_contents('php://input'), true);

/* Load Transaction */
try {
    $transaction = \IPS\nexus\Transaction::load($request['order']['transaction_id']);

    if ($transaction->status !== \IPS\nexus\Transaction::STATUS_PENDING && $transaction->status !== \IPS\nexus\Transaction::STATUS_WAITING) {
        throw new \OutofRangeException;
    }
} catch (\OutOfRangeException $e) {
    \IPS\Output::i()->redirect(\IPS\Http\Url::internal("app=nexus&module=payments&controller=checkout&do=transaction&id=&t=" . $request['order']['transaction_id'], 'front', 'nexus_checkout', \IPS\Settings::i()->nexus_https));
}

try {
    $g_settings = json_decode($transaction->method->settings, true);
    $apiKey = $g_settings['api_key'];
    $secretKey = $g_settings['secret_key'];
    $paymentMethods = $g_settings['payment_methods'];

    $amount = $request['order']['amount'];
    $currency = $request['order']['currency']['symbol'] ?? $request['order']['currency']['symbol'] ?? '$';
    $status = $request['status'];
    $paymentMethod = $request['payment_method'];
    $transactionId = $request['order']['transaction_id'];

    $sigArray['secret_key'] = $g_settings['secret_key'];
    $sigArray['api_key'] = $g_settings['api_key'];
    $sigArray['payment_method'] = $paymentMethod;
    $sigArray['amount'] = $amount;
    $sigArray['currency'] = $currency;
    $sigArray['transaction_id'] = $transactionId;
    $sigArray['status'] = $status;

    $hash = $request['RDG_WH_SIGNATURE'];

    if (\IPS\rexdigitalshop\RexDigitalShop::verifySig($sigArray, $hash)) {
        switch (mb_strtolower($status)) {
            case 'completed':
                $transaction->auth = NULL;
                $transaction->approve(NULL);
                $transaction->save();
                $transaction->sendNotification();
                break;
            case 'pending':
                $transaction->status = \IPS\nexus\Transaction::STATUS_WAITING;
                $transaction->save();
                $transaction->sendNotification();
                break;
            case 'failed':
            case 'timed out':
                $transaction->status = \IPS\nexus\Transaction::STATUS_REFUSED;
                $transaction->void();
                $transaction->save();
                $transaction->sendNotification();
                break;
            default:
                break;
        }
    } else {
        $transaction->status = \IPS\nexus\Transaction::STATUS_REFUSED;
        $transaction->void();
        $transaction->save();
        $transaction->sendNotification();
    }
} catch (\Exception $e) {
    \IPS\Output::i()->redirect($transaction->invoice->checkoutUrl()->setQueryString([
        '_step' => 'checkout_pay',
        'err' => $e->getMessage()
    ]));
}
interface/index.html000066600000000000137160236230010476 0ustar00modules/admin/gift/ShopController.php000066600000001426137160236230013735 0ustar00<?php


namespace IPS\rexdigitalshop\modules\admin\gift;

/* To prevent PHP errors (extending class does not exist) revealing path */
if ( !\defined( '\IPS\SUITE_UNIQUE_KEY' ) )
{
	header( ( isset( $_SERVER['SERVER_PROTOCOL'] ) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0' ) . ' 403 Forbidden' );
	exit;
}

/**
 * ShopController
 */
class _ShopController extends \IPS\Dispatcher\Controller
{
	/**
	 * Execute
	 *
	 * @return	void
	 */
	public function execute()
	{
		\IPS\Dispatcher::i()->checkAcpPermission( 'ShopController_manage' );
		parent::execute();
	}

	/**
	 * ...
	 *
	 * @return	void
	 */
	protected function manage()
	{
		// This is the default method if no 'do' parameter is specified
	}
	
	// Create new methods with the same name as the 'do' parameter which should execute it
}modules/admin/index.html000066600000000000137160236230011276 0ustar00modules/front/index.html000066600000000000137160236230011336 0ustar00modules/index.html000066600000000000137160236230010206 0ustar00setup/index.html000066600000000000137160236230007676 0ustar00setup/upg_10000/index.html000066600000000000137160236230011211 0ustar00sources/index.html000066600000000000137160236230010221 0ustar00sources/rexdigitalshop/index.html000066600000000000137160236230013247 0ustar00sources/rexdigitalshop/RexDigitalShopAdapter.php000066600000016401137160236230016166 0ustar00<?php

/**
 * Client library for RexDigitalShop API.
 */
class RexDigitalShopAdapter
{
    /**
     * @const string
     */
    const VERSION = '1.0.0.0';

    /**
     * @var string
     */
    protected $api_url;
    protected $api_key = '';
    protected $secret_key = '';
    protected static $sig_keys = [
        'create' => [
            'api_key', 'payment_method', 'amount', 'currency', 'transaction_id',
        ],
    ];

    /**
     * @var array
     */
    protected $http_errors = [
        400 => '400 Bad Request',
        401 => '401 Unauthorized',
        500 => '500 Internal Server Error',
        501 => '501 Not Implemented',
        502 => '502 Bad Gateway',
        503 => '503 Service Unavailable',
        504 => '504 Gateway Timeout',
    ];

    /**
     * @var bool
     */
    protected $is_success = false;

    /**
     * @var array
     */
    protected $allowed_request_methods = [
        'get',
        'put',
        'post',
        'delete',
    ];

    /**
     * @var boolean
     */
    protected $ssl_verify = true;

    /**
     * Constructor
     * 
     * @param string $api_key RexDigitalShop App api_key
     * @param string $secret_key RexDigitalShop App secret_key
     * @param bool $is_sandbox false if you use sandbox api_key and true for live mode
     */
    public function __construct($api_key, $secret_key, $is_sandbox = true)
    {
        $this->api_key = $api_key;
        $this->secret_key = $secret_key;

        $validate_params = [
            false === extension_loaded('curl') => 'The curl extension must be loaded for using this class!',
            false === extension_loaded('json') => 'The json extension must be loaded for using this class!',
            empty($this->api_key) => 'api_key is not set!',
            empty($this->secret_key) => 'secret_key is not set!',
        ];
        $this->checkForErrors($validate_params);

        $this->setSandboxMode($is_sandbox);
    }

    /**
     * Set LiveMode
     *
     * @param bool $is_sandbox
     */
    public function setSandboxMode($is_sandbox)
    {
        if ($is_sandbox) {
            $this->api_url = 'https://shop.rexdigital.group/api/v1/payment-request';
        } else {
            $this->api_url = 'https://shop.rexdigital.group/api/v1/payment-request';
        }

        return $this;
    }

    /**
     * Set Api URL
     * 
     * @param string $url Api URL
     */
    public function setUrl($url)
    {
        $this->api_url = $url;

        return $this;
    }

    /**
     * Sets SSL verify
     * 
     * @param bool $ssl_verify SSL verify
     */
    public function setSSLverify($ssl_verify)
    {
        $this->ssl_verify = $ssl_verify;

        return $this;
    }

    /**
     * Request state getter
     *
     * @return bool
     */
    public function isSuccess()
    {
        return $this->is_success;
    }

    /**
     * create payment order
     *
     * @param $params create Params
     * @return array
     */
    public function create(array $params)
    {
        return $this->call(
            'create',
            'post',
            $params
        );
    }

    /**
     * Method responsible for preparing, setting state and returning answer from rest server
     *
     * @param string $method
     * @param string $request
     * @param array $params
     * @return array
     */
    protected function call($method, $request, $params)
    {
        $this->is_success = false;

        $validate_params = [
            false === is_string($method) => 'Method name must be string',
            false === $this->checkRequestMethod($request) => 'Not allowed request method type',
            true === empty($params) => 'params is null',
        ];

        $this->checkForErrors($validate_params);

        $params['api_key'] = $this->api_key;
        $params['api_signature'] = $this->getSig($params, self::$sig_keys[$method]);

        $response = $this->pushData($method, $request, $params);

        $response = json_decode($response, true);

        if (isset($response['result_code']) && 200 == $response['result_code']) {
            $this->is_success = true;
        }

        return $response;
    }

    /**
     * Checking error mechanism
     *
     * @param array $validateArray
     * @throws Exception
     */
    protected function getSig(array &$params, array $sig_keys)
    {
        $msg_array = [];
        foreach ($sig_keys as $key) {
            $msg_array[$key] = isset($params[$key]) ? $params[$key] : '';
        }

        return hash_hmac('sha256', implode('', $msg_array), $this->secret_key);
    }

    /**
     * Checking error mechanism
     *
     * @param array $validateArray
     * @throws Exception
     */
    protected function checkForErrors(&$validate_params)
    {
        foreach ($validate_params as $key => $error) {
            if ($key) {
                throw new Exception($error, -1);
            }
        }
    }

    /**
     * Check if method is allowed
     *
     * @param string $method_type
     * @return bool
     */
    protected function checkRequestMethod($method_type)
    {
        $request_method = strtolower($method_type);

        if (in_array($request_method, $this->allowed_request_methods)) {
            return true;
        }

        return false;
    }

    /**
     * Method responsible for pushing data to server
     *
     * @param string $method
     * @param string $method_type
     * @param array|string $vars
     * @return array
     * @throws Exception
     */
    protected function pushData($method, $method_type, $vars)
    {
        $ch = curl_init();

        curl_setopt($ch, CURLOPT_URL, $x = $this->api_url);
        curl_setopt($ch, CURLOPT_POST, true);

        if (is_array($vars)) $vars = http_build_query($vars, '', '&');
        curl_setopt($ch, CURLOPT_POSTFIELDS, $vars);

        curl_setopt($ch, CURLOPT_HEADER, false);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $this->getHeaders());
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

        $response = curl_exec($ch);

        $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (isset($this->http_errors[$code])) {
            throw new Exception('Response Http Error - ' . $this->http_errors[$code], $code);
        }

        $code = curl_errno($ch);
        if (0 < $code) {
            throw new Exception('Unable to connect to ' . $this->api_url . ' Error: ' . "$code :" . curl_error($ch), $code);
        }

        curl_close($ch);

        return $response;
    }

    protected function &getHeaders()
    {
        $langVersion = phpversion();
        $uname = php_uname();
        $ua = array(
            'version' => self::VERSION,
            'lang' => 'php',
            'lang_version' => $langVersion,
            'publisher' => 'rexdigitalshop',
            'uname' => $uname,
        );
        $headers = array(
            'X-RexDigitalShop-Client-User-Agent: ' . json_encode($ua),
            "User-Agent: RexDigitalShop/php/$langVersion/" . self::VERSION,
            'Content-Type: application/x-www-form-urlencoded',
        );

        return $headers;
    }
}
sources/RexDigitalShop.php000066600000027231137160236230011642 0ustar00<?php

namespace IPS\rexdigitalshop;

/* To prevent PHP errors (extending class does not exist) revealing path */

if (!defined('\IPS\SUITE_UNIQUE_KEY')) {
    header((isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0') . ' 403 Forbidden');
    exit;
}

require_once 'rexdigitalshop/RexDigitalShopAdapter.php';

/**
 * RexDigitalShop Gateway
 */
class _RexDigitalShop extends \IPS\nexus\Gateway
{
    const SUPPORTS_REFUNDS = FALSE;
    const SUPPORTS_PARTIAL_REFUNDS = FALSE;

    protected static $paymentMethods = [
        'alipay' => 'Alipay',
        'wechat' => 'WeChat Pay',

        'ideal' => 'iDeal',
        'sofort'   => 'SOFORT',

        'multibanco' => 'Multibanco',

        'credit_card' => 'Credit Card',

        'apple_pay' => 'Apple Pay',
        'google_pay' => 'Google Pay',
        'microsoft_pay' => 'Microsoft Pay',

        'skins' => 'Virtual Skins',

        'bitcoin'  => 'Bitcoin',
        'ethereum'  => 'Ethereum',
        'litecoin'  => 'Litecoin',
        'monero'  => 'Monero',
    ];

    /**
     * Initialize PaymentGateway
     *
     * @param $api_key
     * @param $secret_key
     * @param bool $sandbox
     * @return \RexDigitalShopAdapter
     */
    public function initGateway($api_key, $secret_key, $sandbox = false)
    {
        return new \RexDigitalShopAdapter($api_key, $secret_key, $sandbox);
    }

    /**
     * Payment Screen Fields
     *
     * @param   \IPS\nexus\Invoice      $invoice    Invoice
     * @param   \IPS\nexus\Money        $amount     The amount to pay now
     * @param   \IPS\nexus\Customer     $member     The member the payment screen is for (if in the ACP charging to a member's card) or NULL for currently logged in member
     * @param   array                   $recurrings Details about recurring costs
     * @param   string                  $type       'checkout' means the cusotmer is doing this on the normal checkout screen, 'admin' means the admin is doing this in the ACP, 'card' means the user is just adding a card
     *
     * @return    array
     */
    public function paymentScreen(\IPS\nexus\Invoice $invoice, \IPS\nexus\Money $amount, \IPS\nexus\Customer $member = NULL, $recurrings = [], $type = 'checkout')
    {
        /* Get gateway settings */
        $settings = json_decode($this->settings, true);

        /* Check if 'all' has been selected */
        if ($settings['payment_methods'] == -1) {
            $settings['payment_methods'] = static::$paymentMethods;
        } else {
            /* Settings do only contain the array keys, not the names so we need to recover them here */
            $flipped = array_flip($settings['payment_methods']);
            $settings['payment_methods'] = array_merge($flipped, array_intersect_key(static::$paymentMethods, $flipped));
        }

        return [
            'rexshop_payment_method' => new \IPS\Helpers\Form\Select(
                'rexshop_payment_method',
                'credit_card',
                true,
                [
                    'options' => $settings['payment_methods']
                ]
            )
        ];
    }

    /**
     * Authorize
     *
     * @param   \IPS\nexus\Transaction                  $transaction    Transaction
     * @param   array|\IPS\nexus\Customer\CreditCard    $values         Values from form OR a stored card object if this gateway supports them
     * @param   \IPS\nexus\Fraud\MaxMind\Request|NULL   $maxMind        *If* MaxMind is enabled, the request object will be passed here so gateway can additional data before request is made
     * @param   array                                   $recurrings     Details about recurring costs
     * @param   string|NULL                             $source         'checkout' if the customer is doing this at a normal checkout, 'renewal' is an automatically generated renewal invoice, 'manual' is admin manually charging. NULL is unknown
     *
     * @return  \IPS\DateTime|NULL                      Auth is valid until or NULL to indicate auth is good forever
     *
     * @throws  \LogicException                         Message will be displayed to user
     */
    public function auth(\IPS\nexus\Transaction $transaction, $values, \IPS\nexus\Fraud\MaxMind\Request $maxMind = NULL, $recurrings = [], $source = NULL)
    {
        /* Get gateway settings */
        $settings = json_decode($this->settings, TRUE);

        /* We need a transaction ID */
        $transaction->save();

        /* User selected payment method */
        $payment_id = $values['rexshop_payment_method'];

        /* Set payment parameters for POST request */
        $params['currency'] = (string) $transaction->amount->currency;
        $params['payment_method'] = (string) $payment_id;
        $params['transaction_id'] = $transaction->id;
        $params['amount'] = (string) $transaction->amount->amount;

        $params['lines'] = [];
        $summary = $transaction->invoice->summary();
        foreach ($summary['items'] as $item) {
            $params['lines'][] = [
                'title' => $item->name,
                'unit_price' => (float) \strval((float) $item->linePrice()->amountAsString() / (int) $item->quantity),
                'units' => $item->quantity,
            ];
        }

        $params['sales_tax'] = (string) $summary['taxTotal'];

        $payer_name = $this->getFullName($transaction);
        $billing = $transaction->invoice->get_billaddress();
        $params['customer'] = [
            'email' => \IPS\Member::loggedIn()->email,
            'name' => !empty($payer_name) ? $payer_name : null,
            'country' => isset($billing->country) ? $billing->country : null,
            'address' => isset($billing->addressLines) ? implode(' ', $billing->addressLines) : null,
            'city' => isset($billing->city) ? ($billing->city . !empty($billing->region) ? ' ' . $billing->region : '') : null,
            'zip_code' => isset($billing->postalCode) ? $billing->postalCode : null,
        ];

        if ($transaction->invoice->hasPhysicalItems()) {
            $shipping = $transaction->invoice->get_shipaddress();

            $params['shipping'] = [
                'country' => isset($shipping->country) ? $shipping->country : null,
                'address' => isset($shipping->addressLines) ? implode(' ', $shipping->addressLines) : null,
                'city' => isset($shipping->city) ? ($shipping->city . !empty($shipping->region) ? ' ' . $shipping->region : '') : null,
                'zip_code' => isset($shipping->postalCode) ? $shipping->postalCode : null,
                'fee' => $summary['shippingTotal'],
            ];
        }

        $params['webhook_url'] = \IPS\Settings::i()->base_url . 'applications/rexdigitalshop/interface/gateway.php';
        $params['return_url'] = (string) $transaction->invoice->checkoutUrl();

        $sigParams['api_key'] = $settings['api_key'];
        $sigParams['secret_key'] = $settings['secret_key'];
        $sigParams['payment_method'] = $params['payment_method'];
        $sigParams['amount'] = $params['amount'];
        $sigParams['currency'] = $params['currency'];
        $sigParams['transaction_id'] = $params['transaction_id'];

        $params['api_signature'] = $this->sign($sigParams);

        /* Get rex digital shop adapter object */
        $rexDigitalShop = $this->initGateway($settings['api_key'], $settings['secret_key'], (bool) \IPS\NEXUS_TEST_GATEWAYS);

        try {
            $response = $rexDigitalShop->create($params);
        } catch (\Exception $e) {
            echo "An error has occurred: " . $e->getMessage();
            die;
        }

        if ($response['result_code'] == 200) {
            /* Let's redirect the user */
            \IPS\Output::i()->redirect(\IPS\Http\Url::external($response["redirect_url"]));
        } else {
            /* Error, let the user know what went wrong */
            \IPS\Log::log(print_r($response, true), 'rexdigitalshop_payment');
            echo "An error has occurred, please contact an admin with the following message: " . print_r($response, true);
            die;
        }
    }

    /**
     * Void
     *
     * @param   \IPS\nexus\Transaction  $transaction    Transaction
     * @return  void
     * @throws  \Exception
     */
    public function void(\IPS\nexus\Transaction $transaction)
    {
        /* Nothing to do as gateway doesn't support refunds atm. */
    }

    /* !ACP Configuration */

    /**
     * Settings
     *
     * @param   \IPS\Helpers\Form   $form   The form
     *
     * @return  void
     */
    public function settings(&$form)
    {
        $settings = json_decode($this->settings, TRUE);

        $form->add(new \IPS\Helpers\Form\Text('rexdigitalshop_api_key', isset($settings['api_key'])
            ? $settings['api_key']
            : '', true));

        $form->add(new \IPS\Helpers\Form\Text('rexdigitalshop_secret_key', isset($settings['secret_key'])
            ? $settings['secret_key']
            : '', true));

        $form->add(new \IPS\Helpers\Form\Select('rexdigitalshop_payment_methods', isset($settings['payment_methods'])
            ? $settings['payment_methods']
            : '-1', true, [
            'options' => static::$paymentMethods,
            'multiple' => true,
            'unlimited' => '-1',
            'unlimitedLang' => 'all'
        ]));
    }

    /**
     * Test Settings
     *
     * @param   array   $settings   Settings
     *
     * @return  array
     */
    public function testSettings($settings)
    {
        return $settings;
    }

    /**
     * Get first name for Rex Digital Shop
     *
     * @param   \IPS\nexus\Transaction  $transaction    Transaction
     *
     * @return  string
     */
    protected function getFirstName(\IPS\nexus\Transaction $transaction)
    {
        return $transaction->invoice->member->member_id
            ? $transaction->invoice->member->cm_first_name
            : $transaction->invoice->guest_data['member']['cm_first_name'];
    }

    /**
     * Get last name for Rex Digital Shop
     *
     * @param   \IPS\nexus\Transaction  $transaction    Transaction
     *
     * @return  string
     */
    protected function getLastName(\IPS\nexus\Transaction $transaction)
    {
        return $transaction->invoice->member->member_id
            ? $transaction->invoice->member->cm_last_name
            : $transaction->invoice->guest_data['member']['cm_last_name'];
    }

    /**
     * Get full name for Rex Digital Shop
     *
     * @param   \IPS\nexus\Transaction  $transaction    Transaction
     *
     * @return  string
     */
    protected function getFullName(\IPS\nexus\Transaction $transaction)
    {
        return $this->getFirstName($transaction) . ' ' . $this->getLastName($transaction);
    }

    /**
     * @param array $data
     * @param bool $webhook
     *
     * @return array|string
     */
    public static function sign(array $data, $webhook = false)
    {
        $sig = [
            $data['api_key'],
            $data['payment_method'],
            $data['amount'],
            $data['currency'],
            $data['transaction_id'],
        ];

        if ($webhook) {
            $sig = [
                $data['transaction_id'],
                $data['status']
            ];
        }

        return hash_hmac('sha256',  implode('', $sig), $data['secret_key']);
    }

    /**
     * @param array $data
     * @param $hash
     * @return bool
     */
    public static function verifySig(array $data, $hash)
    {
        return $hash == static::sign($data, true);
    }
}
tasks/index.html000066600000000000137160236230007663 0ustar00