Gregoriohc\Moneta\Common\AbstractGateway

Complexity

Total Complexity

18

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	defaultParameters()	0	6	1
A	parametersValidationRules()	0	6	1
A	shortName()	0	4	1
A	isInTestMode()	0	4	1
A	client()	0	4	1
A	createRequest()	0	16	3
A	requestClass()	0	4	1
A	supports()	0	10	4
A	__call()	0	14	4

<?php

namespace Gregoriohc\Moneta\Common;

use ArrayAccess;
use Gregoriohc\Moneta\Common\Concerns\Parametrizable;
use IteratorAggregate;
use JsonSerializable;

/**
 * @method bool supportsAuthorize()
 * @method bool supportsCapture()
 * @method bool supportsPurchase()
 * @method bool supportsRefund()
 * @method bool supportsVoid()
 * @method bool supportsCreatePaymentMethod()
 * @method bool supportsDeletePaymentMethod()
 * @method bool supportsUpdatePaymentMethod()
 * @method bool supportsAcceptNotification()
 * @property bool test_mode
 */
abstract class AbstractGateway implements GatewayInterface, ArrayAccess, IteratorAggregate, JsonSerializable
{
    use Parametrizable;

    private $requestMethods = [
        'authorize',
        'capture',
        'purchase',
        'refund',
        'void',
        'createPaymentMethod',
        'deletePaymentMethod',
        'updatePaymentMethod',
    ];

    private $webhookMethods = [
        'acceptNotification',
    ];

    /**
     * @var mixed
     */
    protected $client;

    /**
     * Create a new gateway instance
     *
     * @param array $parameters
     */
    public function __construct($parameters = [])
    {
        $this->bootParameters($parameters);
        $this->bootClient();
    }

    /**
     * @return array
     */
    public function defaultParameters()
    {
        return [
            'test_mode' => false,
        ];
    }

    /**
     * @return array
     */
    public function parametersValidationRules()
    {
        return [
            'test_mode' => 'required',
        ];
    }

    /**
     * Get the short name of the Gateway
     *
     * @return string
     */
    public function shortName()
    {
        return class_basename($this);
    }

    /**
     * @return boolean
     */
    public function isInTestMode()
    {
        return $this->test_mode;
    }

    /**
     * @return mixed
     */
    public function client()
    {
        return $this->client;
    }

    /**
     * Create and initialize a request object
     *
     * @param string $name The request name or class
     * @param array $parameters
     * @return \Gregoriohc\Moneta\Common\Messages\AbstractRequest
     */
    protected function createRequest($name, $parameters = [])
    {
        $requestClass = $name;
        if (!str_contains($requestClass, '\\')) {
            $requestClass = $this->requestClass($requestClass);
        }

        if (!class_exists($requestClass)) {
            $gatewayClass = class_basename($this);
            throw new \BadMethodCallException("Gateway '$gatewayClass' does not support '$name' method");
        }

        $this->validateParameters();

        return new $requestClass($this, $parameters);
    }

    /**
     * @param string $name
     * @return string
     */
    private function requestClass($name)
    {
        return substr(get_class($this), 0, -strlen(class_basename($this))) . 'Messages\\' . ucfirst($name) . 'Request';
    }

    public function supports($name)
    {
        if (in_array($name, $this->requestMethods)) {
            return method_exists($this, $name) || class_exists($this->requestClass($name));
        } elseif (in_array($name, $this->webhookMethods)) {
            return method_exists($this, $name);
        }

        return false;
    }

    /**
     * @param string $name
     * @param $arguments
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        if (strpos($name, 'supports') === 0) {
            return $this->supports(lcfirst(substr($name, 8)));
        }

        if (in_array($name, $this->requestMethods)) {
            $parameters = array_key_exists(0, $arguments) ? $arguments[0] : [];
            return $this->createRequest($name, $parameters);
        }

        $class = get_class($this);
        throw new \BadMethodCallException("Method '$class::$name' does not exists");
    }
}