Iris\Api\BaseClient

Complexity

Total Complexity

18

Size/Duplication

Total Lines	263
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

87.91%

Importance

Changes	4
Bugs	1	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getUniqueId()	0	4	1
A	getVersion()	0	4	1
A	getVenture()	0	4	1
A	getPartner()	0	4	1
A	getAccessToken()	0	4	1
A	getClient()	0	4	1
A	isResponseOk()	0	4	1
A	__construct()	0	11	1
A	loadClient()	0	7	1
A	loadGuzzle()	0	12	1
A	buildRequestUrl()	0	10	1
A	throwException()	0	17	2
A	create()	0	12	1
A	update()	0	12	1
A	doRequest()	0	21	2
A	logResponse()	0	12	1

<?php

namespace Iris\Api;

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

abstract class BaseClient
{
    const RESPONSE_OK = 200;

    const RESPONSE_OK_NO_BODY = 204;

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

    /**
     * @var string
     */
    protected $version;

    /**
     * @var string
     */
    protected $partner;

    /**
     * @var string
     */
    protected $accessToken;

    /**
     * @var string
     */
    protected $venture;

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

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

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

        $this->loadClient($configuration->getConnection());
    }

    /**
     * @param \Iris\Interfaces\Connection $connection
     */
    protected function loadClient(\Iris\Interfaces\Connection $connection)
    {
        $this->version      = $connection->getVersion();
        $this->accessToken  = $connection->getAccessToken();

        $this->loadGuzzle($connection->getBaseUrl());
    }

    /**
     * @param string $baseUrl
     */
    protected function loadGuzzle($baseUrl)
    {
        $this->client = new HttpClient(array(
            'base_url' => $baseUrl,
            'defaults' => array(
                'headers' => array(
                    'Accept' => 'application/json',
                    'Content-Type' => 'application/json'
                )
            )
        ));
    }

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

    /**
     * @return string
     */
    public function getVersion()
    {
        return $this->version;
    }

    /**
     * @return string
     */
    public function getVenture()
    {
        return $this->venture;
    }

    /**
     * @return string
     */
    public function getPartner()
    {
        return $this->partner;
    }

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

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

    /**TODO generalize this method to be used by Bob as venture
     * Builds path to call api.
     * @param string $callPath Suffix path, the action.
     * @param string $venture Venture code.
     * @return string
     */
    protected function buildRequestUrl($callPath, $venture)
    {
        $requestUrl = sprintf(
            'api/%s/gfg/%s/%s',
            $this->getVersion(),
            $this->getPartner(),
            $venture
        );
        return $requestUrl . $callPath;
    }

    /**
     * @param \Exception $exception
     * @param string $message
     * @param array $context
     * @throw \Iris\Exceptions\RetryMessage
     */
    public function throwException(\Exception $exception, $message, array $context = [])
    {
        $message = $message . ' ( Exception message: ' . $exception->getMessage() . ')';
        $this->logger->error($message, $context);

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

        if ($exception instanceof RequestException) {
            $this->logResponse($exception->getResponse());

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

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

    /**
     * @param string $url
     * @param $body
     * @return \GuzzleHttp\Message\Response
     */
    protected function create($url, $body)
    {
        return $this->doRequest(
            'post',
            $url,
            array(
                'body' => json_encode($body),
                'headers' => ['venture-access-token' => $this->getAccessToken(), 'venture-key' => $this->getVenture()],
                'exceptions' => false
            )
        );
    }

    /**
     * @param string $url
     * @param $body
     * @return \GuzzleHttp\Message\Response
     */
    protected function update($url, $body)
    {
        return $this->doRequest(
            'put',
            $url,
            array(
                'body' => json_encode($body),
                'headers' => ['venture-access-token' => $this->getAccessToken(), 'venture-key' => $this->getVenture()],
                'exceptions' => false
            )
        );
    }

    /**
     * @param string $method
     * @param string $url
     * @param array $options
     * @return \GuzzleHttp\Message\Response
     */
    protected function doRequest($method, $url, $options = array())
    {
        $message = sprintf(
            '%s REQUEST TO: %s -- OPTIONS %s',
            $this->getUniqueId(),
            $url,
            json_encode($options)
        );

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

        $response = $this->getClient()->$method($url, $options);

        $this->logResponse($response);

        if (!$this->isResponseOk($response)) {
            throw new \Iris\Exceptions\RetryMessage($response->getBody(), $response->getStatusCode());
        }

        return $response;
    }

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

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

    /**
     * @param \GuzzleHttp\Message\ResponseInterface $response
     * @return bool
     */
    protected function isResponseOk(\GuzzleHttp\Message\ResponseInterface $response)
    {
        return in_array($response->getStatusCode(), array(static::RESPONSE_OK, static::RESPONSE_OK_NO_BODY));
    }
}