Http::getRequestOptions() - Code Metrics - Inspection of "Update request options to exclude multipart when i..." - stevenmaguire/trello-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 070015...50a9e6 )

by Steven

created 2017-03-23 01:52 UTC

Http::getRequestOptions() A

↳ Parent: Http

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
ccs	7
cts	7
cp	1
rs	9.4285
cc	2
eloc	6
nc	2
nop	0
crap	2

<?php namespace Stevenmaguire\Services\Trello;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\ClientInterface as HttpClientInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\RequestInterface;

class Http
{
    /**
     * Multipart resources to include in next request.
     *
     * @var array
     */
    protected $multipartResources = [];

    /**
     * Http client
     *
     * @var HttpClientInterface
     */
    protected $httpClient;

    /**
     * Creates a new http broker.
     */
    public function __construct()
    {
        $this->httpClient = new HttpClient;
    }

    /**
     * Adds authentication credentials to given request.
     *
     * @param  RequestInterface  $request
     *
     * @return RequestInterface
     */
    protected function authenticateRequest(RequestInterface $request)
    {
        $uri = $request->getUri();
        parse_str($uri->getQuery(), $query);

        $query['key'] = Configuration::get('key');
        $query['token'] = Configuration::get('token');

        $uri = $uri->withQuery(http_build_query($query));

        return $request->withUri($uri);
    }

    /**
     * Creates a request.
     *
     * @param  string $verb
     * @param  string $path
     * @param  array  $parameters
     *
     * @return Request
     */
    protected function createRequest($verb, $path, $parameters = [])
    {
        if (isset($parameters['file'])) {
            $this->queueResourceAs(
                'file',
                \GuzzleHttp\Psr7\stream_for($parameters['file'])
            );
            unset($parameters['file']);
        }

        $request = new Request(
            $verb,
            $this->getUrlFromPath($path),
            $this->getHeaders()
        );

        return $request->withUri(
            $request->getUri()->withQuery(
                http_build_query($parameters)
            )
        );
    }

    /**
     * Retrieves http response for a request with the delete method.
     *
     * @param  string $path
     * @param  array  $parameters
     *
     * @return object
     */
    public function delete($path, $parameters = [])
    {
        $request = $this->getRequest('DELETE', $path, $parameters);

        return $this->sendRequest($request);
    }

    /**
     * Retrieves http response for a request with the get method.
     *
     * @param  string $path
     * @param  array  $parameters
     *
     * @return object
     */
    public function get($path, $parameters = [])
    {
        $request = $this->getRequest('GET', $path, $parameters);

        return $this->sendRequest($request);
    }

    /**
     * Creates and returns a request.
     *
     * @param  string $method
     * @param  string $path
     * @param  array  $parameters
     *
     * @return RequestInterface
     */
    public function getRequest($method, $path, $parameters = [], $authenticated = true)
    {
        $request = $this->createRequest($method, $path, $parameters);

        if ($authenticated) {
            $request = $this->authenticateRequest($request);
        }

        return $request;
    }

    /**
     * Retrieves default headers.
     *
     * @return array
     */
    protected function getHeaders()
    {
        return [];
    }

    /**
     * Prepares an array of important exception parts based on composition of a
     * given exception.
     *
     * @param  RequestException  $requestException
     *
     * @return array
     */
    private function getRequestExceptionParts(RequestException $requestException)
    {
        $response = $requestException->getResponse();
        $parts = [];
        $parts['reason'] = $response ? $response->getReasonPhrase() : $requestException->getMessage();
        $parts['code'] = $response ? $response->getStatusCode() : $requestException->getCode();
        $parts['body'] = $response ? $response->getBody() : null;

        return $parts;
    }

    /**
     * Creates an array of request options based on the current status of the
     * http client.
     *
     * @return array
     */
    protected function getRequestOptions()
    {
        $options = [
            'proxy' => Configuration::get('proxy')
        ];

        if (!empty(array_filter($this->multipartResources))) {
            $options['multipart'] = $this->multipartResources;
        }

        return $options;
    }

    /**
     * Creates fully qualified domain from given path.
     *
     * @param  string  $path
     *
     * @return string
     */
    protected function getUrlFromPath($path = '/')
    {
        return Configuration::get('domain').'/'.Configuration::get('version').'/'.ltrim($path, '/');
    }

    /**
     * Retrieves http response for a request with the post method.
     *
     * @param  string $path
     * @param  array  $parameters
     *
     * @return object
     */
    public function post($path, $parameters)
    {
        $request = $this->getRequest('POST', $path, $parameters);

        return $this->sendRequest($request);
    }

    /**
     * Retrieves http response for a request with the put method.
     *
     * @param  string $path
     * @param  array  $parameters
     *
     * @return object
     */
    public function put($path, $parameters)
    {
        $request = $this->getRequest('PUT', $path, $parameters);

        return $this->sendRequest($request);
    }

