Client::getCoins() - Code Metrics - Inspection of "add search endpoint to the client" - coinpaprika/coinpaprika-api-php-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 5d27ce...6ee2cf )

by Krzysztof
created 2018-09-28 12:06 UTC
Client::getCoins() A

↳ Parent: Client
Complexity

Conditions	1
Paths	1
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	8
ccs	5
cts	5
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php

namespace Coinpaprika;

use Coinpaprika\Exception\InvalidResponseException;
use Coinpaprika\Exception\RateLimitExceededException;
use Coinpaprika\Exception\ResponseErrorException;
use Coinpaprika\Http\Request;
use Coinpaprika\Model\Coin;
use Coinpaprika\Model\GlobalStats;
use Coinpaprika\Model\Search;
use Coinpaprika\Model\Ticker;
use JMS\Serializer\SerializerBuilder;
use JMS\Serializer\Serializer;
use GuzzleHttp\Exception\GuzzleException;
use Psr\Http\Message\ResponseInterface;

/**
 * Class Client
 *
 * @package Coinpaprika
 *
 * @author Krzysztof Przybyszewski <[email protected]>
 */
class Client
{
    const BASE_URL = 'https://api.coinpaprika.com/%ver%/';

    /**
     * @var string
     */
    private $apiVersion;

    /**
     * @var \GuzzleHttp\Client
     */
    private $httpClient;

    /**
     * @var Serializer
     */
    private $serializer;

    /**
     * Client constructor.
     *
     * @param   string|null         $cacheDir
     * @param   \GuzzleHttp\Client  $httpClient
     */
    public function __construct(
        string $cacheDir = null,
        \GuzzleHttp\Client $httpClient = null
    ) {
        $serializerBuilder = SerializerBuilder::create()
            ->addMetadataDir(__DIR__.'/Resource/config/serializer');

        if ($cacheDir !== null) {
            $serializerBuilder->setCacheDir($cacheDir);
        }

        $this->apiVersion = 'v1';
        $this->serializer = $serializerBuilder->build();

        if ($httpClient === null) {
            $httpClient = new \GuzzleHttp\Client();
        }

        $this->httpClient = $httpClient;
    }

    /**
     * Get global stats
     *
     * @throws  GuzzleException
     * @throws  ResponseErrorException
     * @throws  RateLimitExceededException
     * @throws  InvalidResponseException
     *
     * @return  GlobalStats
     */
    public function getGlobalStats(): GlobalStats
    {
        $response = $this->sendRequest(
            Request::METHOD_GET,
            $this->getEndpointUrl('global')
        );

        return $this->response($response, GlobalStats::class);
    }

    /**
     * Get tickers
     *
     * @throws  GuzzleException
     * @throws  ResponseErrorException
     * @throws  RateLimitExceededException
     * @throws  InvalidResponseException
     *
     * @return  array|Ticker[]
     */
    public function getTickers(): array
    {
        $response = $this->sendRequest(
            Request::METHOD_GET,
            $this->getEndpointUrl('ticker')
        );

        return $this->response($response, sprintf('array<%s>', Ticker::class));
    }

    /**
     * Get coin`s ticker data
     *
     * @param   string $id
     *
     * @throws  GuzzleException
     * @throws  ResponseErrorException
     * @throws  RateLimitExceededException
     * @throws  InvalidResponseException
     *
     * @return  Ticker
     */
    public function getTickerByCoinId(string $id): Ticker
    {
        $response = $this->sendRequest(
            Request::METHOD_GET,
            $this->getEndpointUrl(sprintf('ticker/%s', $id))
        );

        return $this->response($response, Ticker::class);
    }

    /**
     * Get coins list
     *
     * @throws  GuzzleException
     * @throws  ResponseErrorException
     * @throws  RateLimitExceededException
     * @throws  InvalidResponseException
     *
     * @return  array|Coin[]
     */
    public function getCoins(): array
    {
        $response = $this->sendRequest(
            Request::METHOD_GET,
            $this->getEndpointUrl('coins')
        );

        return $this->response($response, sprintf('array<%s>', Coin::class));

    }

    /**
     * @param   string     $query
     * @param   array|null $categories
     * @param   null       $limit

     *
     * @throws  InvalidResponseException
     * @throws  RateLimitExceededException
     * @throws  ResponseErrorException
     * @throws  GuzzleException
     *
     * @return Search
     */
    public function search(string $query, array $categories = null, $limit = null): Search
    {
        $params = array_filter([
            'q' => $query,
            'c' => $categories ? implode(',', $categories) : null,
            'limit' => $limit
        ]);

        $response = $this->sendRequest(
            Request::METHOD_GET,
            $this->getEndpointUrl('global'),
            $params
        );

        return $this->response($response, Search::class);
    }

    /**
     * Get the API version
     *
     * @return  string
     */
    public function getApiVersion(): string
    {
        return $this->apiVersion;
    }

    /**
     * Get the endpoint URL.
     *
     * @param   string  $endpoint
     *
     * @return  string
     */
    protected function getEndpointUrl(string $endpoint): string
    {
        return str_replace('%ver%', $this->getApiVersion(), static::BASE_URL).$endpoint;
    }

    /**
     * @param   string $method
     * @param   string $url
     * @param   array  $params
     * @param   array  $headers
     *
     * @return  ResponseInterface
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    protected function sendRequest(
        string $method,
        string $url,
        array $params = [],
        /** @scrutinizer ignore-unused */ array $params = [],
        array $headers = []
    ): ResponseInterface {

        $defaultHeaders = [
            'User-Agent' => 'Coinpaprika API Client - PHP'
        ];

        if (Request::METHOD_GET === $method) {

        }

        return $this->httpClient->request($method, $url, [
            'headers' => array_merge($defaultHeaders, $headers)
        ]);
    }

    /**
     * @param   ResponseInterface   $response
     *
     * @throws  InvalidResponseException
     * @throws  RateLimitExceededException
     * @throws  ResponseErrorException
     */
    protected function validateResponse(ResponseInterface $response): void
    {
        $statusCode = $response->getStatusCode();

        // rate limit exceeded
        if ($statusCode === 429) {
            throw new RateLimitExceededException('Response code from API 429. Rate limit exceeded.');
        }

        // check for errors
        if ($statusCode >= 400 && $statusCode <= 500) {

            if (array_key_exists('error', $e = json_decode($response->getBody(), true))) {

                throw new ResponseErrorException(sprintf(
                    'Response code: %s, error: %s',
                    $statusCode,
                    $e['error']
                ));
            }

            throw new InvalidResponseException(sprintf(
                'Bad response from a server - status code: %s, but error field does not exists.',
                $statusCode
            ));
        }
    }

    /**
     * Unmarshal JSON
     *
     * @param   ResponseInterface $response
     * @param   string            $type
     *
     * @throws  ResponseErrorException
     * @throws  RateLimitExceededException
     * @throws  InvalidResponseException
     *
     * @see     https://api.coinpaprika.com/#section/Errors
     *
     * @return  mixed
     */
    protected function response(ResponseInterface $response, string $type)
    {
        $this->validateResponse($response);

        return $this->serializer->deserialize($response->getBody(), $type, 'json');
    }
}

coinpaprika / coinpaprika-api-php-client

GitHub Access Token became invalid

Push — master ( 5d27ce...6ee2cf )

Client::getCoins() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
