unreal4u\TelegramAPI\HttpClientRequestHandlerReact

Complexity

Total Complexity

7

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get()	0	5	1
A	post()	0	6	3
B	processRequest()	0	29	2

<?php

declare(strict_types=1);

namespace unreal4u\TelegramAPI;

use React\EventLoop\LoopInterface;
use React\HttpClient\Client;
use React\HttpClient\Request;
use React\HttpClient\Response;
use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use unreal4u\TelegramAPI\Exceptions\ClientException;
use unreal4u\TelegramAPI\InternalFunctionality\TelegramResponse;

class HttpClientRequestHandlerReact implements RequestHandlerInterface
{
    /**
     * @var Client
     */
    protected $client;

    /**
     * HttpClientRequestHandler constructor.
     * @param LoopInterface $loop
     */
    public function __construct(LoopInterface $loop)
    {
        $this->client = new Client($loop);
    }

    /**
     * @param string $uri
     * @return PromiseInterface
     */
    public function get(string $uri): PromiseInterface
    {
        $request = $this->client->request('GET', $uri);
        return $this->processRequest($request);
    }

    /**
     * @param string $uri
     * @param array $options
     * @return PromiseInterface
     */
    public function post(string $uri, array $options): PromiseInterface
    {
        $headers = !empty($options['headers']) ? $options['headers'] : [];
        $request = $this->client->request('POST', $uri, $headers);
        return $this->processRequest($request, (!empty($options['body']) ? $options['body'] : null));
    }

    /**
     * @param Request $request
     * @param mixed $data
     * @return PromiseInterface
     */
    private function processRequest(Request $request, $data = null): PromiseInterface
    {
        $deferred = new Deferred();

        $receivedData = '';
        $request->on('response', function (Response $response) use ($deferred, &$receivedData) {
            $response->on('data', function ($chunk) use (&$receivedData) {
                $receivedData .= $chunk;
            });

            $response->on('end', function () use (&$receivedData, $deferred, $response) {
                try {
                    $endResponse = new TelegramResponse($receivedData, $response->getHeaders());
                    $deferred->resolve($endResponse);
                } catch (\Exception $e) {
                    // Capture any exceptions thrown from TelegramResponse and reject the response
                    $deferred->reject($e);
                }
            });
        });

        $request->on('error', function (\Exception $e) use ($deferred) {
            $deferred->reject(new ClientException($e->getMessage(), $e->getCode(), $e));
        });

        $request->end($data);

        return $deferred->promise();
    }
}