Client::handleError() - Code Metrics - Inspection of "Bigger fixes" - lyal/checkr - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 2b935e...e07ba9 )

by Lyal

created 2017-10-30 21:53 UTC

Client::handleError() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php

namespace Lyal\Checkr;

use Guzzle\Http\Message\Response;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Exception\BadResponseException;
use Lyal\Checkr\Exceptions\UnknownResourceException;

class Client
{
    private $key;
    private $guzzle;
    private $options = [];

    private $lastResponse;

    public $useCollections = true;

    /**
     * Client constructor.
     *
     * @param string|null $key
     * @param array $options
     * @param GuzzleClient|null $guzzle
     */
    public function __construct($key = null, array $options = [], GuzzleClient $guzzle = null)
    {
        $this->setHttpClient($guzzle ?? new GuzzleClient());
        $this->setKey($key ?? env('checkr_api_key', null));
        $this->setOptions($options);
    }

    /**
     * @param GuzzleClient $client
     *
     * @return void
     */
    public function setHttpClient(GuzzleClient $client)
    {
        $this->guzzle = $client;
    }

    /**
     * @return mixed
     */
    public function getHttpClient()
    {
        return $this->guzzle;
    }

    /**
     * Fetch an API resource to handle the client request.
     *
     * @param string $name
     * @param array $args
     * @param \Lyal\Checkr\Entities\AbstractEntity $previousObject
     *
     * @throws UnknownResourceException
     *
     * @return mixed
     */
    public function api($name, $args, $previousObject = null)
    {
        // Autoload resource name using studly case
        if (!$className = checkrEntityClassName($name)) {
            throw new UnknownResourceException($name);
        }
        $args = count($args) ? $args[0] : $args;
        $entity = new $className($args, $this);
        if ($previousObject) {
            $entity->setPreviousObject($previousObject);
        }

        return $entity;
    }

    /**
     * Pass all unknown methods to api().
     *
     * @param $name
     * @param $args
     *
     * @return mixed
     */
    public function __call($name, $args)
    {
        return $this->api($name, $args);
    }

    /**
     * @param bool $status
     *
     * @return void
     */
    public function setLastResponse($response)
    {
        $this->lastResponse = $response;
    }

    /**
     * @return Response
     */
    public function getLastResponse()
    {
        return $this->lastResponse;
    }

    /**
     * Set a key for authentication with checkr.
     *
     * @param $key
     *
     * @return void
     */
    public function setKey($key)
    {
        $this->key = $key;
    }

    /**
     * Get the checkr api key.
     *
     * @return string|bool
     */
    public function getKey()
    {
        return $this->key ?: env('checkr_api_key', null);
    }

    /**
     * Set options for HttpClient.
     *
     * @param array $options
     *
     * @return array
     */
    public function setOptions(array $options) : array
    {
        return $this->options = $options;
    }

    /**
     * Set individual option.
     *
     * @param $key
     * @param $value
     *
     * @return mixed
     */
    public function setOption($key, $value)
    {
        return $this->options[$key] = $value;
    }

    /**
     * @return array
     */
    public function getOptions() : array
    {
        return $this->options;
    }

    /**
     * @param $key
     *
     * @return bool|mixed
     * @return void
     */
    public function getOption($key)
    {
        if (isset($this->options[$key])) {
            return $this->options[$key];
        }

        return false;
    }

