Picqer\Financials\Exact\Connection

Complexity

Total Complexity

88

Size/Duplication

Total Lines	786
Duplicated Lines	0 %

Importance

Changes	37
Bugs	4	Features	4

48 Methods

Rating	Name	Duplication	Size	Complexity
A	insertMiddleWare()	0	3	1
A	setClient()	0	3	1
A	client()	0	18	3
A	getMinutelyLimitRemaining()	0	3	1
A	setBaseUrl()	0	3	1
A	getAccessToken()	0	3	1
B	parseResponse()	0	35	9
A	getAuthUrl()	0	6	1
A	post()	0	11	2
A	getDailyLimitReset()	0	3	1
A	put()	0	11	2
A	get()	0	11	2
A	getTokenUrl()	0	3	1
A	createRequest()	0	28	6
A	setTokenExpires()	0	3	1
A	getApiUrl()	0	3	1
A	setExactClientSecret()	0	3	1
A	getDivision()	0	3	1
A	getCurrentDivisionNumber()	0	8	2
A	connect()	0	17	4
A	setExactClientId()	0	3	1
A	extractRateLimits()	0	8	1
A	tokenHasExpired()	0	7	2
A	redirectForAuthorization()	0	5	1
A	parseExceptionForErrorMessages()	0	21	4
A	getTokenExpires()	0	3	1
A	formatUrl()	0	17	3
A	getTimestampFromExpiresIn()	0	7	2
A	setRefreshToken()	0	3	1
A	setApiUrl()	0	3	1
A	needsAuthentication()	0	3	2
A	setTokenUpdateCallback()	0	3	1
A	setRedirectUrl()	0	3	1
A	getDailyLimitRemaining()	0	3	1
A	setDivision()	0	3	1
A	setAcquireAccessTokenLockCallback()	0	3	1
A	setAuthUrl()	0	3	1
A	setTokenUrl()	0	3	1
A	getBaseUrl()	0	3	1
A	getMinutelyLimit()	0	3	1
B	acquireAccessToken()	0	50	7
A	setAuthorizationCode()	0	3	1
A	getDailyLimit()	0	3	1
A	delete()	0	11	2
A	setAcquireAccessTokenUnlockCallback()	0	3	1
A	getRefreshToken()	0	3	1
A	setAccessToken()	0	3	1
A	acquireAccessToken_by_refreshtoken()	0	29	4

<?php

namespace Picqer\Financials\Exact;

use Exception;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\BadResponseException;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;

/**
 * Class Connection.
 */
class Connection
{
    /**
     * @var string
     */
    private $baseUrl = 'https://start.exactonline.nl';

    /**
     * @var string
     */
    private $apiUrl = '/api/v1';

    /**
     * @var string
     */
    private $authUrl = '/api/oauth2/auth';

    /**
     * @var string
     */
    private $tokenUrl = '/api/oauth2/token';

    /**
     * @var mixed
     */
    private $exactClientId;

    /**
     * @var mixed
     */
    private $exactClientSecret;

    /**
     * @var mixed
     */
    private $authorizationCode;

    /**
     * @var mixed
     */
    private $accessToken;

    /**
     * @var int the Unix timestamp at which the access token expires
     */
    private $tokenExpires;

    /**
     * @var mixed
     */
    private $refreshToken;

    /**
     * @var mixed
     */
    private $redirectUrl;

    /**
     * @var mixed
     */
    private $division;

    /**
     * @var Client|null
     */
    private $client;

    /**
     * @var callable(Connection)
     */
    private $tokenUpdateCallback;

    /**
     * @var callable(Connection)
     */
    private $acquireAccessTokenLockCallback;

    /**
     * @var callable(Connection)
     */
    private $acquireAccessTokenUnlockCallback;

    /**
     * @var callable[]
     */
    protected $middleWares = [];

    /**
     * @var string|null
     */
    public $nextUrl = null;

    /**
     * @var int|null
     */
    protected $dailyLimit;

    /**
     * @var int|null
     */
    protected $dailyLimitRemaining;

    /**
     * @var int|null
     */
    protected $dailyLimitReset;

    /**
     * @var int|null
     */
    protected $minutelyLimit;

