bSecure\ApiRequest

Complexity

Total Complexity

26

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	request()	0	9	2
A	_requestRaw()	0	19	2
A	httpClient()	0	7	2
A	__construct()	0	6	2
A	setHttpClient()	0	3	1
A	_interpretResponse()	0	15	3
A	_defaultHeaders()	0	17	4
A	handleErrorResponse()	0	16	5
A	_specificAPIError()	0	8	5

<?php

namespace bSecure;
use bSecure\Helpers\Constant;

/**
 * Class ApiRequest.
 */
class ApiRequest
{

    /**
     * @var string
     */
    private $_apiBase;

    /**
     * @var HttpClient\ClientInterface
     */
    private static $_httpClient;

    /**
     * ApiRequest constructor.
     *
     * @param null|string $apiBase
     */
    public function __construct( $apiBase = null)
    {
        if (!$apiBase) {
            $apiBase = bSecure::$apiBase;
        }
        $this->_apiBase = $apiBase;
    }

    /**
     * @param string $method
     * @param string $url
     * @param null|array $params
     * @param null|array $headers
     *
     * @throws Exception\ApiErrorException
     *
     * @return array tuple containing (ApiReponse, API key)
     */
    public function request($method, $url, $params = null, $authKey = Constant::NO)
    {
        $params = $params ?: [];
        list($rcode, $rbody, $rheaders) =
          $this->_requestRaw($method, $url, $params, $authKey);
        list($message, $exception, $rbody) = $this->_interpretResponse( $rcode,$rbody, $rheaders);

        $resp = new ApiResponse($rbody, $rcode, $message, $exception);
        return [$resp];
    }

    /**
     * @static
     *
     * @param string $apiKey
     *
     * @return array
     */
    private static function _defaultHeaders($authKey = false)
    {
        $authHeader = [];
        $defaultHeaders = [];

        if($authKey)
        {
            $authToken = bSecure::getAuthToken();
            if(gettype($authToken) == "string")
            {
                $authHeader = ['Authorization' => 'Bearer ' .$authToken];
            }else if(gettype($authToken) == "object"){
                $authHeader = [];
            }
        }
        $headers = array_merge($defaultHeaders,$authHeader);
        return $headers;
    }

    /**
     * @param string $method
     * @param string $url
     * @param array $params
     * @param array $headers
     *
     * @throws Exception\AuthenticationException
     * @throws Exception\ApiConnectionException
     *
     * @return array
     */
    private function _requestRaw($method, $url, $params, $authKey)
    {
        $absUrl = $this->_apiBase . $url;
        $defaultHeaders = $this->_defaultHeaders($authKey);

        $combinedHeaders = $defaultHeaders;
        $rawHeaders = [];

        foreach ($combinedHeaders as $header => $value) {
            $rawHeaders[] = $header . ': ' . $value;
        }
        list($rbody, $rcode, $rheaders) = $this->httpClient()->request(
          $method,
          $absUrl,
          $rawHeaders,
          $params,
          false

The call to bSecure\HttpClient\ClientInterface::request() has too many arguments starting with false.

        );
        return [$rbody, $rcode, $rheaders];
    }

    /**
     * @param string $rbody
     * @param int $rcode
     * @param array $rheaders
     *
     * @throws Exception\UnexpectedValueException
     * @throws Exception\ApiErrorException
     *
     * @return array
     */
    private function _interpretResponse( $rcode,$rbody, $rheaders)

The parameter $rheaders is not used and could be removed.

    {
        $resp = \json_decode($rbody, true);
        $jsonError = \json_last_error();

        if (null === $resp && \JSON_ERROR_NONE !== $jsonError) {
            $msg = "Invalid response body from API: {$rbody} "
              . "(HTTP response code was {$rcode}, json_last_error() was {$jsonError})";
            throw new Exception\UnexpectedValueException($msg, $rcode);
        }
        $message = $resp['message'];
        $exception = $resp['exception'];
        $rbody = $resp['body'];

        return [$message, $exception, $rbody];
    }

    /**
     * @param string $rbody a JSON string
     * @param int $rcode
     * @param array $rheaders
     * @param array $resp
     *
     * @throws Exception\UnexpectedValueException
     * @throws Exception\ApiErrorException
     */
    public function handleErrorResponse($rbody, $rcode, $rheaders, $resp)
    {
        $errorData = $resp['message'];
        $error = null;
        if (\is_array($errorData) && $errorData != []) {
            $error = self::_specificAPIError($resp,$rheaders,$rcode);
        }else{
            if (!\is_array($resp) || !isset($resp['error'])) {

The condition is_array($resp) is always true.

                $msg = "Invalid response object from API: {$rbody} "
                  . "(HTTP response code was {$rcode})";

                throw new Exception\UnexpectedValueException($msg);
            }
        }

        throw $error;
    }
    /**
     * @static
     *
     * @param string $rbody
     * @param int    $rcode
     * @param array  $rheaders
     * @param array  $resp
     * @param array  $errorData
     *
     * @return Exception\ApiErrorException
     */
    private static function _specificAPIError($errorData,$rheaders, $code)

The parameter $code is not used and could be removed.

    {
        $msg = isset($errorData['message']) ? $errorData['message'] : null;
        $body = isset($errorData['body']) ? $errorData['body'] : null;
        $code = isset($errorData['status']) ? $errorData['status'] : null;
        $exception = isset($errorData['exception']) ? $errorData['exception'] : null;

        return Exception\InvalidRequestException::factory($msg, $code, $body, $exception, $rheaders, $code);
    }
    /**
     * @static
     *
     * @param HttpClient\ClientInterface $client
     */
    public static function setHttpClient($client)
    {
        self::$_httpClient = $client;
    }


    /**
     * @return HttpClient\ClientInterface
     */
    private function httpClient()
    {
        if (!self::$_httpClient) {
            self::$_httpClient = HttpClient\CurlClient::instance();
        }

        return self::$_httpClient;
    }
}