ApiClients\Client\RabbitMQ\Management\AsyncClient

Complexity

Total Complexity

6

Size/Duplication

Total Lines	95
Duplicated Lines	25.26 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	11	1
A	createFromClient()	0	4	1
A	__construct()	0	4	1
A	overview()	0	10	1
A	queues()	12	12	1
A	connections()	12	12	1

<?php
declare(strict_types=1);

namespace ApiClients\Client\RabbitMQ\Management;

use ApiClients\Foundation\ClientInterface as FoundationClientInterface;
use ApiClients\Foundation\Factory;
use ApiClients\Foundation\Hydrator\CommandBus\Command\HydrateCommand;
use ApiClients\Foundation\Transport\CommandBus\Command\SimpleRequestCommand;
use Psr\Http\Message\ResponseInterface;
use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface;
use Rx\Observable;
use Rx\ObservableInterface;
use Rx\React\Promise;
use function React\Promise\resolve;

final class AsyncClient implements AsyncClientInterface
{
    /**
     * @var FoundationClientInterface
     */
    private $client;

    /**
     * Create a new AsyncClient based on the loop and other options pass
     *
     * @param LoopInterface $loop
     * @param string $baseUrl
     * @param string $username
     * @param string $password
     * @param array $options
     * @return AsyncClient
     */
    public static function create(
        LoopInterface $loop,
        string $baseUrl,
        string $username,
        string $password,
        array $options = []

The parameter $options is not used and could be removed.

    ): self {
        $options = ApiSettings::getOptions($baseUrl, $username, $password, 'Async');
        $client = Factory::create($loop, $options);
        return new self($client);
    }

    /**
     * Create an AsyncClient from a ApiClients\Foundation\ClientInterface.
     * Be sure to pass in a client with the options from ApiSettings and the Async namespace suffix.
     *
     * @param FoundationClientInterface $client
     * @return AsyncClient
     */
    public static function createFromClient(FoundationClientInterface $client): self
    {
        return new self($client);
    }

    /**
     * @param FoundationClientInterface $client
     */
    private function __construct(FoundationClientInterface $client)
    {
        $this->client = $client;
    }

    /**
     * @return PromiseInterface
     */
    public function overview(): PromiseInterface
    {
        return $this->client->handle(
            new SimpleRequestCommand('overview')
        )->then(function (ResponseInterface $response) {
            return resolve($this->client->handle(
                new HydrateCommand('Overview', $response->getBody()->getJson())

It seems like you code against a concrete implementation and not the interface Psr\Http\Message\StreamInterface as the method getJson() does only exist in the following implementations of said interface: ApiClients\Foundation\Transport\JsonStream.

            ));
        });
    }

    /**
     * @return ObservableInterface
     */
    public function queues(): ObservableInterface

This method seems to be duplicated in your project.

    {
        return Promise::toObservable($this->client->handle(
            new SimpleRequestCommand('queues')
        ))->flatMap(function (ResponseInterface $response) {
            return Observable::fromArray($response->getBody()->getJson());

It seems like you code against a concrete implementation and not the interface Psr\Http\Message\StreamInterface as the method getJson() does only exist in the following implementations of said interface: ApiClients\Foundation\Transport\JsonStream.

        })->flatMap(function ($queue) {
            return Promise::toObservable($this->client->handle(
                new HydrateCommand('Queue', $queue)
            ));
        });
    }

    /**
     * @return ObservableInterface
     */
    public function connections(): ObservableInterface

This method seems to be duplicated in your project.

    {
        return Promise::toObservable($this->client->handle(
            new SimpleRequestCommand('connections')
        ))->flatMap(function (ResponseInterface $response) {
            return Observable::fromArray($response->getBody()->getJson());

It seems like you code against a concrete implementation and not the interface Psr\Http\Message\StreamInterface as the method getJson() does only exist in the following implementations of said interface: ApiClients\Foundation\Transport\JsonStream.

        })->flatMap(function ($connection) {
            return Promise::toObservable($this->client->handle(
                new HydrateCommand('Connection', $connection)
            ));
        });
    }
}