    /**
     * Adds a given resource to multipart stream collection, to be processed by next request.
     *
     * @param  string                                           $name
     * @param  resource|string|Psr\Http\Message\StreamInterface $resource
     *
     * @return void
     */
    protected function queueResourceAs($name, $resource)
    {
        array_push($this->multipartResources, [
            'name' => $name,
            'contents' => $resource,
        ]);
    }

    /**
     * Retrieves http response for a given request.
     *
     * @param  RequestInterface $request
     *
     * @return object
     * @throws Exceptions\Exception
     */
    protected function sendRequest(RequestInterface $request)
    {
        try {
            $response = $this->httpClient->send(
                $request,
                $this->getRequestOptions()
            );

            $this->multipartResources = [];

            return json_decode($response->getBody());
        } catch (RequestException $e) {
            $this->throwRequestException($e);
        }
    } // @codeCoverageIgnore

    /**
     * Updates the http client.
     *
     * @param HttpClientInterface  $httpClient
     *
     * @return Http
     */
    public function setClient(HttpClientInterface $httpClient)
    {
        $this->httpClient = $httpClient;

        return $this;
    }

    /**
     * Creates local exception from guzzle request exception, which includes
     * response body.
     *
     * @param  RequestException  $requestException
     *
     * @return void
     * @throws Exceptions\Exception
     */
    protected function throwRequestException(RequestException $requestException)
    {
        $exceptionParts = $this->getRequestExceptionParts($requestException);

        $exception = new Exceptions\Exception(
            $exceptionParts['reason'],
            $exceptionParts['code'],
            $requestException
        );

        $body = $exceptionParts['body'];
        $json = json_decode($body);

        if (json_last_error() == JSON_ERROR_NONE) {
            throw $exception->setResponseBody($json);
        }

        throw $exception->setResponseBody($body);
    }
}


