Client::wasSuccessfulRequest() - Code Metrics - LauLamanApps/ecurring-api - Measure and Improve Code Quality continuously with Scrutinizer

Client::wasSuccessfulRequest() A
last analyzed 2018-10-25 13:10 UTC

↳ Parent: Client
Complexity

Conditions	3
Paths	3
Size

Total Lines	18
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
eloc	14
dl	0
loc	18
ccs	0
cts	12
cp	0
rs	9.7998
c	0
b	0
f	0
cc	3
nc	3
nop	1
crap	12
<?php

declare(strict_types=1);

namespace LauLamanApps\eCurring\Http\Adapter\Guzzle;

use GuzzleHttp\ClientInterface as GuzzleClientInterface;
use GuzzleHttp\Exception\RequestException;
use LauLamanApps\eCurring\Exception\eCurringException;
use LauLamanApps\eCurring\Http\Adapter\Guzzle\Exception\Handler;
use LauLamanApps\eCurring\Http\Adapter\Guzzle\Exception\NotFoundException;
use LauLamanApps\eCurring\Http\ClientInterface;
use LauLamanApps\eCurring\Http\Endpoint\Exception\EndpointCouldNotBeMappedException;
use LauLamanApps\eCurring\Http\Endpoint\MapperInterface;
use LauLamanApps\eCurring\Http\Exception\ApiCallException;
use LauLamanApps\eCurring\Resource\Curser\Pagination;
use Psr\Http\Message\ResponseInterface;

final class Client implements ClientInterface
{
    /**
     * @var GuzzleClientInterface
     */
    private $guzzleClient;

    /**
     * @var MapperInterface
     */
    private $endpointMapper;

    public function __construct(
        GuzzleClientInterface $guzzleClient,
        MapperInterface $urlMapper
    ) {
        $this->guzzleClient = $guzzleClient;
        $this->endpointMapper = $urlMapper;
    }

    /**
     * @throws EndpointCouldNotBeMappedException
     * @throws eCurringException
     * @throws NotFoundException
     */
    public function getEndpoint(string $endpoint, ?array $urlBits = [], ?Pagination $page = null): ResponseInterface
    {
        $options = $page ? ['query' => $page->getQueryOptions()] : [];

        return $this->get(
            $this->endpointMapper->map($endpoint, $urlBits),
            $options
        );
    }

    /**
     * @throws eCurringException
     * @throws NotFoundException
     * @return ResponseInterface
     */
    public function getUrl(string $url): ResponseInterface
    {
        return $this->get($url);
    }

    public function getJson(ResponseInterface $response): string
    {
        return (string) $response->getBody();
    }

    /**
     * @throws NotFoundException
     * @throws eCurringException
     */
    private function get(string $url, ?array $options = []): ResponseInterface
    {
        try {
            $response = $this->guzzleClient->get($url, $options);

            $this->wasSuccessfulRequest($response);

            return $response;
        } catch (RequestException $exception) {
            Handler::handleRequestException($exception);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @throws eCurringException
     */
    public function postEndpoint(string $endpoint, array $data, array $urlBits = null): ResponseInterface
    {
        return $this->post(
            $this->endpointMapper->map($endpoint, $urlBits),
            $this->endpointMapper->map($endpoint, /** @scrutinizer ignore-type */ $urlBits),
            ['json' => $data]
        );
    }

    /**
     * @throws ApiCallException
     * @throws eCurringException
     * @throws NotFoundException
     */
    private function post(string $url, ?array $options = []): ResponseInterface
    {
        try {
            $response = $this->guzzleClient->post($url, $options);
            $this->wasSuccessfulRequest($response);

            return $response;
        } catch (RequestException $exception) {
            Handler::handleRequestException($exception);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @throws eCurringException
     */
    public function patchEndpoint(string $endpoint, array $data, array $urlBits = null): ResponseInterface
    {
        return $this->patch(
            $this->endpointMapper->map($endpoint, $urlBits),
            $this->endpointMapper->map($endpoint, /** @scrutinizer ignore-type */ $urlBits),
            ['json' => $data]
        );
    }

    /**
     * @throws ApiCallException
     * @throws eCurringException
     * @throws NotFoundException
     */
    private function patch(string $url, ?array $options = []): ResponseInterface
    {
        try {
            $response = $this->guzzleClient->patch($url, $options);
            $this->wasSuccessfulRequest($response);

            return $response;
        } catch (RequestException $exception) {
            Handler::handleRequestException($exception);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @throws eCurringException
     */
    public function deleteEndpoint(string $endpoint, array $data, array $urlBits = null): void
    {
        $this->delete(
            $this->endpointMapper->map($endpoint, $urlBits),
            $this->endpointMapper->map($endpoint, /** @scrutinizer ignore-type */ $urlBits),
            ['json' => $data]
        );
    }

    /**
     * @throws ApiCallException
     * @throws eCurringException
     * @throws NotFoundException
     */
    private function delete(string $url, ?array $options = []): ResponseInterface
    {
        try {
            $response = $this->guzzleClient->delete($url, $options);
            $this->wasSuccessfulRequest($response);

            return $response;
        } catch (RequestException $exception) {
            Handler::handleRequestException($exception);
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        }
    }

    /**
     * @throws ApiCallException
     */
    private function wasSuccessfulRequest(ResponseInterface $response): void
    {
        switch ($response->getStatusCode()) {
            case 200:
                return;

                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 201:
                return;

                break;
            default:
                throw new ApiCallException(
                    sprintf(
                        '%s %s: %s',
                        $response->getStatusCode(),
                        $response->getReasonPhrase(),
                        $response->getBody()->getContents()
                    )
                );
        }
    }
}

LauLamanApps / ecurring-api

Client::wasSuccessfulRequest() A last analyzed 2018-10-25 13:10 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Client::wasSuccessfulRequest() A
last analyzed 2018-10-25 13:10 UTC
