AbstractRequest::requestPut() - Code Metrics - Inspection of "Code refactor of request and transformations" - cct-marketing/Rest - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 312ccc...32eec2 )

by Paul

created 2018-03-28 19:49 UTC

AbstractRequest::requestPut() A

↳ Parent: AbstractRequest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	3
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace CCT\Component\Rest\Http;

use CCT\Component\Rest\Config;
use CCT\Component\Rest\Exception\InvalidParameterException;
use CCT\Component\Rest\Exception\ServiceUnavailableException;
use CCT\Component\Rest\Http\Definition\QueryParams;
use CCT\Component\Rest\Http\Definition\RequestHeaders;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Exception\RequestException;
use Psr\Http\Message\ResponseInterface as PsrResponseInterface;

abstract class AbstractRequest implements RequestInterface
{
    /**
     * @var GuzzleClient
     */
    protected $client;

    /**
     * Request headers
     *
     * @var RequestHeaders
     */
    protected $headers;

    /**
     * The name of the response class used to
     * @var Config
     */
    protected $config;

    /**
     * AbstractRequest constructor.
     *
     * @param GuzzleClient $client
     * @param Config $config
     */
    public function __construct(GuzzleClient $client, Config $config)
    {
        $this->client = $client;
        $this->config = $config;

        $this->setUp();
    }

    /**
     * @param string $uri
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function requestGet($uri, QueryParams $queryParams = null)
    {
        return $this->execute(self::METHOD_GET, $uri, [], $queryParams);
    }

    /**
     * @param string $uri
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function requestDelete($uri, QueryParams $queryParams = null)
    {
        return $this->execute(self::METHOD_DELETE, $uri, [], $queryParams);
    }

    /**
     * @param string $uri
     * @param array|object $formData
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function requestPost($uri, $formData, QueryParams $queryParams = null)
    {
        return $this->execute(self::METHOD_POST, $uri, $formData, $queryParams);
    }

    /**
     * @param string $uri
     * @param array|object $formData
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function requestPatch($uri, $formData, QueryParams $queryParams = null)
    {
        return $this->execute(self::METHOD_PATCH, $uri, $formData, $queryParams);
    }

    /**
     * @param string $uri
     * @param array|object $formData
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function requestPut($uri, $formData, QueryParams $queryParams = null)
    {
        return $this->execute(self::METHOD_PUT, $uri, $formData, $queryParams);
    }

    /**
     * @param string $method
     * @param string $uri
     * @param array|object $formData
     * @param QueryParams|null $queryParams
     *
     * @return ResponseInterface|\Symfony\Component\HttpFoundation\Response
     */
    protected function execute($method, string $uri, $formData = [], QueryParams $queryParams = null)
    {
        $options = $this->getRequestOptions($formData, $queryParams);

        $response = $this->sendRequest($method, $uri, $options);

        return $this->createResponseRefFromResponse($response);
    }

    /**
     * @param array|object $formData
     * @param QueryParams|null $queryParams
     *
     * @return array
     */
    protected function getRequestOptions($formData = [], QueryParams $queryParams = null)
    {
        return [
            'form_params' => $formData,
            'headers' => $this->getHeaders()->toArray(),
            'query' => $queryParams !== null ? $queryParams->toArray() : []
        ];
    }

    /**
     * @param string $method
     * @param string $uri
     * @param array $options
     *
     * @throws ServiceUnavailableException
     *
     * @return PsrResponseInterface|object
     */
    protected function sendRequest($method, string $uri, $options = [])
    {
        try {
            $response = $this->client->request($method, $uri, $options);
        } catch (ConnectException $e) {
            throw new ServiceUnavailableException($e->getRequest(), $e->getMessage());
        } catch (RequestException $e) {
            if (null === $e->getResponse()->getBody()) {
                throw $e;
            }
            $response = $e->getResponse();
        }

        return $response;
    }

    /**
     * Set headers for request
     *
     * @param RequestHeaders $headers
     */
    protected function setHeaders(RequestHeaders $headers)
    {
        $this->headers = $headers;
    }

