ninjacto\OrtcPhp\OrtcClient

Complexity

Total Complexity

16

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	execute()	0	24	3
A	batchExecute()	0	19	2
A	setGuzzleClient()	0	4	1
A	setRequest()	0	4	1
A	setBaseUrl()	0	4	1
A	getRequestOptionsForPost()	0	7	1
A	getRequestOptionsForGet()	0	6	1
A	createRequest()	0	16	2
A	createBatchPostRequests()	0	14	2
A	getRequestUrl()	0	8	2

<?php

namespace ninjacto\OrtcPhp;

use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Message\FutureResponse;
use GuzzleHttp\Pool;
use ninjacto\OrtcPhp\Exceptions\BatchRequestException;
use ninjacto\OrtcPhp\Exceptions\InvalidBalancerUrlException;
use ninjacto\OrtcPhp\Exceptions\NetworkErrorException;
use ninjacto\OrtcPhp\Exceptions\UnauthorizedException;
use ninjacto\OrtcPhp\Models\Requests\OrtcRequest;

class OrtcClient
{
    /**
     * @var \GuzzleHttp\Client
     */
    protected $guzzleClient;

    /**
     * @var OrtcRequest
     */
    protected $request;

    /**
     * @var string
     */
    protected $baseUrl;

    /**
     * execute single request.
     *
     * @throws UnauthorizedException
     * @throws NetworkErrorException
     * @throws InvalidBalancerUrlException
     *
     * @return Models\Responses\OrtcResponse
     */
    public function execute()
    {
        $response = null;

        try {
            $guzzleRequest = $this->createRequest();

            /** @var FutureResponse $response */
            $response = $this->guzzleClient->send($guzzleRequest);
        } catch (ClientException $e) {
            if ($e->getResponse()->getStatusCode() == 401) {
                throw new UnauthorizedException();
            } else {
                $networkErrorException = new NetworkErrorException();
                $networkErrorException->setGuzzleClientException($e);

                throw $networkErrorException;
            }
        }

        $handler = $this->request->getResponseHandler();

        return $handler->handle($response);
    }

    /**
     * execute batch requests (post).
     *
     * @throws BatchRequestException
     *
     * @return Models\Responses\OrtcResponse
     */
    public function batchExecute()
    {
        $guzzleRequests = $this->createBatchPostRequests();

        $results = Pool::batch($this->guzzleClient, $guzzleRequests, [
            'pool_size' => $this->request->getOrtcConfig()->getBatchPoolSize(),
        ]);

        if (count($results->getFailures()) > 0) {

The method getFailures cannot be called on $results (of type array).

            $batchRequestException = new BatchRequestException();
            $batchRequestException->setResults($results);

$results is of type array, but the function expects a object<GuzzleHttp\BatchResults>.

            throw $batchRequestException;
        }

        $handler = $this->request->getResponseHandler();

        return $handler->handle($results);

$results is of type array, but the function expects a object<GuzzleHttp\Message\FutureResponse>|object<GuzzleHttp\BatchResults>.

    }

    /**
     * @param \GuzzleHttp\Client $guzzleClient
     */
    public function setGuzzleClient($guzzleClient)
    {
        $this->guzzleClient = $guzzleClient;
    }

    /**
     * @param OrtcRequest $request
     */
    public function setRequest($request)
    {
        $this->request = $request;
    }

    /**
     * @param string $baseUrl
     */
    public function setBaseUrl($baseUrl)
    {
        $this->baseUrl = $baseUrl;
    }

    /**
     * get request options for post requests.
     *
     * @param array $postData
     *
     * @return array
     */
    protected function getRequestOptionsForPost($postData)
    {
        return [
            'verify' => $this->request->getOrtcConfig()->isVerifySsl(),
            'body'   => $postData,
        ];
    }

    /**
     * get request options for get requests.
     *
     * @return array
     */
    protected function getRequestOptionsForGet()
    {
        return [
            'verify' => $this->request->getOrtcConfig()->isVerifySsl(),
        ];
    }

    /**
     * create guzzle GET/POST request.
     *
     * @return \Psr\Http\Message\RequestInterface
     */
    protected function createRequest()
    {
        if ($this->request->isPost()) {
            return $this->guzzleClient->createRequest(

The method createRequest() does not exist on GuzzleHttp\Client. Did you maybe mean request()?

                'POST',
                $this->getRequestUrl(),
                $this->getRequestOptionsForPost($this->request->getPostData())
            );
        } else {
            return $this->guzzleClient->createRequest(

The method createRequest() does not exist on GuzzleHttp\Client. Did you maybe mean request()?

                'GET',
                $this->getRequestUrl(),
                $this->getRequestOptionsForGet()
            );
        }
    }

    /**
     * create batch guzzle POST requests.
     *
     * @return \GuzzleHttp\Message\Request[]
     */
    protected function createBatchPostRequests()
    {
        $requests = [];

        foreach ($this->request->getPostData() as $postData) {
            $requests[] = $this->guzzleClient->createRequest(

The method createRequest() does not exist on GuzzleHttp\Client. Did you maybe mean request()?

                'POST',
                $this->getRequestUrl(),
                $this->getRequestOptionsForPost($postData)
            );
        }

        return $requests;
    }

    /**
     * combine path url & baseUrl if needed!
     */
    protected function getRequestUrl()
    {
        if (!$this->request->isUrlAbsolute()) {
            return $this->baseUrl . $this->request->getUrlPath();
        } else {
            return $this->request->getUrlPath();
        }
    }
}