    /**
     * Make a request through Guzzle.
     *
     * Note: $options in the parameters of this function is temporary; for Guzzle options
     * like debug, set them on the $client
     *
     * @param $method
     * @param $path
     * @param array $options
     * @param bool $returnResponse
     *
     * @throws \Lyal\Checkr\Exceptions\UnhandledRequestError
     * @throws \Lyal\Checkr\Exceptions\Client\Unauthorized
     * @throws \Lyal\Checkr\Exceptions\Client\NotFound
     * @throws \Lyal\Checkr\Exceptions\Client\InternalServerError
     * @throws \Lyal\Checkr\Exceptions\Client\Forbidden
     * @throws \Lyal\Checkr\Exceptions\Client\Conflict
     * @throws \Lyal\Checkr\Exceptions\Client\BadRequest
     *
     * @return mixed
     */
    public function request($method, $path, array $options = [])
    {
        $body = '';
        $options = array_merge($this->getOptions(), $options);
        $options['auth'] = [$this->getKey() . ':', ''];

        try {
            $response = $this->getHttpClient()->request($method, $this->getApiEndPoint() . $path, $options);
            $this->setLastResponse($response);
            $body = json_decode((string)$response->getBody());
        } catch (BadResponseException $exception) {
            $this->handleError($exception);
        }

        return $body;
    }

    /**
     * @return string
     */
    public function getApiEndPoint()
    {
        return 'https://api.checkr.com/v1/';
    }

    /**
     *  Throw our own custom handler for errors.
     *
     * @param BadResponseException $exception
     *
     * @throws \Lyal\Checkr\Exceptions\Client\BadRequest
     * @throws \Lyal\Checkr\Exceptions\Client\Unauthorized
     * @throws \Lyal\Checkr\Exceptions\Client\Forbidden
     * @throws \Lyal\Checkr\Exceptions\Client\NotFound
     * @throws \Lyal\Checkr\Exceptions\Client\Conflict
     * @throws \Lyal\Checkr\Exceptions\Server\InternalServerError
     * @throws \Lyal\Checkr\Exceptions\UnhandledRequestError
     */
    private function handleError(BadResponseException $exception)
    {
        $handler = new RequestErrorHandler($exception);
        $handler->handleError();
    }
}