1		<?php namespace Stevenmaguire\Services\Trello;
2
3		use GuzzleHttp\Client as HttpClient;
4		use GuzzleHttp\ClientInterface as HttpClientInterface;
5		use GuzzleHttp\Exception\RequestException;
6		use GuzzleHttp\Psr7\Request;
7		use Psr\Http\Message\RequestInterface;
8
9		class Http
10		{
11		/**
12		* Multipart resources to include in next request.
13		*
14		* @var array
15		*/
16		protected $multipartResources = [];
17
18		/**
19		* Http client
20		*
21		* @var HttpClientInterface
22		*/
23		protected $httpClient;
24
25		/**
26		* Creates a new http broker.
27		*/
28	688	public function __construct()
29		{
30	688	$this->httpClient = new HttpClient;
31	688	}
32
33		/**
34		* Adds authentication credentials to given request.
35		*
36		* @param RequestInterface $request
37		*
38		* @return RequestInterface
39		*/
40	668	protected function authenticateRequest(RequestInterface $request)
41		{
42	668	$uri = $request->getUri();
43	668	parse_str($uri->getQuery(), $query);
44
45	668	$query['key'] = Configuration::get('key');
46	668	$query['token'] = Configuration::get('token');
47
48	668	$uri = $uri->withQuery(http_build_query($query));
49
50	668	return $request->withUri($uri);
51		}
52
53		/**
54		* Creates a request.
55		*
56		* @param string $verb
57		* @param string $path
58		* @param array $parameters
59		*
60		* @return Request
61		*/
62	670	protected function createRequest($verb, $path, $parameters = [])
63		{
64	670	if (isset($parameters['file'])) {
65	4	$this->queueResourceAs(
66	2	'file',
67	2	\GuzzleHttp\Psr7\stream_for($parameters['file'])
68	2	);
69	2	unset($parameters['file']);
70	2	}
71
72	670	$request = new Request(
73	670	$verb,
74	670	$this->getUrlFromPath($path),
75	670	$this->getHeaders()
76	670	);
77
78	670	return $request->withUri(
79	670	$request->getUri()->withQuery(
80	670	http_build_query($parameters)
81	670	)
82	670	);
83		}
84
85		/**
86		* Retrieves http response for a request with the delete method.
87		*
88		* @param string $path
89		* @param array $parameters
90		*
91		* @return object
92		*/
93	60	public function delete($path, $parameters = [])
94		{
95	60	$request = $this->getRequest('DELETE', $path, $parameters);
96
97	60	return $this->sendRequest($request);
98		}
99
100		/**
101		* Retrieves http response for a request with the get method.
102		*
103		* @param string $path
104		* @param array $parameters
105		*
106		* @return object
107		*/
108	308	public function get($path, $parameters = [])
109		{
110	308	$request = $this->getRequest('GET', $path, $parameters);
111
112	308	return $this->sendRequest($request);
113		}
114
115		/**
116		* Creates and returns a request.
117		*
118		* @param string $method
119		* @param string $path
120		* @param array $parameters
121		*
122		* @return RequestInterface
123		*/
124	670	public function getRequest($method, $path, $parameters = [], $authenticated = true)
125		{
126	670	$request = $this->createRequest($method, $path, $parameters);
127
128	670	if ($authenticated) {
129	668	$request = $this->authenticateRequest($request);
130	668	}
131
132	670	return $request;
133		}
134
135		/**
136		* Retrieves default headers.
137		*
138		* @return array
139		*/
140	670	protected function getHeaders()
141		{
142	670	return [];
143		}
144
145		/**
146		* Prepares an array of important exception parts based on composition of a
147		* given exception.
148		*
149		* @param RequestException $requestException
150		*
151		* @return array
152		*/
153	8	private function getRequestExceptionParts(RequestException $requestException)
154		{
155	8	$response = $requestException->getResponse();
156	8	$parts = [];
157	8	$parts['reason'] = $response ? $response->getReasonPhrase() : $requestException->getMessage();
158	8	$parts['code'] = $response ? $response->getStatusCode() : $requestException->getCode();
159	8	$parts['body'] = $response ? $response->getBody() : null;
160
161	8	return $parts;
162		}
163
164		/**
165		* Creates an array of request options based on the current status of the
166		* http client.
167		*
168		* @return array
169		*/
170	666	protected function getRequestOptions()
171		{
172		$options = [
173	666	'proxy' => Configuration::get('proxy')
174	666	];
175
176	666	if (!empty(array_filter($this->multipartResources))) {
177	2	$options['multipart'] = $this->multipartResources;
178	2	}
179
180	666	return $options;
181		}
182
183		/**
184		* Creates fully qualified domain from given path.
185		*
186		* @param string $path
187		*
188		* @return string
189		*/
190	670	protected function getUrlFromPath($path = '/')
191		{
192	670	return Configuration::get('domain').'/'.Configuration::get('version').'/'.ltrim($path, '/');
193		}
194
195		/**
196		* Retrieves http response for a request with the post method.
197		*
198		* @param string $path
199		* @param array $parameters
200		*
201		* @return object
202		*/
203	82	public function post($path, $parameters)
204		{
205	82	$request = $this->getRequest('POST', $path, $parameters);
206
207	82	return $this->sendRequest($request);
208		}
209
210		/**
211		* Retrieves http response for a request with the put method.
212		*
213		* @param string $path
214		* @param array $parameters
215		*
216		* @return object
217		*/
218	216	public function put($path, $parameters)
219		{
220	216	$request = $this->getRequest('PUT', $path, $parameters);
221
222	216	return $this->sendRequest($request);
223		}
224
225		/**
226		* Adds a given resource to multipart stream collection, to be processed by next request.
227		*
228		* @param string $name
229		* @param resource\|string\|Psr\Http\Message\StreamInterface $resource
230		*
231		* @return void
232		*/
233	2	protected function queueResourceAs($name, $resource)
234		{
235	2	array_push($this->multipartResources, [
236	2	'name' => $name,
237	2	'contents' => $resource,
238	2	]);
239	2	}
240
241		/**
242		* Retrieves http response for a given request.
243		*
244		* @param RequestInterface $request
245		*
246		* @return object
247		* @throws Exceptions\Exception
248		*/
249	666	protected function sendRequest(RequestInterface $request)
250		{
251		try {
252	666	$response = $this->httpClient->send(
253	666	$request,
254	666	$this->getRequestOptions()
255	666	);
256
257	658	$this->multipartResources = [];
258
259	658	return json_decode($response->getBody());
260	8	} catch (RequestException $e) {
261	8	$this->throwRequestException($e);
262		}
263		} // @codeCoverageIgnore
264
265		/**
266		* Updates the http client.
267		*
268		* @param HttpClientInterface $httpClient
269		*
270		* @return Http
271		*/
272	666	public function setClient(HttpClientInterface $httpClient)
273		{
274	666	$this->httpClient = $httpClient;
275
276	666	return $this;
277		}
278
279		/**
280		* Creates local exception from guzzle request exception, which includes
281		* response body.
282		*
283		* @param RequestException $requestException
284		*
285		* @return void
286		* @throws Exceptions\Exception
287		*/
288	8	protected function throwRequestException(RequestException $requestException)
289		{
290	8	$exceptionParts = $this->getRequestExceptionParts($requestException);
291
292	8	$exception = new Exceptions\Exception(
293	8	$exceptionParts['reason'],
294	8	$exceptionParts['code'],
295		$requestException
296	8	);
297
298	8	$body = $exceptionParts['body'];
299	8	$json = json_decode($body);
300
301	8	if (json_last_error() == JSON_ERROR_NONE) {
302	6	throw $exception->setResponseBody($json);
303		}
304
305	2	throw $exception->setResponseBody($body);
306		}
307		}
308

stevenmaguire / trello-php

Push — master ( 070015...50a9e6 )

Http::getRequestOptions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like