    /**
     * Get headers for request
     *
     * @return RequestHeaders
     */
    protected function getHeaders(): RequestHeaders
    {
        return $this->headers;
    }

    /**
     * Create Response reflection from a response
     *
     * @param PsrResponseInterface $response
     *
     * @return ResponseInterface|object
     */
    protected function createResponseRefFromResponse(PsrResponseInterface $response)
    {
        $responseRef = $this->createResponseReflectionInstance();

        return $responseRef->newInstance(
            $response->getBody()->getContents(),
            $response->getStatusCode(),
            $response->getHeaders()
        );
    }

    /**
     * Creates a Reflection Response class.
     *
     * @return \ReflectionClass
     */
    private function createResponseReflectionInstance(): \ReflectionClass
    {
        $responseClass = $this->config->get(Config::RESPONSE_CLASS, Response::class);
        $responseRef = new \ReflectionClass($responseClass);

        if (!$responseRef->implementsInterface(ResponseInterface::class)) {
            throw new InvalidParameterException(sprintf(
                'The response class must be an implementation of %s',
                ResponseInterface::class
            ));
        }

        return $responseRef;
    }

    /**
     * @return string|null
     */
    public function getUri()
    {
        return $this->config->get(Config::URI_PREFIX, '/');
    }

    /**
     * Initialization of the request.
     *
     * @return void
     */
    abstract protected function setUp();
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace CCT\Component\Rest\Http;
6
7		use CCT\Component\Rest\Config;
8		use CCT\Component\Rest\Exception\InvalidParameterException;
9		use CCT\Component\Rest\Exception\ServiceUnavailableException;
10		use CCT\Component\Rest\Http\Definition\QueryParams;
11		use CCT\Component\Rest\Http\Definition\RequestHeaders;
12		use GuzzleHttp\Client as GuzzleClient;
13		use GuzzleHttp\Exception\ConnectException;
14		use GuzzleHttp\Exception\RequestException;
15		use Psr\Http\Message\ResponseInterface as PsrResponseInterface;
16
17		abstract class AbstractRequest implements RequestInterface
18		{
19		/**
20		* @var GuzzleClient
21		*/
22		protected $client;
23
24		/**
25		* Request headers
26		*
27		* @var RequestHeaders
28		*/
29		protected $headers;
30
31		/**
32		* The name of the response class used to
33		* @var Config
34		*/
35		protected $config;
36
37		/**
38		* AbstractRequest constructor.
39		*
40		* @param GuzzleClient $client
41		* @param Config $config
42		*/
43	4	public function __construct(GuzzleClient $client, Config $config)
44		{
45	4	$this->client = $client;
46	4	$this->config = $config;
47
48	4	$this->setUp();
49	4	}
50
51		/**
52		* @param string $uri
53		* @param QueryParams\|null $queryParams
54		*
55		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
56		*/
57	3	protected function requestGet($uri, QueryParams $queryParams = null)
58		{
59	3	return $this->execute(self::METHOD_GET, $uri, [], $queryParams);
60		}
61
62		/**
63		* @param string $uri
64		* @param QueryParams\|null $queryParams
65		*
66		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
67		*/
68		protected function requestDelete($uri, QueryParams $queryParams = null)
69		{
70		return $this->execute(self::METHOD_DELETE, $uri, [], $queryParams);
71		}
72
73		/**
74		* @param string $uri
75		* @param array\|object $formData
76		* @param QueryParams\|null $queryParams
77		*
78		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
79		*/
80		protected function requestPost($uri, $formData, QueryParams $queryParams = null)
81		{
82		return $this->execute(self::METHOD_POST, $uri, $formData, $queryParams);
83		}
84
85		/**
86		* @param string $uri
87		* @param array\|object $formData
88		* @param QueryParams\|null $queryParams
89		*
90		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
91		*/
92		protected function requestPatch($uri, $formData, QueryParams $queryParams = null)
93		{
94		return $this->execute(self::METHOD_PATCH, $uri, $formData, $queryParams);
95		}
96
97		/**
98		* @param string $uri
99		* @param array\|object $formData
100		* @param QueryParams\|null $queryParams
101		*
102		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
103		*/
104		protected function requestPut($uri, $formData, QueryParams $queryParams = null)
105		{
106		return $this->execute(self::METHOD_PUT, $uri, $formData, $queryParams);
107		}
108
109		/**
110		* @param string $method
111		* @param string $uri
112		* @param array\|object $formData
113		* @param QueryParams\|null $queryParams
114		*
115		* @return ResponseInterface\|\Symfony\Component\HttpFoundation\Response
116		*/
117	3	protected function execute($method, string $uri, $formData = [], QueryParams $queryParams = null)
118		{
119	3	$options = $this->getRequestOptions($formData, $queryParams);
120
121	3	$response = $this->sendRequest($method, $uri, $options);
122
123	3	return $this->createResponseRefFromResponse($response);
124		}
125
126		/**
127		* @param array\|object $formData
128		* @param QueryParams\|null $queryParams
129		*
130		* @return array
131		*/
132	3	protected function getRequestOptions($formData = [], QueryParams $queryParams = null)
133		{
134		return [
135	3	'form_params' => $formData,
136	3	'headers' => $this->getHeaders()->toArray(),
137		'query' => $queryParams !== null ? $queryParams->toArray() : []
138		];
139		}
140
141		/**
142		* @param string $method
143		* @param string $uri
144		* @param array $options
145		*
146		* @throws ServiceUnavailableException
147		*
148		* @return PsrResponseInterface\|object
149		*/
150	3	protected function sendRequest($method, string $uri, $options = [])
151		{
152		try {
153	3	$response = $this->client->request($method, $uri, $options);
154		} catch (ConnectException $e) {
155		throw new ServiceUnavailableException($e->getRequest(), $e->getMessage());
156		} catch (RequestException $e) {
157		if (null === $e->getResponse()->getBody()) {
158		throw $e;
159		}
160		$response = $e->getResponse();
161		}
162
163	3	return $response;
164		}
165
166		/**
167		* Set headers for request
168		*
169		* @param RequestHeaders $headers
170		*/
171	3	protected function setHeaders(RequestHeaders $headers)
172		{
173	3	$this->headers = $headers;
174	3	}
175
176		/**
177		* Get headers for request
178		*
179		* @return RequestHeaders
180		*/
181	3	protected function getHeaders(): RequestHeaders
182		{
183	3	return $this->headers;
184		}
185
186		/**
187		* Create Response reflection from a response
188		*
189		* @param PsrResponseInterface $response
190		*
191		* @return ResponseInterface\|object
192		*/
193	3	protected function createResponseRefFromResponse(PsrResponseInterface $response)
194		{
195	3	$responseRef = $this->createResponseReflectionInstance();
196
197	3	return $responseRef->newInstance(
198	3	$response->getBody()->getContents(),
199	3	$response->getStatusCode(),
200	3	$response->getHeaders()
201		);
202		}
203
204		/**
205		* Creates a Reflection Response class.
206		*
207		* @return \ReflectionClass
208		*/
209	3	private function createResponseReflectionInstance(): \ReflectionClass
210		{
211	3	$responseClass = $this->config->get(Config::RESPONSE_CLASS, Response::class);
212	3	$responseRef = new \ReflectionClass($responseClass);
213
214	3	if (!$responseRef->implementsInterface(ResponseInterface::class)) {
215		throw new InvalidParameterException(sprintf(
216		'The response class must be an implementation of %s',
217		ResponseInterface::class
218		));
219		}
220
221	3	return $responseRef;
222		}
223
224		/**
225		* @return string\|null
226		*/
227	3	public function getUri()
228		{
229	3	return $this->config->get(Config::URI_PREFIX, '/');
230		}
231
232		/**
233		* Initialization of the request.
234		*
235		* @return void
236		*/
237		abstract protected function setUp();
238		}
239

cct-marketing / Rest

Push — master ( 312ccc...32eec2 )

AbstractRequest::requestPut() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like