Stevenmaguire\Uber\Client

Complexity

Total Complexity

22

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	applyConfiguration()	0	6	1
A	getAuthorizationHeader()	0	8	2
A	getConfigForVerbAndParameters()	0	16	3
A	getHeaders()	0	7	1
A	getUrlFromPath()	0	8	3
A	handleRequestException()	0	11	2
A	parseConfiguration()	0	12	1
A	parseRateLimitFromResponse()	0	13	2
A	request()	0	17	2
A	setHttpClient()	0	5	1
A	enforceSandboxExpectation()	0	8	3

<?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\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 $http_client;

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

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

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

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

    /**
     * Get 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;
    }

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

    /**
     * Build url
     *
     * @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;
    }

    /**
     * Handle 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);
    }

    /**
     * Parse 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);
    }

    /**
     * Attempt 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
     */
    private function request($verb, $path, $parameters = [])
    {
        $client = $this->http_client;
        $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());
    }

    /**
     * Set Http Client
     *
     * @param HttpClient  $client
     *
     * @return Client
     */
    public function setHttpClient(HttpClient $client)
    {
        $this->http_client = $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.
     *
     * @see    https://developer.uber.com/docs/riders/guides/sandbox
     * @return void
     * @throws Exception
     */
    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);
        }
    }
}