Waredesk\RequestHandler

Complexity

Total Complexity

28

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

76.74%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	disabledAuthentication()	0	4	1
A	getClientId()	0	4	1
A	setClientId()	0	4	1
A	getClientSecret()	0	4	1
A	setClientSecret()	0	4	1
A	getAccessToken()	0	17	2
A	setAccessToken()	0	4	1
A	getApiUrl()	0	4	1
A	setApiUrl()	0	5	1
A	setMockHandler()	0	5	1
A	handleBadResponse()	0	10	2
A	handleException()	0	4	1
A	enhanceHeaders()	0	12	3
A	encodeParams()	0	8	2
A	request()	0	19	4
A	get()	0	4	1
A	post()	0	4	1
A	update()	0	4	1
A	delete()	0	4	1

<?php

namespace Waredesk;

use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Request as GuzzleRequest;
use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\ResponseInterface;
use Waredesk\Exceptions\UnknownException;

class RequestHandler
{
    private $mockHandler;
    private $accessToken;
    private $apiUrl;
    private $client;
    private $clientId;
    private $clientSecret;
    private $disabledAuthentication = false;

    public function __construct(string $clientId, string $clientSecret, string $accessToken = null, string $apiUrl = null)
    {
        $this->clientId = $clientId;
        $this->clientSecret = $clientSecret;
        $this->accessToken = $accessToken;
        $this->apiUrl = $apiUrl;
        $this->client = new Client(['base_uri' => $this->apiUrl, 'handler' => $this->mockHandler]);
    }

    public function disabledAuthentication()
    {
        $this->disabledAuthentication = true;
    }

    public function getClientId(): string
    {
        return $this->clientId;
    }

    public function setClientId(string $clientId = null)
    {
        $this->clientId = $clientId;
    }

    public function getClientSecret(): string
    {
        return $this->clientSecret;
    }

    public function setClientSecret(string $clientSecret = null)
    {
        $this->clientSecret = $clientSecret;
    }

    public function getAccessToken(): string
    {
        if (null !== $this->accessToken) {
            return $this->accessToken;
        }
        $this->disabledAuthentication();
        $response = $this->post(
            '/v1/authorize',
            [
                'client_id' => $this->clientId,
                'client_secret' => $this->clientSecret,
                'grant_type' => 'client_credentials'
            ]
        );
        $this->accessToken = $response['access_token'];
        return $this->accessToken;
    }

    public function setAccessToken(string $accessToken = null)
    {
        $this->accessToken = $accessToken;
    }

    public function getApiUrl(): string
    {
        return $this->apiUrl;
    }

    public function setApiUrl(string $apiUrl)
    {
        $this->apiUrl = $apiUrl;
        $this->client = new Client(['base_uri' => $this->apiUrl, 'handler' => $this->mockHandler]);
    }

    public function setMockHandler(HandlerStack $mockHandler = null)
    {
        $this->mockHandler = $mockHandler;
        $this->client = new Client(['base_uri' => $this->apiUrl, 'handler' => $this->mockHandler]);
    }

    private function handleBadResponse(ResponseInterface $response = null)
    {
        if ($response) {
            $body = (string)$response->getBody();
            $json = \GuzzleHttp\json_decode($body, true);
            (new ErrorHandler())($json);
            return;
        }
        throw new UnknownException();
    }

    private function handleException(ClientException $exception)
    {
        $this->handleBadResponse($exception->getResponse());
    }

    private function enhanceHeaders(array $headers = []): array
    {
        $headers['Content-Type'] = 'application/json';
        if (!$this->disabledAuthentication) {
            $accessToken = $this->getAccessToken();
            if ($accessToken !== null) {
                $headers['Authorization'] = 'Bearer '.$accessToken;
            }
        }
        $this->disabledAuthentication = false;
        return $headers;
    }

    private function encodeParams($params = null): ?string
    {
        $body = null;
        if ($params) {
            $body = \GuzzleHttp\json_encode($params);
        }
        return $body;
    }

    private function request(string $method, string $endpoint, array $headers = [], $params = null): array
    {
        try {
            $request = new GuzzleRequest(
                $method,
                $endpoint,
                $this->enhanceHeaders($headers),
                $this->encodeParams($params)
            );
            $response = $this->client->send($request);
            if ($response->getStatusCode() >= 200 && $response->getStatusCode() <= 399) {
                return \GuzzleHttp\json_decode((string)$response->getBody(), true);
            }
            $this->handleBadResponse($response);
        } catch (ClientException $e) {
            $this->handleException($e);
        }
        throw new UnknownException();
    }

    public function get(string $endpoint, array $headers = [], array $params = null): array
    {
        return $this->request('GET', $endpoint, $headers, $params);
    }

    public function post(string $endpoint, $params = null, array $headers = []): array
    {
        return $this->request('POST', $endpoint, $headers, $params);
    }

    public function update(string $endpoint, $params = null, array $headers = []): array
    {
        return $this->request('PUT', $endpoint, $headers, $params);
    }

    public function delete(string $endpoint, $params = null, array $headers = []): array
    {
        return $this->request('DELETE', $endpoint, $headers, $params);
    }
}