1			<?php
2
3			namespace Lyal\Checkr;
4
5			use Guzzle\Http\Message\Response;
6			use GuzzleHttp\Client as GuzzleClient;
7			use GuzzleHttp\Exception\BadResponseException;
8			use Lyal\Checkr\Exceptions\UnknownResourceException;
9
10			class Client
11			{
12			private $key;
13			private $guzzle;
14			private $options = [];
15
16			private $lastResponse;
17
18			public $useCollections = true;
19
20			/**
21			* Client constructor.
22			*
23			* @param string\|null $key
24			* @param array $options
25			* @param GuzzleClient\|null $guzzle
26			*/
27			public function __construct($key = null, array $options = [], GuzzleClient $guzzle = null)
28			{
29			$this->setHttpClient($guzzle ?? new GuzzleClient());
30			$this->setKey($key ?? env('checkr_api_key', null));
31			$this->setOptions($options);
32			}
33
34			/**
35			* @param GuzzleClient $client
36			*
37			* @return void
38			*/
39			public function setHttpClient(GuzzleClient $client)
40			{
41			$this->guzzle = $client;
42			}
43
44			/**
45			* @return mixed
46			*/
47			public function getHttpClient()
48			{
49			return $this->guzzle;
50			}
51
52			/**
53			* Fetch an API resource to handle the client request.
54			*
55			* @param string $name
56			* @param array $args
57			* @param \Lyal\Checkr\Entities\AbstractEntity $previousObject
58			*
59			* @throws UnknownResourceException
60			*
61			* @return mixed
62			*/
63			public function api($name, $args, $previousObject = null)
64			{
65			// Autoload resource name using studly case
66			if (!$className = checkrEntityClassName($name)) {
67			throw new UnknownResourceException($name);
68			}
69			$args = count($args) ? $args[0] : $args;
70			$entity = new $className($args, $this);
71			if ($previousObject) {
72			$entity->setPreviousObject($previousObject);
73			}
74
75			return $entity;
76			}
77
78			/**
79			* Pass all unknown methods to api().
80			*
81			* @param $name
82			* @param $args
83			*
84			* @return mixed
85			*/
86			public function __call($name, $args)
87			{
88			return $this->api($name, $args);
89			}
90
91			/**
92			* @param bool $status
93			*
94			* @return void
95			*/
96			public function setLastResponse($response)
97			{
98			$this->lastResponse = $response;
99			}
100
101			/**
102			* @return Response
103			*/
104			public function getLastResponse()
105			{
106			return $this->lastResponse;
107			}
108
109			/**
110			* Set a key for authentication with checkr.
111			*
112			* @param $key
113			*
114			* @return void
115			*/
116			public function setKey($key)
117			{
118			$this->key = $key;
119			}
120
121			/**
122			* Get the checkr api key.
123			*
124			* @return string\|bool
125			*/
126			public function getKey()
127			{
128			return $this->key ?: env('checkr_api_key', null);
129			}
130
131			/**
132			* Set options for HttpClient.
133			*
134			* @param array $options
135			*
136			* @return array
137			*/
138			public function setOptions(array $options) : array
139			{
140			return $this->options = $options;
141			}
142
143			/**
144			* Set individual option.
145			*
146			* @param $key
147			* @param $value
148			*
149			* @return mixed
150			*/
151			public function setOption($key, $value)
152			{
153			return $this->options[$key] = $value;
154			}
155
156			/**
157			* @return array
158			*/
159			public function getOptions() : array
160			{
161			return $this->options;
162			}
163
164			/**
165			* @param $key
166			*
167			* @return bool\|mixed
168			* @return void
169			*/
170			public function getOption($key)
171			{
172			if (isset($this->options[$key])) {
173			return $this->options[$key];
174			}
175
176			return false;
177			}
178
179			/**
180			* Make a request through Guzzle.
181			*
182			* Note: $options in the parameters of this function is temporary; for Guzzle options
183			* like debug, set them on the $client
184			*
185			* @param $method
186			* @param $path
187			* @param array $options
188			* @param bool $returnResponse
189			*
190			* @throws \Lyal\Checkr\Exceptions\UnhandledRequestError
191			* @throws \Lyal\Checkr\Exceptions\Client\Unauthorized
192			* @throws \Lyal\Checkr\Exceptions\Client\NotFound
193			* @throws \Lyal\Checkr\Exceptions\Client\InternalServerError
194			* @throws \Lyal\Checkr\Exceptions\Client\Forbidden
195			* @throws \Lyal\Checkr\Exceptions\Client\Conflict
196			* @throws \Lyal\Checkr\Exceptions\Client\BadRequest
197			*
198			* @return mixed
199			*/
200			public function request($method, $path, array $options = [])
201			{
202			$body = '';
203			$options = array_merge($this->getOptions(), $options);
204			$options['auth'] = [$this->getKey() . ':', ''];
205
206			try {
207			$response = $this->getHttpClient()->request($method, $this->getApiEndPoint() . $path, $options);
208			$this->setLastResponse($response);
209			$body = json_decode((string)$response->getBody());
210			} catch (BadResponseException $exception) {
211			$this->handleError($exception);
212			}
213
214			return $body;
215			}
216
217			/**
218			* @return string
219			*/
220			public function getApiEndPoint()
221			{
222			return 'https://api.checkr.com/v1/';
223			}
224
225			/**
226			* Throw our own custom handler for errors.
227			*
228			* @param BadResponseException $exception
229			*
230			* @throws \Lyal\Checkr\Exceptions\Client\BadRequest
231			* @throws \Lyal\Checkr\Exceptions\Client\Unauthorized
232			* @throws \Lyal\Checkr\Exceptions\Client\Forbidden
233			* @throws \Lyal\Checkr\Exceptions\Client\NotFound
234			* @throws \Lyal\Checkr\Exceptions\Client\Conflict
235			* @throws \Lyal\Checkr\Exceptions\Server\InternalServerError
236			* @throws \Lyal\Checkr\Exceptions\UnhandledRequestError
237			*/
238			private function handleError(BadResponseException $exception)
239			{
240			$handler = new RequestErrorHandler($exception);
241			$handler->handleError();
242			}
243			}
244

lyal / checkr

Push — master ( 2b935e...e07ba9 )

Client::handleError() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like