Client::__construct() - Code Metrics - stevenmaguire/uber-php - Measure and Improve Code Quality continuously with Scrutinizer

Client::__construct() A
last analyzed 2017-08-24 02:53 UTC

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

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

<?php namespace Stevenmaguire\Uber;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\ClientException as HttpClientException;
use GuzzleHttp\Psr7\Response;
use ReflectionClass;

class Client
{
    use GetSetTrait;
    use Resources\Drivers;
    use Resources\Estimates;
    use Resources\Products;
    use Resources\Promotions;
    use Resources\Reminders;
    use Resources\Requests;
    use Resources\Riders;

    /**
     * Access token
     *
     * @var string
     */
    private $access_token;

    /**
     * Server token
     *
     * @var string
     */
    private $server_token;

    /**
     * Use sandbox API
     *
     * @var bool
     */
    private $use_sandbox;

    /**
     * Version
     *
     * @var string
     */
    private $version;

    /**
     * Locale
     *
     * @var string
     */
    private $locale;

    /**
     * Rate limit
     *
     * @var RateLimit
     */
    private $rate_limit = null;

    /**
     * Http client
     *
     * @var HttpClient
     */
    private $httpClient;

    /**
     * Creates a new client.
     *
     * @param    array    $configuration
     */
    public function __construct($configuration = [])
    {
        $configuration = $this->parseConfiguration($configuration);
        $this->applyConfiguration($configuration);
        $this->httpClient = new HttpClient;
    }

    /**
     * Applies configuration to client.
     *
     * @param   array     $configuration
     *
     * @return  void
     */
    private function applyConfiguration($configuration = [])
    {
        array_walk($configuration, function ($value, $key) {
            $this->updateAttribute($key, $value);
        });
    }

    /**
     * Gets authorization header value.
     *
     * @return   string
     */
    private function getAuthorizationHeader()
    {
        if ($this->access_token) {
            return 'Bearer '.$this->access_token;
        }

        return 'Token '.$this->server_token;
    }

    /**
     * Gets HttpClient config for verb and parameters.
     *
     * @param    string   $verb
     * @param    array    $parameters
     *
     * @return   array
     */
    private function getConfigForVerbAndParameters($verb, $parameters = [])
    {
        $config = [
            'headers' => $this->getHeaders()
        ];

        if (!empty($parameters)) {
            if (strtolower($verb) == 'get') {
                $config['query'] = $parameters;
            } else {
                $config['json'] = $parameters;
            }
        }

        return $config;
    }

    /**
     * Gets headers for request.
     *
     * @return   array
     */
    public function getHeaders()
    {
        return [
            'Authorization' => trim($this->getAuthorizationHeader()),
            'Accept-Language' => trim($this->locale),
        ];
    }

    /**
     * Builds url from path.
     *
     * @param    string   $path
     *
     * @return   string   Url
     */
    public function getUrlFromPath($path)
    {
        $path = ltrim($path, '/');

        $host = 'https://'.($this->use_sandbox ? 'sandbox-' : '').'api.uber.com';

        return $host.($this->version ? '/'.$this->version : '').'/'.$path;
    }

    /**
     * Handles http client exceptions.
     *
     * @param    HttpClientException $e
     *
     * @return   void
     * @throws   Exception
     */
    private function handleRequestException(HttpClientException $e)
    {
        if ($response = $e->getResponse()) {
            $exception = new Exception($response->getReasonPhrase(), $response->getStatusCode(), $e);
            $exception->setBody(json_decode($response->getBody()));

            throw $exception;
        }

        throw new Exception($e->getMessage(), 500, $e);
    }

    /**
     * Parses configuration using defaults.
     *
     * @param    array    $configuration
     *
     * @return   array    $configuration
     */
    private function parseConfiguration($configuration = [])
    {
        $defaults = array(
            'access_token'  =>  null,
            'server_token'  =>  null,
            'use_sandbox'   =>  false,
            'version'   =>  'v1.2',
            'locale'    => 'en_US',
        );

        return array_merge($defaults, $configuration);
    }

    /**
     * Attempts to pull rate limit headers from response and add to client.
     *
     * @param    Response $response
     *
     * @return   void
     */
    private function parseRateLimitFromResponse(Response $response)
    {
        $rateLimitHeaders = array_filter([
            $response->getHeader('X-Rate-Limit-Limit'),
            $response->getHeader('X-Rate-Limit-Remaining'),
            $response->getHeader('X-Rate-Limit-Reset')
        ]);

        if (count($rateLimitHeaders) == 3) {
            $rateLimitClass = new ReflectionClass(RateLimit::class);
            $this->rate_limit = $rateLimitClass->newInstanceArgs($rateLimitHeaders);
        }
    }

