ApiClient::getClient() - Code Metrics - Inspection of "Moving to GFG repo" - GFG/hek - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 01baf6...9ed857 )

by Vitor de

created 2016-03-28 19:44 UTC

ApiClient::getClient() B

↳ Parent: ApiClient

Complexity

Conditions	3
Paths	3

Size

Total Lines	26
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	26
ccs	16
cts	16
cp	1
rs	8.8571
cc	3
eloc	14
nc	3
nop	0
crap	3

<?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;

        return $this;
    }
}


1		<?php
2
3		namespace GFG\Hek;
4
5		use GuzzleHttp\Client as HttpClient;
6		use GuzzleHttp\Exception\RequestException;
7
8		class ApiClient
9		{
10		const RESPONSE_OK = 200;
11		const RESPONSE_OK_NO_BODY = 204;
12
13		/**
14		* @var \GuzzleHttp\Client
15		*/
16		private $client;
17
18		/**
19		* @var string
20		*/
21		private $uniqueId;
22
23		/**
24		* @var \Hek\Interfaces\Configuration
25		*/
26		private $configuration;
27
28		/**
29		* @var \Psr\Log\LoggerInterface
30		*/
31		private $logger;
32
33		/**
34		* @param Interfaces\Configuration $configuration
35		* @param \Psr\Log\LoggerInterface $logger
36		*/
37	8	public function __construct(
38		Interfaces\Configuration $configuration,
39		\Psr\Log\LoggerInterface $logger
40		) {
41	8	$this->uniqueId = $this->getUniqueId();
42	8	$this->logger = $logger;
43
44	8	$this->setConfiguration($configuration);
45	8	}
46
47		/**
48		* @param $client
49		* @return Client
50		*/
51	4	public function setClient($client)
52		{
53	4	$this->client = $client;
54	4	return $this;
55		}
56
57		/**
58		* @return string
59		*/
60	8	public function getUniqueId()
61		{
62	8	if (!$this->uniqueId) {
63	8	$this->uniqueId = uniqid();
64	8	}
65
66	8	return $this->uniqueId;
67		}
68
69		/**
70		* @param string $uniqueId
71		* @return Client
72		*/
73	4	public function setUniqueId($uniqueId)
74		{
75	4	$this->uniqueId = $uniqueId;
76	4	return $this;
77		}
78
79		/**
80		* @return \GuzzleHttp\Client
81		*/
82	6	public function getClient()
83		{
84	6	if (!$this->client) {
85
86		// http authentication
87	2	$auth = [];
88	2	if ($this->getConfiguration()->getHttpUser()) {
89		$auth = [
90		'auth' => [
91	1	$this->getConfiguration()->getHttpUser(),
92	1	$this->getConfiguration()->getHttpPass()
93	1	]
94	1	];
95	1	}
96
97	2	$this->client = new HttpClient(array_merge($auth, [
98	2	'base_uri' => $this->getConfiguration()->getBaseUrl(),
99		'headers' => [
100	2	'Accept' => 'application/json',
101		'Content-Type' => 'application/json'
102	2	]
103	2	]));
104	2	}
105
106	6	return $this->client;
107		}
108
109		/**
110		* @param Interfaces\Context $context
111		* @return void
112		*/
113	3	public function execute(Interfaces\Context $context)
114		{
115		try {
116	3	$configuration = $this->getConfiguration();
117	3	$contextUrl = $context->getUrl();
118	3	$url = $contextUrl->getFullUrl();
119
120		$options = [
121	3	'body' => json_encode($context->exportContextData()),
122		'headers' => [
123	3	'access-token' => $configuration->getAccessToken(),
124	3	'user-key' => $configuration->getUserKey()
125	3	],
126		'exceptions' => false
127	3	];
128
129
130	3	$this->logRequest($url, $options);
131
132	3	$response = $this->getClient()
133	3	->{$context->getHttpMethod()}($url, $options);
134
135	2	$this->checkResponse($response);
136	1	$this->logResponse($response);
137
138	3	} catch (\Exception $e) {
139
140	2	$message = "Unable to execute context {$context->getName()}" .
141	2	" ( Exception message: {$e->getMessage()})";
142
143	2	$this->logger->error($message, $context->exportContextData());
144
145	2	$retryMessage = 'Try Again';
146	2	$code = 500;
147
148	2	if ($e instanceof \GuzzleHttp\Exception\RequestException) {
149	1	$this->logResponse($e->getResponse());
150
151	1	$retryMessage = $e->getResponse()->getBody();
152	1	$code = $e->getResponse()->getStatusCode();
153	1	}
154
155	2	throw new Exceptions\RetryMessage($retryMessage, $code);
156		}
157	1	}
158
159		/**
160		* @param string $url
161		* @param array $options
162		* @return void
163		*/
164	3	private function logRequest($url, $options)
165		{
166	3	$message = sprintf(
167	3	'%s REQUEST TO: %s -- OPTIONS %s',
168	3	$this->getUniqueId(),
169	3	$url,
170	3	json_encode($options)
171	3	);
172
173	3	$this->logger->info($message);
174	3	}
175
176		/**
177		* @param \GuzzleHttp\Message\ResponseInterface $response
178		* @return void
179		*/
180	2	private function logResponse(
181		\Psr\Http\Message\ResponseInterface $response
182		) {
183	2	$message = sprintf(
184	2	'%s RESPONSE: -- HTTP CODE %s -- BODY %s',
185	2	$this->getUniqueId(),
186	2	$response->getStatusCode(),
187	2	$response->getBody()
188	2	);
189
190	2	$this->logger->info($message);
191	2	}
192
193		/**
194		* @param \GuzzleHttp\Message\ResponseInterface $response
195		* @return bool
196		*/
197	2	private function checkResponse(
198		\Psr\Http\Message\ResponseInterface $response
199		) {
200	2	if (!in_array(
201	2	$response->getStatusCode(),
202	2	array(static::RESPONSE_OK, static::RESPONSE_OK_NO_BODY)
203	2	)) {
204	1	throw new Exceptions\RetryMessage(
205	1	$response->getBody(),
206	1	$response->getStatusCode()
207	1	);
208		}
209	1	}
210
211		/**
212		* Gets the value of configuration
213		*
214		* @return Interfaces\Configuration
215		*/
216	5	public function getConfiguration()
217		{
218	5	return $this->configuration;
219		}
220
221		/**
222		* Sets the value of Configuration
223		*
224		* @param Interfaces\Configuration $configuration
225		* @return Client
226		*/
227	8	public function setConfiguration(Interfaces\Configuration $configuration)
228		{
229	8	$this->configuration = $configuration;
		0 ignored issues – show Documentation Bug introduced 2016-03-28 19:48 UTC by Report Bug Copy Issue Report It seems like `$configuration` of type `object<GFG\Hek\Interfaces\Configuration>` is incompatible with the declared type `object<Hek\Interfaces\Configuration>` of property `$configuration`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
230	8	return $this;
231		}
232		}
233

GFG / hek

Push — master ( 01baf6...9ed857 )

ApiClient::getClient() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like