GFG\Hek\ApiClient

Complexity

Total Complexity

17

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	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
B	execute()	0	45	3
A	logRequest()	0	11	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 \Hek\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 Client
     */
    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 Client
     */
    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       = [
                'body'    => json_encode($context->exportContextData()),
                'headers' => [
                    'access-token' => $configuration->getAccessToken(),
                    'user-key'     => $configuration->getUserKey()
                ],
                'exceptions' => false
            ];


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

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

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

        } catch (\Exception $e) {

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

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

            $retryMessage = 'Try Again';
            $code = 500;

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

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

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

    /**
     * @param string $url
     * @param array $options
     * @return void
     */
    private function logRequest($url, $options)
    {
        $message = sprintf(
            '%s REQUEST TO: %s -- OPTIONS %s',
            $this->getUniqueId(),
            $url,
            json_encode($options)
        );

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

    /**
     * @param \GuzzleHttp\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 \GuzzleHttp\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 Client
     */
    public function setConfiguration(Interfaces\Configuration $configuration)
    {
        $this->configuration = $configuration;

It seems like $configuration of type object<GFG\Hek\Interfaces\Configuration> is incompatible with the declared type object<Hek\Interfaces\Configuration> of property $configuration.

        return $this;
    }
}