GFG\Hek\ApiClient

Complexity

Total Complexity

18

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	setClient()	0	5	1
A	getUniqueId()	0	8	2
A	setUniqueId()	0	5	1
B	getClient()	0	26	3
A	execute()	0	55	4
A	logRequest()	0	16	1
A	logResponse()	0	12	1
A	checkResponse()	0	13	2
A	getConfiguration()	0	4	1
A	setConfiguration()	0	5	1

<?php

namespace GFG\Hek;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\RequestException;

class ApiClient
{
    const RESPONSE_OK         = 200;
    const RESPONSE_OK_NO_BODY = 204;

    /**
     * @var \GuzzleHttp\Client
     */
    private $client;

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

    /**
     * @var Interfaces\Configuration
     */
    private $configuration;

    /**
     * @var \Psr\Log\LoggerInterface
     */
    private $logger;

    /**
     * @param Interfaces\Configuration $configuration
     * @param \Psr\Log\LoggerInterface $logger
     */
    public function __construct(
        Interfaces\Configuration $configuration,
        \Psr\Log\LoggerInterface $logger
    ) {
        $this->uniqueId = $this->getUniqueId();
        $this->logger   = $logger;

        $this->setConfiguration($configuration);
    }

    /**
     * @param $client
     * @return ApiClient
     */
    public function setClient($client)
    {
        $this->client = $client;
        return $this;
    }

    /**
     * @return string
     */
    public function getUniqueId()
    {
        if (!$this->uniqueId) {
            $this->uniqueId = uniqid();
        }

        return $this->uniqueId;
    }

    /**
     * @param string $uniqueId
     * @return ApiClient
     */
    public function setUniqueId($uniqueId)
    {
        $this->uniqueId = $uniqueId;
        return $this;
    }

    /**
     * @return \GuzzleHttp\Client
     */
    public function getClient()
    {
        if (!$this->client) {

            // http authentication
            $auth = [];
            if ($this->getConfiguration()->getHttpUser()) {
                $auth = [
                    'auth' => [
                        $this->getConfiguration()->getHttpUser(),
                        $this->getConfiguration()->getHttpPass()
                    ]
                ];
            }

            $this->client = new HttpClient(array_merge($auth, [
                'base_uri'  => $this->getConfiguration()->getBaseUrl(),
                'headers'   => [
                    'Accept'       => 'application/json',
                    'Content-Type' => 'application/json'
                ]
            ]));
        }

        return $this->client;
    }

    /**
     * @param Interfaces\Context $context
     * @return void
     */
    public function execute(Interfaces\Context $context)
    {
        try {
            $configuration = $this->getConfiguration();
            $contextUrl    = $context->getUrl();
            $url           = $contextUrl->getFullUrl();

            $options       = [
                'headers' => [
                    'access-token' => $configuration->getAccessToken(),
                    'user-key'     => $configuration->getUserKey()
                ],
                'exceptions' => false
            ];

            if (strtolower($context->getHttpMethod()) === 'get') {

                // send context on query string
                $options['query'] = $context->exportContextData();
            } else {

                // send context on request body as JSON 
                $options['body'] = json_encode($context->exportContextData());
            }

            $this->logRequest($url, $options, $context->getHttpMethod());

            $response = $this->getClient()
                ->{$context->getHttpMethod()}($url, $options);

            $this->checkResponse($response);
            $this->logResponse($response);

            return $response;

        } catch (\Exception $e) {

            $message = "Unable to execute context {$context->getName()}" .
                " ( Exception message: {$e->getMessage()})";

            $this->logger->error($message, $context->exportContextData());

            $retryMessage = sprintf('Try Again - Message: %s - Code: %s', $e->getMessage(), $e->getCode());
            $code = 500;

            if ($e instanceof \GuzzleHttp\Exception\RequestException) {
                $this->logResponse($e->getResponse());

It seems like $e->getResponse() can be null; however, logResponse() does not accept null, maybe add an additional type check?

                $retryMessage = $e->getResponse()->getBody();
                $code         = $e->getResponse()->getStatusCode();
            }

            throw new Exceptions\RetryMessage($retryMessage, $code);
        }
    }

    /**
     * @param string $url
     * @param array $options
     * @param string $method
     * @return void
     */
    private function logRequest($url, $options, $method = '')
    {
        $baseUri = $this->getClient()->getConfig('base_uri');

        $url = $baseUri . $url;

        $message = sprintf(
            '%s %s REQUEST TO: %s -- OPTIONS %s',
            $this->getUniqueId(),
            $method,
            $url,
            json_encode($options)
        );

        $this->logger->info($message);
    }

    /**
     * @param \Psr\Http\Message\ResponseInterface $response
     * @return void
     */
    private function logResponse(
        \Psr\Http\Message\ResponseInterface $response
    ) {
        $message = sprintf(
            '%s RESPONSE: -- HTTP CODE %s -- BODY %s',
            $this->getUniqueId(),
            $response->getStatusCode(),
            $response->getBody()
        );

        $this->logger->info($message);
    }

    /**
     * @param \Psr\Http\Message\ResponseInterface $response
     * @return bool
     */
    private function checkResponse(
        \Psr\Http\Message\ResponseInterface $response
    ) {
        if (!in_array(
            $response->getStatusCode(),
            array(static::RESPONSE_OK, static::RESPONSE_OK_NO_BODY)
        )) {
            throw new Exceptions\RetryMessage(
                $response->getBody(),
                $response->getStatusCode()
            );
        }
    }

    /**
     * Gets the value of configuration
     *
     * @return Interfaces\Configuration
     */
    public function getConfiguration()
    {
        return $this->configuration;
    }

    /**
     * Sets the value of Configuration
     *
     * @param Interfaces\Configuration $configuration
     * @return ApiClient
     */
    public function setConfiguration(Interfaces\Configuration $configuration)
    {
        $this->configuration = $configuration;
        return $this;
    }
}