App\Console\Commands\GitterRoomListenCommand

Complexity

Total Complexity

11

Size/Duplication

Total Lines	179
Duplicated Lines	6.15 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes	7
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	auth()	0	10	1
A	handle()	0	23	2
A	getExtensions()	0	18	2
B	listen()	0	44	2
A	onMessageFallback()	11	23	2
A	onMessage()	0	9	2

<?php
namespace App\Console\Commands;


use App\Gitter\ExtensionInterface;
use App\Gitter\Middlewares\EloquentQueryBuilderMiddleware;
use App\Gitter\Middlewares\GoogleSearchMiddleware;
use App\Gitter\MiddlewaresExtension;
use App\Message;
use App\Room;
use App\User;
use Carbon\Carbon;
use Gitter\Client;
use Gitter\Iterators\PromiseIterator\Controls;
use Gitter\Models\Message as GitterMessage;
use Gitter\Models\Room as GitterRoom;
use Gitter\Models\User as GitterUser;
use Illuminate\Contracts\Config\Repository;
use Illuminate\Contracts\Container\Container;
use React\EventLoop\LoopInterface;


/**
 * Class GitterRoomListenCommand
 * @package App\Console\Commands
 *
 * Прослушивание сообщений требуемой комнаты
 */
class GitterRoomListenCommand extends AbstractCommand
{
    /**
     * @var string
     */
    protected $signature = 'gitter:listen {room}';

    /**
     * @var string
     */
    protected $description = 'Listen gitter room';

    /**
     * @var array|ExtensionInterface[]
     */
    protected $extensions = [];

    /**
     * Execute the console command.
     *
     * @param Repository $config
     * @param Container $container
     *
     * @return mixed
     */
    public function handle(Repository $config, Container $container)
    {
        /** @var Client $client */
        $client = $this->createClient($container, $config->get('gitter.token'));

        $this->auth($client, function (User $user) use ($client) {

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

            $this->findRoom($client, $this->argument('room'), function (GitterRoom $room) {

It seems like $this->argument('room') targeting Illuminate\Console\Command::argument() can also be of type array; however, App\Console\Commands\AbstractCommand::findRoom() does only seem to accept string, maybe add an additional type check?

                try {
                    $this->listen($room, true);

                } catch (\Throwable $e) {

                    $this->error($e->getMessage());
                }
            });

        });

        /** @var LoopInterface $loop */
        $loop = $container->make(LoopInterface::class);
        $loop->run();
    }

    /**
     * @param Client $client
     * @param \Closure $callback
     */
    protected function auth(Client $client, \Closure $callback)
    {
        GitterUser::current($client)
            ->then(function (GitterUser $gitterUser) use ($callback) {
                $user = User::make($gitterUser);
                \Auth::setUser($user);

                $callback($user);
            });
    }

    /**
     * @param GitterRoom $room
     * @return array
     */
    protected function getExtensions(GitterRoom $room)
    {
        if ($this->extensions === []) {
            /**
             * Register Middlewares extension
             * @var MiddlewaresExtension $middlewares
             */
            $middlewares = app(MiddlewaresExtension::class, ['room' => $room]);
            $middlewares
                    ->register(GoogleSearchMiddleware::class)
                    ->register(EloquentQueryBuilderMiddleware::class);


            $this->extensions[] = $middlewares;
        }

        return $this->extensions;
    }

    /**
     * @param GitterRoom $gitter
     * @param bool $startup
     * @return $this
     */
    protected function listen(GitterRoom $gitter, $startup = false)
    {
        /** @var Room $room */
        $room = Room::make($gitter, function (Room $room) {
            $this->call('gitter:sync', [
                'room'       => $room->gitter_id,
                '--users'    => true,
                '--messages' => true,
            ]);
        });

        $this->getExtensions($gitter);

        /** @var LoopInterface $loop */
        $loop = app(LoopInterface::class);

        if ($startup) {
            $this->info('Fetching last messages...');
            $this->onMessageFallback($loop, $gitter, 1);

            return $this;
        }

        $this->info(sprintf(
            'Startup gitter listener for %s at [%s]',
            $room->url,
            Carbon::now()->toDateTimeString()
        ));

        $gitter->onMessage(function (GitterMessage $msg) {
            app(Client::class)->setFallbackMode(false);
            $this->onMessage($msg);

        }, function (\Throwable $e) use ($loop, $gitter) {
            $this->error($e->getMessage());
            $this->error($e->getFile() . ':' . $e->getLine());
            $this->warn('Stream not available. Use message fallback fetch mode.');

            app(Client::class)->setFallbackMode(true);
            $this->onMessageFallback($loop, $gitter);
        });

        return $this;
    }

    /**
     * @param LoopInterface $loop
     * @param GitterRoom $gitter
     * @param int $timeout
     */
    protected function onMessageFallback(LoopInterface $loop, GitterRoom $gitter, $timeout = 10)
    {
        /** @var Message $lastMessage */
        $lastMessage = Message::where('room_id', $gitter->id)
            ->latest('created_at')
            ->first();

        if ($lastMessage) {
            $loop->addTimer($timeout, function () use ($gitter, $lastMessage) {

$timeout is of type integer, but the function expects a object<React\EventLoop\numeric>.

This code seems to be duplicated across your project.

                $gitter->getMessages($lastMessage->gitter_id, GitterRoom::MESSAGE_FETCH_ASC)
                    ->fetch(function (GitterMessage $message, Controls $controls) {
                        $this->onMessage($message);
                        $controls->next();
                    })
                    ->then(function () use ($gitter) {
                        $this->warn('Connection...');
                        $this->listen($gitter);
                    });
            });
        } else {
            $this->listen($gitter);
        }
    }

    /**
     * @param GitterMessage $gitter
     */
    protected function onMessage(GitterMessage $gitter)
    {
        $message = Message::make($gitter);

        /** @var ExtensionInterface $extension */
        foreach ($this->extensions as $extension) {
            $extension->fire($message);
        }
    }
}