floor12\MindBox\MindBoxClient

Complexity

Total Complexity

9

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

78.79%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setClient()	0	3	1
A	getResponse()	0	3	1
A	sendData()	0	21	3
A	getHttpRequest()	0	3	1
A	__construct()	0	20	3

<?php


namespace floor12\MindBox;


use floor12\MindBox\Exceptions\EmptyApiEndPointException;
use floor12\MindBox\Exceptions\EmptyApiKeyException;
use floor12\MindBox\Requests\MindBoxRequest;
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\GuzzleException;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\ResponseInterface;
use function GuzzleHttp\Psr7\build_query;

class MindBoxClient
{
    const MODE_ASYNCHRONOUS = 0;
    const MODE_SYNCHRONOUS = 1;
    const ASYNC_MINDBOX_API_URL = 'https://api.mindbox.ru/v3/operations/async';
    const SYNC_MINDBOX_API_URL = 'https://api.mindbox.ru/v3/operations/sync';
    const DEFAULT_HTTP_TIMEOUT = 15;

    /** @var string */
    private $endpointId;
    /** @var Client */
    private $client;
    /** @var string[] */
    private $headers;
    /** @var string */
    private $secretKey;
    /** @var ResponseInterface */
    private $response;
    /** @var Request */
    private $httpRequest;

    /**
     * @param string $secretKey
     * @param string $endpointId
     * @param ClientInterface|null $client
     * @throws EmptyApiEndPointException
     * @throws EmptyApiKeyException
     */
    public function __construct(
        string $secretKey,
        string $endpointId,
        ClientInterface $client = null)
    {
        $this->client = $client ?? new Client();

        $this->secretKey = $secretKey;
        $this->endpointId = $endpointId;

        if (empty($this->secretKey))
            throw new EmptyApiKeyException();

        if (empty($this->endpointId))
            throw new EmptyApiEndPointException();

        $this->headers = [
            'Content-Type' => 'application/json; charset=utf-8',
            'Accept' => 'application/json',
            'Authorization' => "Mindbox secretKey=\"{$this->secretKey}\""
        ];
    }

    /**
     * @param ClientInterface $client
     */
    public function setClient(ClientInterface $client): void
    {
        $this->client = $client;

$client is of type GuzzleHttp\ClientInterface, but the property $client was declared to be of type GuzzleHttp\Client. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    /**
     * @param MindBoxRequest $mindBoxRequest
     * @throws GuzzleException
     */
    public function sendData(MindBoxRequest $mindBoxRequest): void
    {
        $httpRequestParams = [
            'endpointId' => $this->endpointId,
            'operation' => $mindBoxRequest->getOperationName()
        ];


        if ($mindBoxRequest->getDeviceUUID()) {
            $httpRequestParams['deviceUUID'] = $mindBoxRequest->getDeviceUUID();
        }

        $baseUrl = $mindBoxRequest->isAsync() ? self::ASYNC_MINDBOX_API_URL : self::SYNC_MINDBOX_API_URL;

        $this->httpRequest = new Request(
            'POST',
            $baseUrl . '?' . build_query($httpRequestParams),

The function GuzzleHttp\Psr7\build_query() has been deprecated: build_query will be removed in guzzlehttp/psr7:2.0. Use Query::build instead.

            $this->headers,
            $mindBoxRequest->getBodyAsJson()
        );
        $this->response = $this->client->send($this->httpRequest, ['timeout' => self::DEFAULT_HTTP_TIMEOUT]);
    }

    /**
     * @return ResponseInterface
     */
    public function getResponse(): ResponseInterface
    {
        return $this->response;
    }

    /**
     * @return Request
     */
    public function getHttpRequest(): Request
    {
        return $this->httpRequest;
    }

}