Appwilio\RussianPostSDK\Dispatching\Http\ApiClient

Complexity

Total Complexity

27

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getHttpClient()	0	13	2
A	guessFileType()	0	13	3
A	buildRequestOptions()	0	14	2
B	send()	0	37	9
A	handleClientException()	0	7	1
A	post()	0	3	1
A	put()	0	3	1
A	__construct()	0	4	1
A	handleServerException()	0	3	1
A	delete()	0	3	1
A	getResponseContent()	0	3	1
A	handleAuthenticationException()	0	7	2
A	buildFile()	0	10	1
A	get()	0	3	1

<?php

/**
 * This file is part of RussianPost SDK package.
 *
 * © Appwilio (http://appwilio.com), JhaoDa (https://github.com/jhaoda)
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Appwilio\RussianPostSDK\Dispatching\Http;

use Appwilio\RussianPostSDK\Dispatching\Instantiator;
use Appwilio\RussianPostSDK\Dispatching\Contracts\Arrayable;
use Appwilio\RussianPostSDK\Dispatching\Exceptions\BadRequest;
use Appwilio\RussianPostSDK\Dispatching\Contracts\DispatchingException;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\ServerException;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Psr7\UploadedFile;
use Psr\Http\Message\ResponseInterface;

final class ApiClient
{
    private const API_URL = 'https://otpravka-api.pochta.ru';

    private const COMMON_HEADERS = [
        'Accept' => 'application/json;charset=UTF-8',
    ];

    private const FILE_SIGNATURES = [
        'zip' => 'PK',
        'pdf' => '%PDF-',
    ];

    /** @var Authorization */
    private $auth;

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

    /** @var array */
    private $httpOptions;

    public function __construct(Authorization $authorization, array $httpOptions)
    {
        $this->auth = $authorization;
        $this->httpOptions = $httpOptions;
    }

    public function get(string $path, ?Arrayable $request = null, $type = null)
    {
        return $this->send('GET', ...\func_get_args());

func_get_args() is expanded, but the parameter $path of Appwilio\RussianPostSDK\Dispatching\Http\ApiClient::send() does not expect variable arguments.

    }

    public function post(string $path, Arrayable $request, $type = null)
    {
        return $this->send('POST', ...\func_get_args());

func_get_args() is expanded, but the parameter $path of Appwilio\RussianPostSDK\Dispatching\Http\ApiClient::send() does not expect variable arguments.

    }

    public function put(string $path, Arrayable $request, $type = null)
    {
        return $this->send('PUT', ...\func_get_args());

func_get_args() is expanded, but the parameter $path of Appwilio\RussianPostSDK\Dispatching\Http\ApiClient::send() does not expect variable arguments.

    }

    public function delete(string $path, Arrayable $request, $type = null)
    {
        return $this->send('DELETE', ...\func_get_args());

func_get_args() is expanded, but the parameter $path of Appwilio\RussianPostSDK\Dispatching\Http\ApiClient::send() does not expect variable arguments.

    }

    /**
     * Выполнение запроса.
     *
     * @param  string          $method
     * @param  string          $path
     * @param  Arrayable|null  $request
     * @param  null            $type

Are you sure the doc-type for parameter $type is correct as it would always require null to be passed?

     *
     * @throws DispatchingException
     * @throws \GuzzleHttp\Exception\GuzzleException
     *
     * @return mixed
     */
    private function send(string $method, string $path, ?Arrayable $request = null, $type = null)
    {
        $response = null;

The assignment to $response is dead and can be removed.

        try {
            $response = $this->getHttpClient()->request(
                $method, $path, $request ? $this->buildRequestOptions($method, $request) : []
            );
        } catch (ClientException $e) {
            if ($e->getCode() === 401) {
                throw $this->handleAuthenticationException($e);
            }

            throw $this->handleClientException($e);
        } catch (ServerException $e) {
            throw $this->handleServerException($e);
        } catch (\Exception $e) {
            throw $e;
        }

        if (null === $response) {
            return null;
        }

        $fileType = $this->guessFileType($response);

        if ($fileType) {
            return $this->buildFile($response, $fileType);
        }

        $content = $this->getResponseContent($response);

        if (null === $type) {

The condition null === $type is always true.

            return $content;
        }

        return Instantiator::instantiate($type, $content);
    }

    private function buildRequestOptions(string $method, Arrayable $request): array
    {
        $data = \array_filter($request->toArray());

        if ($method === 'GET') {
            return [
                'query' => $data,
            ];
        }

        return [
            'body'    => \json_encode($data),
            'headers' => [
                'Content-Type' => 'application/json;charset=UTF-8',
            ],
        ];
    }

    private function getHttpClient(): HttpClient
    {
        if ($this->httpClient === null) {
            $this->httpClient = new HttpClient(\array_merge(
                $this->httpOptions,
                [
                    'base_uri' => self::API_URL,
                    'headers'  => \array_merge(self::COMMON_HEADERS, $this->auth->toArray()),
                ]
            ));
        }

        return $this->httpClient;
    }

    private function guessFileType(Response $response): ?string
    {
        $chunk = $response->getBody()->read(10);

        foreach (self::FILE_SIGNATURES as $type => $signature) {
            if (0 === \stripos($chunk, $signature)) {
                $response->getBody()->rewind();

                return $type;
            }
        }

        return null;
    }

    private function buildFile(Response $response, string $type): UploadedFile
    {
        $name = \explode('=', $response->getHeaderLine('Content-Disposition') ?? '')[1] ?? '';

        return new UploadedFile(
            $response->getBody(),
            $response->getBody()->getSize(),
            \UPLOAD_ERR_OK,
            "{$name}.{$type}",
            $response->getHeaderLine('Content-Type')
        );
    }

    private function handleClientException(ClientException $exception): DispatchingException
    {
        $content = $this->getResponseContent($exception->getResponse());

        return new BadRequest(
            $content['message'] ?? $content['error'] ?? $content['desc'],
            (int) ($content['status'] ?? $content['code'] ?? $exception->getCode())
        );
    }

    private function handleAuthenticationException(ClientException $exception)
    {
        $content = $this->getResponseContent($exception->getResponse());

        return new BadRequest(
            $content['message'] ?? $content['desc'] ?? '',
            $content['code'] ? (int) $content['code'] : $exception->getCode()
        );
    }

    private function handleServerException(ServerException $e): DispatchingException
    {
        throw $e;
    }

    private function getResponseContent(ResponseInterface $response): array
    {
        return \json_decode((string) $response->getBody(), true);
    }
}