    /**
     * @var int|null
     */
    protected $minutelyLimitRemaining;

    /**
     * @return Client
     */
    private function client()
    {
        if ($this->client) {
            return $this->client;
        }

        $handlerStack = HandlerStack::create();
        foreach ($this->middleWares as $middleWare) {
            $handlerStack->push($middleWare);
        }

        $this->client = new Client([
            'http_errors' => true,
            'handler'     => $handlerStack,
            'expect'      => false,
        ]);

        return $this->client;
    }

    /**
     * Insert a custom Guzzle client.
     *
     * @param Client $client
     */
    public function setClient($client)
    {
        $this->client = $client;
    }

    /**
     * Insert a Middleware for the Guzzle Client.
     *
     * @param $middleWare
     */
    public function insertMiddleWare($middleWare)
    {
        $this->middleWares[] = $middleWare;
    }

    /**
     * @throws ApiException
     *
     * @return Client
     */
    public function connect()
    {
        // Redirect for authorization if needed (no access token or refresh token given)
        if ($this->needsAuthentication()) {
            $this->redirectForAuthorization();
        }

        // If access token is not set or token has expired, acquire new token
		if (empty($this->accessToken)){
			$this->acquireAccessToken();
		}else if($this->tokenHasExpired()){
			$this->acquireAccessToken_by_refreshtoken();
		}
		
        $client = $this->client();

        return $client;
    }
	
	// Acquire AccessToken by RefreshToken
	private function acquireAccessToken_by_refreshtoken() {
		$headers = array("Content-Type: application/x-www-form-urlencoded", "Cache-Control: no-cache");	
		$params = array(
			'refresh_token' => $this->refreshToken,
			'grant_type' => 'refresh_token',
			'client_id'     => $this->exactClientId,
            'client_secret' => $this->exactClientSecret,
		);

		$curl = curl_init();                  
		$url = $this->getTokenUrl();
		curl_setopt($curl, CURLOPT_URL,$url);

It seems like $curl can also be of type false; however, parameter $ch of curl_setopt() does only seem to accept resource, maybe add an additional type check?

		curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);				
		curl_setopt($curl, CURLOPT_POST, true); 
		curl_setopt($curl, CURLOPT_POSTFIELDS,http_build_query($params));
		curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
		$output = curl_exec ($curl);

It seems like $curl can also be of type false; however, parameter $ch of curl_exec() does only seem to accept resource, maybe add an additional type check?

