Integracao\ControlPay\AbstractAPI

Complexity

Total Complexity

14

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	37	4
A	addQueryAdditionalParameters()	0	12	3
A	getResponse()	0	4	1
A	getQueryParameters()	0	5	2
A	getHeaders()	0	5	2
A	requestException()	0	9	2

<?php
namespace Integracao\ControlPay;

use GuzzleHttp;
use Integracao\ControlPay\Constants\ControlPayParameterConst;
use Integracao\ControlPay\Impl\BasicAuthentication;
use Integracao\ControlPay\Impl\KeyQueryStringAuthentication;

/**
 * Class AbstractAPI
 * @package Integracao\NTKPedido
 */
abstract class AbstractAPI
{
    /**
     * @var Client
     */
    protected $_client;

    /**
     * @var GuzzleHttp\Client
     */
    protected $_httpClient;

    /**
     * @var string
     */
    protected $url;

    /**
     * @var string
     */
    protected $endpoint;

    /**
     * @var GuzzleHttp\Query
     */
    protected $query;

    /**
     * @var GuzzleHttp\Message\ResponseInterface
     */
    protected $response;

    /**
     * @var array
     */
    protected $headers = [
        'Content-Type' => 'application/json; charset=utf-8',
        'Cache-Control' => 'no-cache',
    ];

    /**
     * AbstractAPI constructor.
     * @param $endpoint
     * @param Client|null $client
     */
    protected function __construct($endpoint, Client $client = null)
    {
        $this->endpoint = $endpoint;
        $this->_client = $client;

        if(is_null($this->_client))
            $this->_client = new Client();

        $this->query = new GuzzleHttp\Query();
        $this->query->setEncodingType(false);

        switch ($this->_client->getParameter(ControlPayParameterConst::CONTROLPAY_OAUTH_TYPE))
        {
            case KeyQueryStringAuthentication::class:
                $this->query->set('key', $this->_client->getAuthentication());
                break;
            case BasicAuthentication::class:
                $this->headers['Authorization'] = $this->_client->getAuthentication();
                break;
            default:
                $this->query->set('key', $this->_client->getAuthentication());
                break;
        }

        $this->_httpClient = new GuzzleHttp\Client([
            'base_url' => sprintf("%s/%s/",
                $client->getParameter(ControlPayParameterConst::CONTROLPAY_HOST),

It seems like $client is not always an object, but can also be of type null. Maybe add an additional type check?

                $this->endpoint
            ),
            'timeout' => $client->getParameter(ControlPayParameterConst::CONTROLPAY_TIMEOUT),
            'verify' => false,
            'defaults' => [
                'headers' => $this->headers,
                'query' => $this->query
            ]
        ]);
    }

    /**
     * Adiciona parâmetros mantendo os já inicializados como padrão
     *
     * @param array $params
     * @return string
     */
    protected function addQueryAdditionalParameters(array $params)
    {
        $this->query = new GuzzleHttp\Query();

        if(isset($this->_httpClient->getDefaultOption()['query']))
            $this->query = $this->_httpClient->getDefaultOption()['query'];

        foreach ($params as $key => $value)
            $this->query->set($key, $value);

        return $this->query;
    }

    /**
     * @return GuzzleHttp\Message\ResponseInterface
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * @return array
     */
    public function getQueryParameters()
    {
        return isset($this->_httpClient->getDefaultOption()['query']) ?
            $this->_httpClient->getDefaultOption()['query'] : [];
    }

    /**
     * @return array
     */
    public function getHeaders()
    {
        return isset($this->_httpClient->getDefaultOption()['headers']) ?
            $this->_httpClient->getDefaultOption()['headers'] : [];
    }

    /**
     * @param GuzzleHttp\Exception\RequestException $ex
     * @param string $message
     * @throws \Exception
     */
    protected function requestException(GuzzleHttp\Exception\RequestException $ex, $message = "Falha de requisição")
    {
        if ($ex->hasResponse()) {
            throw new \Exception(sprintf("%s \ncode => [%s] \nbody => [%s]", $message,
                $ex->getResponse()->getStatusCode(), $ex->getResponse()->getBody()));
        }

        throw new \Exception($message, $ex->getCode(), $ex);
    }

}