Inktale\Api\InktaleApiClient

Complexity

Total Complexity

20

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setApiKey()	0	4	1
A	get()	0	4	1
A	delete()	0	4	1
A	post()	0	4	1
A	put()	0	4	1
A	getLastResponseRaw()	0	4	1
A	getLastResponse()	0	4	1
A	request()	0	17	2
A	initCurl()	0	16	1
A	getUrl()	0	8	2
B	execute()	0	41	5
A	getCurlHeaders()	0	13	2

<?php

namespace Inktale\Api;

use Inktale\Api\Exceptions\InktaleApiAuthException;
use Inktale\Api\Exceptions\InktaleApiException;
use Inktale\Api\Structures\ApiErrorItem;

class InktaleApiClient
{
    const USER_AGENT = 'Inktale PHP wrapper (https://github.com/inktale/php-api-sdk)';

    /**
     * @var string
     */
    public $url = 'https://inktale.com/api/v1/';

    /**
     * Last JSON encoded response
     *
     * @var string
     */
    private $lastResponseRaw;

    /**
     * Last parsed response (json decoded)
     *
     * @var array
     */
    private $lastResponse;

    /**
     * Authorization token
     *
     * @var string
     */
    private $apiKey;

    /**
     * Your API key
     *
     * @param string|null $apiKey
     */
    public function __construct($apiKey = null)
    {
        $this->setApiKey($apiKey);
    }

    /**
     * Set authorization header key
     * @param string $apiKey
     */
    public function setApiKey($apiKey)
    {
        $this->apiKey = $apiKey;
    }

    /**
     * Perform a GET request to the API
     *
     * @param string $path Request path
     * @param array $params Additional GET parameters as an associative array
     * @return mixed
     */
    public function get($path, $params = [])
    {
        return $this->request('GET', $path, $params);
    }

    /**
     * Perform a DELETE request to the API
     *
     * @param string $path Request path
     * @param array $params Additional GET parameters as an associative array
     * @return mixed
     */
    public function delete($path, $params = [])
    {
        return $this->request('DELETE', $path, $params);
    }

    /**
     * Perform a POST request to the API
     *
     * @param string $path Request path
     * @param array $data Request body data as an associative array
     * @param array $params Additional GET parameters as an associative array
     * @return mixed
     */
    public function post($path, $data = [], $params = [])
    {
        return $this->request('POST', $path, $params, $data);
    }

    /**
     * Perform a PUT request to the API
     *
     * @param string $path Request path
     * @param array $data Request body data as an associative array
     * @param array $params Additional GET parameters as an associative array
     * @return mixed
     */
    public function put($path, $data = [], $params = [])
    {
        return $this->request('PUT', $path, $params, $data);
    }

    /**
     * Return raw response data from the last request
     *
     * @return string|null Response data
     */
    public function getLastResponseRaw()
    {
        return $this->lastResponseRaw;
    }

    /**
     * Return decoded response data from the last request
     *
     * @return array|null Response data
     */
    public function getLastResponse()
    {
        return $this->lastResponse;
    }

    /**
     * Internal request implementation
     * @param string $method POST, GET, etc.
     * @param string $path API endpoint path
     * @param array $query Query parameters
     * @param array|mixed $data Post data
     * @return mixed
     * @throws InktaleApiException
     */
    protected function request($method, $path, array $query = [], $data = null)
    {
        $curl = $this->initCurl($method, $path, $query);

        $bodyLength = 0;
        if ($data !== null) {
            $bodyEncoded = json_encode($data);
            $bodyLength = strlen($bodyEncoded);
            curl_setopt($curl, CURLOPT_POSTFIELDS, $bodyEncoded);
        }

        $headers = $this->getCurlHeaders($bodyLength, 'application/json');

        curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);

        return $this->execute($curl);
    }

    /**
     * @param string $method
     * @param string $path
     * @param array $query Query parameters
     * @return resource cURL handler
     */
    protected function initCurl($method, $path, array $query)
    {
        $curl = curl_init($this->getUrl($path, $query));

        curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($curl, CURLOPT_MAXREDIRS, 3);

        curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 20);
        curl_setopt($curl, CURLOPT_TIMEOUT, 10);

        curl_setopt($curl, CURLOPT_USERAGENT, self::USER_AGENT);

        return $curl;
    }

    /**
     * @param string $path
     * @param array $query
     * @return string
     */
    private function getUrl($path, array $query)
    {
        $url = $this->url . ltrim($path, '/');
        if ($query) {

The expression $query of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $url .= '?' . http_build_query($query);
        }
        return $url;
    }

    /**
     * Execute cURL handler and return response
     * @param resource $curl
     * @return mixed
     * @throws InktaleApiException
     */
    private function execute($curl)
    {
        $this->lastResponseRaw = null;
        $this->lastResponse = null;

It seems like null of type null is incompatible with the declared type array of property $lastResponse.

        $responseRaw = curl_exec($curl);

        $responseCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);

        $errorNumber = curl_errno($curl);
        $error = curl_error($curl);
        curl_close($curl);

        if ($errorNumber) {
            throw new InktaleApiException('Inktale API CURL error: ' . $error, $errorNumber);
        }

        $response = json_decode($responseRaw, true);

        if ($responseCode >= 400 || !empty($response['error'])) {
            $errorItem = ApiErrorItem::fromArray($response['error']);
            $exceptionMessage = $errorItem->title . ': ' . $errorItem->details;

            if ($responseCode == 401) {
                $exception = new InktaleApiAuthException($exceptionMessage, $errorItem->code);
            } else {
                $exception = new InktaleApiException($exceptionMessage, $errorItem->code);
            }

            $exception->setRawResponse($responseRaw)
                ->setErrorDetails($errorItem->details)
                ->setErrorTitle($errorItem->title);

            throw $exception;
        }

        $this->lastResponse = $response;
        $this->lastResponseRaw = $responseRaw;

        return $response;
    }

    /**
     * @param int $contentLength
     * @param string $contentType
     * @return string[]
     */
    private function getCurlHeaders($contentLength, $contentType)
    {
        $headers = [
            'Content-Type: ' . $contentType,
            'Content-Length: ' . $contentLength,
        ];

        if ($this->apiKey) {
            $headers[] = 'Authorization:' . $this->apiKey;
        }

        return $headers;
    }
}