    /**
     * Makes a request to the Uber API and returns the response.
     *
     * @param    string   $verb       The Http verb to use
     * @param    string   $path       The path of the APi after the domain
     * @param    array    $parameters Parameters
     *
     * @return   stdClass             The JSON response from the request
     * @throws   Exception
     */
    protected function request($verb, $path, $parameters = [])
    {
        $client = $this->httpClient;
        $url = $this->getUrlFromPath($path);
        $verb = strtolower($verb);
        $config = $this->getConfigForVerbAndParameters($verb, $parameters);

        try {
            $response = $client->$verb($url, $config);
        } catch (HttpClientException $e) {
            $this->handleRequestException($e);
        }

        $this->parseRateLimitFromResponse($response);

        return json_decode($response->getBody());
    }

    /**
     * Sets Http Client.
     *
     * @param    HttpClient  $client
     *
     * @return   Client
     */
    public function setHttpClient(HttpClient $client)
    {
        $this->httpClient = $client;
        return $this;
    }

    /**
     * Throws exception when client is not configured sandbox use. Should only
     * be utilized when attempting to do work against ephemeral sandbox API
     * data.
     *
     * @return   void
     * @throws   Exception
     *
     * @see      https://developer.uber.com/docs/riders/guides/sandbox
     */
    private function enforceSandboxExpectation($message = null)
    {
        if (!$this->use_sandbox) {
            $message = $message ?: 'Attempted to invoke sandbox functionality '.
                'with production client; this is not recommended';
            throw new Exception($message);
        }
    }
}


