App\Console\Commands\GitterRoomListenCommand

Complexity

Total Complexity

11

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	9
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
B	handle()	0	31	3
A	auth()	0	12	1
B	listen()	0	40	2
B	onMessageFallback()	0	26	2
A	onMessage()	0	17	3

<?php
/**
 * This file is part of GitterBot package.
 *
 * @author Serafim <nesk@xakep.ru>
 * @date 26.01.2016 4:57
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace App\Console\Commands;

use App\Gitter\Extensions\MiddlewareBuilder;
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';

    /**
     * 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) use ($client) {

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);

                    $client->onChangeFallbackMode(function($state) use ($room) {
                        if ($state) {
                            $room->sendMessage('_Подключение к Gitter Stream API восстановлено_');
                        } else {
                            $room->sendMessage('_Подключение к Gitter Stream API потеряно. Слоупок mode enabled._');
                        }
                    });

                } 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);
            }, function(\Throwable $e) {
                $this->onError($e);

The method onError() does not exist on App\Console\Commands\GitterRoomListenCommand. Did you maybe mean ignoreValidationErrors()?

            });
    }

    /**
     * @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,
            ]);
        });

        /** @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) {

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

            $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>.

                $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);
                    }, function(\Throwable $e) {
                        $this->error($e->getMessage());
                    });
            });
        } else {
            $this->listen($gitter);
        }
    }

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

        if ($message->gitter_id === \Auth::user()->gitter_id) {
            return;
        }

        try {
            /** @var MiddlewareBuilder $builder */
            $builder = app(MiddlewareBuilder::class);
            $builder->fire($gitter->room, $message);

        } catch (\Throwable $e) {
            $this->error($e->getMessage());
        }
    }
}