Http::putAsBody() - Code Metrics - Inspection of "Update updateCardCustomField to handle params as b..." - stevenmaguire/trello-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 993800...e13cda )

by Steven

created 2018-03-27 13:43 UTC

Http::putAsBody() A

↳ Parent: Http

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

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

<?php namespace Stevenmaguire\Services\Trello;

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

class Http
{
    const HTTP_DELETE = 'DELETE';
    const HTTP_GET = 'GET';
    const HTTP_POST = 'POST';
    const HTTP_PUT = 'PUT';

    /**
     * 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',
                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(static::HTTP_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(static::HTTP_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(static::HTTP_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(static::HTTP_PUT, $path, $parameters);

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

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

stevenmaguire / trello-php

Push — master ( 993800...e13cda )

Http::putAsBody() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like