		$res = json_decode($output, true);
		if(!$res['error'] && $res['refresh_token']){
			$this->accessToken = $res['access_token'];
			$this->refreshToken = $res['refresh_token'];
			$this->tokenExpires = $this->getTimestampFromExpiresIn($res['expires_in']);

			if (is_callable($this->tokenUpdateCallback)) {
				call_user_func($this->tokenUpdateCallback, $this);
			}
		} else {
			throw new ApiException('Could not acquire tokens, json decode failed. Got response: ' . $res["error"] .', '. $res["error_description"]);
		}
	}

    /**
     * @param string $method
     * @param string $endpoint
     * @param mixed  $body
     * @param array  $params
     * @param array  $headers
     *
     * @return Request
     */
    private function createRequest($method, $endpoint, $body = null, array $params = [], array $headers = [])
    {
        // Add default json headers to the request
        $headers = array_merge($headers, [
            'Accept'       => 'application/json',
            'Content-Type' => 'application/json',
            'Prefer'       => 'return=representation',
        ]);

        // If access token is not set or token has expired, acquire new token
        if (empty($this->accessToken) || $this->tokenHasExpired()) {
            $this->acquireAccessToken();
        }

        // If we have a token, sign the request
        if (! $this->needsAuthentication() && ! empty($this->accessToken)) {
            $headers['Authorization'] = 'Bearer ' . $this->accessToken;
        }

        // Create param string
        if (! empty($params)) {
            $endpoint .= '?' . http_build_query($params);
        }

        // Create the request
        $request = new Request($method, $endpoint, $headers, $body);

        return $request;
    }

    /**
     * @param string $url
     * @param array  $params
     * @param array  $headers
     *
     * @throws ApiException
     *
     * @return mixed
     */
    public function get($url, array $params = [], array $headers = [])
    {
        $url = $this->formatUrl($url, $url !== 'current/Me', $url == $this->nextUrl);

        try {
            $request = $this->createRequest('GET', $url, null, $params, $headers);
            $response = $this->client()->send($request);

            return $this->parseResponse($response, $url != $this->nextUrl);
        } catch (Exception $e) {
            $this->parseExceptionForErrorMessages($e);
        }
    }

    /**
     * @param string $url
     * @param mixed  $body
     *
     * @throws ApiException
     *
     * @return mixed
     */
    public function post($url, $body)
    {
        $url = $this->formatUrl($url);

        try {
            $request = $this->createRequest('POST', $url, $body);
            $response = $this->client()->send($request);

            return $this->parseResponse($response);
        } catch (Exception $e) {
            $this->parseExceptionForErrorMessages($e);
        }
    }

    /**
     * @param string $url
     * @param mixed  $body
     *
     * @throws ApiException
     *
     * @return mixed
     */
    public function put($url, $body)
    {
        $url = $this->formatUrl($url);

        try {
            $request = $this->createRequest('PUT', $url, $body);
            $response = $this->client()->send($request);

            return $this->parseResponse($response);
        } catch (Exception $e) {
            $this->parseExceptionForErrorMessages($e);
        }
    }

    /**
     * @param string $url
     *
     * @throws ApiException
     *
     * @return mixed
     */
    public function delete($url)
    {
        $url = $this->formatUrl($url);

        try {
            $request = $this->createRequest('DELETE', $url);
            $response = $this->client()->send($request);

            return $this->parseResponse($response);
        } catch (Exception $e) {
            $this->parseExceptionForErrorMessages($e);
        }
    }

    /**
     * @return string
     */
    public function getAuthUrl()
    {
        return $this->baseUrl . $this->authUrl . '?' . http_build_query([
            'client_id'     => $this->exactClientId,
            'redirect_uri'  => $this->redirectUrl,
            'response_type' => 'code',
        ]);
    }

    /**
     * @param mixed $exactClientId
     */
    public function setExactClientId($exactClientId)
    {
        $this->exactClientId = $exactClientId;
    }

    /**
     * @param mixed $exactClientSecret
     */
    public function setExactClientSecret($exactClientSecret)
    {
        $this->exactClientSecret = $exactClientSecret;
    }

    /**
     * @param mixed $authorizationCode
     */
    public function setAuthorizationCode($authorizationCode)
    {
        $this->authorizationCode = $authorizationCode;
    }

    /**
     * @param mixed $accessToken
     */
    public function setAccessToken($accessToken)
    {
        $this->accessToken = $accessToken;
    }

    /**
     * @param mixed $refreshToken
     */
    public function setRefreshToken($refreshToken)
    {
        $this->refreshToken = $refreshToken;
    }

    public function redirectForAuthorization()
    {
        $authUrl = $this->getAuthUrl();
        header('Location: ' . $authUrl);
        exit;
    }

    /**
     * @param mixed $redirectUrl
     */
    public function setRedirectUrl($redirectUrl)
    {
        $this->redirectUrl = $redirectUrl;
    }

    /**
     * @return bool
     */
    public function needsAuthentication()
    {
        return empty($this->refreshToken) && empty($this->authorizationCode);
    }

    /**
     * @param Response $response
     * @param bool     $returnSingleIfPossible
     *
     * @throws ApiException
     *
     * @return mixed
     */
    private function parseResponse(Response $response, $returnSingleIfPossible = true)
    {
        try {
            if ($response->getStatusCode() === 204) {
                return [];
            }

            $this->extractRateLimits($response);

            Psr7\rewind_body($response);

The function rewind_body was not found. Maybe you did not declare it correctly or list all dependencies?

            $json = json_decode($response->getBody()->getContents(), true);
            if (false === is_array($json)) {
                throw new ApiException('Json decode failed. Got response: ' . $response->getBody()->getContents());
            }
            if (array_key_exists('d', $json)) {
                if (array_key_exists('__next', $json['d'])) {
                    $this->nextUrl = $json['d']['__next'];
                } else {
                    $this->nextUrl = null;
                }

                if (array_key_exists('results', $json['d'])) {
                    if ($returnSingleIfPossible && count($json['d']['results']) == 1) {
                        return $json['d']['results'][0];
                    }

                    return $json['d']['results'];
                }

                return $json['d'];
            }

            return $json;
        } catch (\RuntimeException $e) {
            throw new ApiException($e->getMessage());
        }
    }

    /**
     * @return mixed
     */
    private function getCurrentDivisionNumber()
    {
        if (empty($this->division)) {
            $me = new Me($this);
            $this->division = $me->find()->CurrentDivision;
        }

        return $this->division;
    }

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

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

    private function acquireAccessToken()
    {
        try {
            if (is_callable($this->acquireAccessTokenLockCallback)) {
                call_user_func($this->acquireAccessTokenLockCallback, $this);
            }

            // If refresh token not yet acquired, do token request
            if (empty($this->refreshToken)) {
                $body = [
                    'form_params' => [
                        'redirect_uri'  => $this->redirectUrl,
                        'grant_type'    => 'authorization_code',
                        'client_id'     => $this->exactClientId,
                        'client_secret' => $this->exactClientSecret,
                        'code'          => $this->authorizationCode,
                    ],
                ];
            } else { // else do refresh token request
                $body = [
                    'form_params' => [
                        'refresh_token' => $this->refreshToken,
                        'grant_type'    => 'refresh_token',
                        'client_id'     => $this->exactClientId,
                        'client_secret' => $this->exactClientSecret,
                    ],
                ];
            }

            $response = $this->client()->post($this->getTokenUrl(), $body);

            Psr7\rewind_body($response);

The function rewind_body was not found. Maybe you did not declare it correctly or list all dependencies?

            $body = json_decode($response->getBody()->getContents(), true);

            if (json_last_error() === JSON_ERROR_NONE) {
                $this->accessToken = $body['access_token'];
                $this->refreshToken = $body['refresh_token'];
                $this->tokenExpires = $this->getTimestampFromExpiresIn($body['expires_in']);

                if (is_callable($this->tokenUpdateCallback)) {
                    call_user_func($this->tokenUpdateCallback, $this);
                }
            } else {
                throw new ApiException('Could not acquire tokens, json decode failed. Got response: ' . $response->getBody()->getContents());
            }
        } catch (BadResponseException $ex) {
            throw new ApiException('Could not acquire or refresh tokens [http ' . $ex->getResponse()->getStatusCode() . ']', 0, $ex);
        } finally {
            if (is_callable($this->acquireAccessTokenUnlockCallback)) {
                call_user_func($this->acquireAccessTokenUnlockCallback, $this);
            }
        }
    }

    /**
     * Translates expires_in to a Unix timestamp.
     *
     * @param string $expiresIn number of seconds until the token expires
     *
     * @return int
     */
    private function getTimestampFromExpiresIn($expiresIn)
    {
        if (! ctype_digit($expiresIn)) {
            throw new \InvalidArgumentException('Function requires a numeric expires value');
        }

        return time() + $expiresIn;
    }

    /**
     * @return int the Unix timestamp at which the access token expires
     */
    public function getTokenExpires()
    {
        return $this->tokenExpires;
    }

    /**
     * @param int $tokenExpires the Unix timestamp at which the access token expires
     */
    public function setTokenExpires($tokenExpires)
    {
        $this->tokenExpires = $tokenExpires;
    }

    private function tokenHasExpired()
    {
        if (empty($this->tokenExpires)) {
            return true;
        }

        return ($this->tokenExpires - 60) < time();
    }

    private function formatUrl($endPoint, $includeDivision = true, $formatNextUrl = false)
    {
        if ($formatNextUrl) {
            return $endPoint;
        }

        if ($includeDivision) {
            return implode('/', [
                $this->getApiUrl(),
                $this->getCurrentDivisionNumber(),
                $endPoint,
            ]);
        }

        return implode('/', [
            $this->getApiUrl(),
            $endPoint,
        ]);
    }

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

    /**
     * @param mixed $division
     */
    public function setDivision($division)
    {
        $this->division = $division;
    }

    /**
     * @param callable $callback
     */
    public function setAcquireAccessTokenLockCallback($callback)
    {
        $this->acquireAccessTokenLockCallback = $callback;
    }

    /**
     * @param callable $callback
     */
    public function setAcquireAccessTokenUnlockCallback($callback)
    {
        $this->acquireAccessTokenUnlockCallback = $callback;
    }

    /**
     * @param callable $callback
     */
    public function setTokenUpdateCallback($callback)
    {
        $this->tokenUpdateCallback = $callback;
    }

    /**
     * Parse the reponse in the Exception to return the Exact error messages.
     *
     * @param Exception $e
     *
     * @throws ApiException
     */
    private function parseExceptionForErrorMessages(Exception $e)
    {
        if (! $e instanceof BadResponseException) {
            throw new ApiException($e->getMessage(), 0, $e);
        }

        $response = $e->getResponse();

        $this->extractRateLimits($response);

It seems like $response can also be of type null; however, parameter $response of Picqer\Financials\Exact\Connection::extractRateLimits() does only seem to accept GuzzleHttp\Psr7\Response, maybe add an additional type check?

        Psr7\rewind_body($response);

The function rewind_body was not found. Maybe you did not declare it correctly or list all dependencies?

        $responseBody = $response->getBody()->getContents();
        $decodedResponseBody = json_decode($responseBody, true);

        if (! is_null($decodedResponseBody) && isset($decodedResponseBody['error']['message']['value'])) {
            $errorMessage = $decodedResponseBody['error']['message']['value'];
        } else {
            $errorMessage = $responseBody;
        }

        throw new ApiException('Error ' . $response->getStatusCode() . ': ' . $errorMessage, $response->getStatusCode(), $e);
    }

    /**
     * @return int|null The maximum number of API calls that your app is permitted to make per company, per day
     */
    public function getDailyLimit()
    {
        return $this->dailyLimit;
    }

    /**
     * @return int|null The remaining number of API calls that your app is permitted to make for a company, per day
     */
    public function getDailyLimitRemaining()
    {
        return $this->dailyLimitRemaining;
    }

    /**
     * @return int|null The time at which the rate limit window resets in UTC epoch milliseconds
     */
    public function getDailyLimitReset()
    {
        return $this->dailyLimitReset;
    }

    /**
     * @return int|null The maximum number of API calls that your app is permitted to make per company, per minute
     */
    public function getMinutelyLimit()
    {
        return $this->minutelyLimit;
    }

    /**
     * @return int|null The remaining number of API calls that your app is permitted to make for a company, per minute
     */
    public function getMinutelyLimitRemaining()
    {
        return $this->minutelyLimitRemaining;
    }

    /**
     * @return string
     */
    protected function getBaseUrl()
    {
        return $this->baseUrl;
    }

    /**
     * @return string
     */
    private function getApiUrl()
    {
        return $this->baseUrl . $this->apiUrl;
    }

    /**
     * @return string
     */
    private function getTokenUrl()
    {
        return $this->baseUrl . $this->tokenUrl;
    }

    /**
     * Set base URL for different countries according to
     * https://developers.exactonline.com/#Exact%20Online%20sites.html.
     *
     * @param string $baseUrl
     */
    public function setBaseUrl($baseUrl)
    {
        $this->baseUrl = $baseUrl;
    }

    /**
     * @param string $apiUrl
     */
    public function setApiUrl($apiUrl)
    {
        $this->apiUrl = $apiUrl;
    }

    /**
     * @param string $authUrl
     */
    public function setAuthUrl($authUrl)
    {
        $this->authUrl = $authUrl;
    }

    /**
     * @param string $tokenUrl
     */
    public function setTokenUrl($tokenUrl)
    {
        $this->tokenUrl = $tokenUrl;
    }

    private function extractRateLimits(Response $response)
    {
        $this->dailyLimit = (int) $response->getHeaderLine('X-RateLimit-Limit');
        $this->dailyLimitRemaining = (int) $response->getHeaderLine('X-RateLimit-Remaining');
        $this->dailyLimitReset = (int) $response->getHeaderLine('X-RateLimit-Reset');

        $this->minutelyLimit = (int) $response->getHeaderLine('X-RateLimit-Minutely-Limit');
        $this->minutelyLimitRemaining = (int) $response->getHeaderLine('X-RateLimit-Minutely-Remaining');
    }
}