1		<?php namespace Stevenmaguire\Uber;
2
3		use GuzzleHttp\Client as HttpClient;
4		use GuzzleHttp\Exception\ClientException as HttpClientException;
5		use GuzzleHttp\Psr7\Response;
6		use ReflectionClass;
7
8		class Client
9		{
10		use GetSetTrait;
11		use Resources\Drivers;
12		use Resources\Estimates;
13		use Resources\Products;
14		use Resources\Promotions;
15		use Resources\Reminders;
16		use Resources\Requests;
17		use Resources\Riders;
18
19		/**
20		* Access token
21		*
22		* @var string
23		*/
24		private $access_token;
25
26		/**
27		* Server token
28		*
29		* @var string
30		*/
31		private $server_token;
32
33		/**
34		* Use sandbox API
35		*
36		* @var bool
37		*/
38		private $use_sandbox;
39
40		/**
41		* Version
42		*
43		* @var string
44		*/
45		private $version;
46
47		/**
48		* Locale
49		*
50		* @var string
51		*/
52		private $locale;
53
54		/**
55		* Rate limit
56		*
57		* @var RateLimit
58		*/
59		private $rate_limit = null;
60
61		/**
62		* Http client
63		*
64		* @var HttpClient
65		*/
66		private $httpClient;
67
68		/**
69		* Creates a new client.
70		*
71		* @param array $configuration
72		*/
73	100	public function __construct($configuration = [])
74		{
75	100	$configuration = $this->parseConfiguration($configuration);
76	100	$this->applyConfiguration($configuration);
77	100	$this->httpClient = new HttpClient;
78	100	}
79
80		/**
81		* Applies configuration to client.
82		*
83		* @param array $configuration
84		*
85		* @return void
86		*/
87		private function applyConfiguration($configuration = [])
88		{
89	100	array_walk($configuration, function ($value, $key) {
90	100	$this->updateAttribute($key, $value);
91	100	});
92	100	}
93
94		/**
95		* Gets authorization header value.
96		*
97		* @return string
98		*/
99	78	private function getAuthorizationHeader()
100		{
101	78	if ($this->access_token) {
102	2	return 'Bearer '.$this->access_token;
103		}
104
105	76	return 'Token '.$this->server_token;
106		}
107
108		/**
109		* Gets HttpClient config for verb and parameters.
110		*
111		* @param string $verb
112		* @param array $parameters
113		*
114		* @return array
115		*/
116	68	private function getConfigForVerbAndParameters($verb, $parameters = [])
117		{
118		$config = [
119	68	'headers' => $this->getHeaders()
120	34	];
121
122	68	if (!empty($parameters)) {
123	34	if (strtolower($verb) == 'get') {
124	14	$config['query'] = $parameters;
125	7	} else {
126	20	$config['json'] = $parameters;
127		}
128	17	}
129
130	68	return $config;
131		}
132
133		/**
134		* Gets headers for request.
135		*
136		* @return array
137		*/
138	78	public function getHeaders()
139		{
140		return [
141	78	'Authorization' => trim($this->getAuthorizationHeader()),
142	78	'Accept-Language' => trim($this->locale),
143	39	];
144		}
145
146		/**
147		* Builds url from path.
148		*
149		* @param string $path
150		*
151		* @return string Url
152		*/
153	72	public function getUrlFromPath($path)
154		{
155	72	$path = ltrim($path, '/');
156
157	72	$host = 'https://'.($this->use_sandbox ? 'sandbox-' : '').'api.uber.com';
158
159	72	return $host.($this->version ? '/'.$this->version : '').'/'.$path;
160		}
161
162		/**
163		* Handles http client exceptions.
164		*
165		* @param HttpClientException $e
166		*
167		* @return void
168		* @throws Exception
169		*/
170	6	private function handleRequestException(HttpClientException $e)
171		{
172	6	if ($response = $e->getResponse()) {
173	4	$exception = new Exception($response->getReasonPhrase(), $response->getStatusCode(), $e);
174	4	$exception->setBody(json_decode($response->getBody()));
175
176	4	throw $exception;
177		}
178
179	2	throw new Exception($e->getMessage(), 500, $e);
180		}
181
182		/**
183		* Parses configuration using defaults.
184		*
185		* @param array $configuration
186		*
187		* @return array $configuration
188		*/
189	100	private function parseConfiguration($configuration = [])
190		{
191		$defaults = array(
192	100	'access_token' => null,
193	50	'server_token' => null,
194	50	'use_sandbox' => false,
195	50	'version' => 'v1.2',
196	50	'locale' => 'en_US',
197	50	);
198
199	100	return array_merge($defaults, $configuration);
200		}
201
202		/**
203		* Attempts to pull rate limit headers from response and add to client.
204		*
205		* @param Response $response
206		*
207		* @return void
208		*/
209	62	private function parseRateLimitFromResponse(Response $response)
210		{
211	62	$rateLimitHeaders = array_filter([
212	62	$response->getHeader('X-Rate-Limit-Limit'),
213	62	$response->getHeader('X-Rate-Limit-Remaining'),
214	62	$response->getHeader('X-Rate-Limit-Reset')
215	31	]);
216
217	62	if (count($rateLimitHeaders) == 3) {
218	40	$rateLimitClass = new ReflectionClass(RateLimit::class);
219	40	$this->rate_limit = $rateLimitClass->newInstanceArgs($rateLimitHeaders);
220	20	}
221	62	}
222
223		/**
224		* Makes a request to the Uber API and returns the response.
225		*
226		* @param string $verb The Http verb to use
227		* @param string $path The path of the APi after the domain
228		* @param array $parameters Parameters
229		*
230		* @return stdClass The JSON response from the request
231		* @throws Exception
232		*/
233	68	protected function request($verb, $path, $parameters = [])
234		{
235	68	$client = $this->httpClient;
236	68	$url = $this->getUrlFromPath($path);
237	68	$verb = strtolower($verb);
238	68	$config = $this->getConfigForVerbAndParameters($verb, $parameters);
239
240		try {
241	68	$response = $client->$verb($url, $config);
242	37	} catch (HttpClientException $e) {
243	6	$this->handleRequestException($e);
244		}
245
246	62	$this->parseRateLimitFromResponse($response);
247
248	62	return json_decode($response->getBody());
249		}
250
251		/**
252		* Sets Http Client.
253		*
254		* @param HttpClient $client
255		*
256		* @return Client
257		*/
258	68	public function setHttpClient(HttpClient $client)
259		{
260	68	$this->httpClient = $client;
261	68	return $this;
262		}
263
264		/**
265		* Throws exception when client is not configured sandbox use. Should only
266		* be utilized when attempting to do work against ephemeral sandbox API
267		* data.
268		*
269		* @return void
270		* @throws Exception
271		*
272		* @see https://developer.uber.com/docs/riders/guides/sandbox
273		*/
274	8	private function enforceSandboxExpectation($message = null)
275		{
276	8	if (!$this->use_sandbox) {
277	4	$message = $message ?: 'Attempted to invoke sandbox functionality '.
278	4	'with production client; this is not recommended';
279	4	throw new Exception($message);
280		}
281	4	}
282		}
283

stevenmaguire / uber-php

Client::__construct() A last analyzed 2017-08-24 02:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Client::__construct() A
last analyzed 2017-08-24 02:53 UTC