Nopolabs\Yabot\Slack\Client

Complexity

Total Complexity

38

Size/Duplication

Total Lines	266
Duplicated Lines	7.52 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	init()	0	7	1
A	update()	0	7	1
A	onEvent()	0	6	1
A	getRealTimeClient()	0	4	1
A	getAuthedUser()	0	4	1
A	getAuthedUsername()	0	4	1
A	connect()	0	4	1
A	disconnect()	0	4	1
A	reconnect()	0	5	1
A	ping()	0	4	1
B	say()	0	23	6
A	send()	0	4	1
A	post()	10	10	1
A	directMessage()	10	10	1
A	getUsersMap()	0	4	1
A	getBotsMap()	0	4	1
A	getChannelsMap()	0	4	1
A	getUserById()	0	4	1
A	getUserByName()	0	4	1
A	getBotById()	0	4	1
A	getBotByName()	0	4	1
A	getChannelById()	0	4	1
A	getChannelByName()	0	4	1
A	updateUsers()	0	6	1
A	updateBots()	0	6	1
A	updateChannels()	0	6	1
A	updateAuthedUser()	0	7	1
A	initChannelUpdateHandlers()	0	7	2
A	initUserUpdateHandlers()	0	7	2
A	useWebSocket()	0	4	1

<?php

namespace Nopolabs\Yabot\Slack;


use Closure;
use Nopolabs\Yabot\Helpers\ConfigTrait;
use Nopolabs\Yabot\Helpers\LogTrait;
use Psr\Log\LoggerInterface;
use React\Promise\PromiseInterface;
use Slack\Bot;
use Slack\Channel;
use Slack\ChannelInterface;
use Slack\Payload;
use Slack\RealTimeClient;
use Slack\User;

class Client
{
    use ConfigTrait;
    use LogTrait;

    /** @var RealTimeClient */
    private $realTimeClient;

    /** @var Users */
    private $users;

    /** @var Bots */
    private $bots;

    /** @var Channels */
    private $channels;

    /** @var User */
    protected $authedUser;

    public function __construct(
        RealTimeClient $realTimeClient,
        Users $users,
        Bots $bots,
        Channels $channels,
        array $config = [],
        LoggerInterface $log = null)
    {
        $this->realTimeClient = $realTimeClient;
        $this->users = $users;
        $this->bots = $bots;
        $this->channels = $channels;
        $this->setConfig($config);
        $this->setLog($log);
    }

    public function init() : Client
    {
        $this->initChannelUpdateHandlers();
        $this->initUserUpdateHandlers();

        return $this;
    }

    public function update(Closure $authedUserUpdated)
    {
        $this->updateUsers();
        $this->updateBots();
        $this->updateChannels();
        $this->updateAuthedUser($authedUserUpdated);
    }

    public function onEvent($event, array $onEvent)
    {
        $this->realTimeClient->on($event, function(Payload $payload) use ($onEvent) {
            call_user_func($onEvent, $payload);
        });
    }

    public function getRealTimeClient()
    {
        return $this->realTimeClient;
    }

    public function getAuthedUser()
    {
        return $this->authedUser;
    }

    public function getAuthedUsername()
    {
        return $this->authedUser->getUsername();
    }

    public function connect() : PromiseInterface
    {
        return $this->realTimeClient->connect();
    }

    public function disconnect()
    {
        $this->realTimeClient->disconnect();
    }

    public function reconnect() : PromiseInterface
    {
        $this->realTimeClient->disconnect();
        return $this->realTimeClient->connect();
    }

    public function ping() : PromiseInterface
    {
        return $this->getRealTimeClient()->ping();
    }

    public function say($text, $channelOrName, array $additionalParameters = [])
    {
        $channel = $channelOrName;
        if (!($channel instanceof ChannelInterface)) {
            $channel = $this->getChannelByName($channelOrName);
            if (!($channel instanceof ChannelInterface)) {
                $channel = $this->getChannelById($channelOrName);
                if (!($channel instanceof ChannelInterface)) {
                    $this->warning('No channel, trying to say: '.$text);
                    return;
                }
            }
        }

        if (empty($additionalParameters) && $this->useWebSocket()) {
            // WebSocket send does not support message formatting.
            $this->send($text, $channel);
            return;
        }

        // Http post send supports message formatting.
        $this->post($text, $channel, $additionalParameters);
    }

    public function send($text, ChannelInterface $channel)
    {
        $this->realTimeClient->send($text, $channel);
    }

    public function post($text, ChannelInterface $channel, array $additionalParameters = [])

This method seems to be duplicated in your project.

    {
        $parameters = array_merge([
            'text' => $text,
            'channel' => $channel->getId(),
            'as_user' => true,
        ], $additionalParameters);

        $this->realTimeClient->apiCall('chat.postMessage', $parameters);
    }

    public function directMessage($text, $userName)

This method seems to be duplicated in your project.

    {
        $parameters = [
            'text' => $text,
            'channel' => $userName,
            'as_user' => false,
        ];

        $this->realTimeClient->apiCall('chat.postMessage', $parameters);
    }


    public function getUsersMap() : array
    {
        return $this->users->getMap();
    }

    public function getBotsMap() : array
    {
        return $this->bots->getMap();
    }

    public function getChannelsMap() : array
    {
        return $this->channels->getMap();
    }

    /**
     * @param $id
     * @return null|User
     */
    public function getUserById($id)
    {
        return $this->users->byId($id);
    }

    /**
     * @param $name
     * @return null|User
     */
    public function getUserByName($name)
    {
        return $this->users->byName($name);
    }

    /**
     * @param $id
     * @return null|Bot
     */
    public function getBotById($id)
    {
        return $this->bots->byId($id);
    }

    /**
     * @param $name
     * @return null|Bot
     */
    public function getBotByName($name)
    {
        return $this->bots->byName($name);
    }

    /**
     * @param $id
     * @return null|Channel
     */
    public function getChannelById($id)
    {
        return $this->channels->byId($id);
    }

    /**
     * @param $name
     * @return null|Channel
     */
    public function getChannelByName($name)
    {
        return $this->channels->byName($name);
    }

    public function updateUsers()
    {
        $this->realTimeClient->getUsers()->then(function(array $users) {
            $this->users->update($users);
        });
    }

    public function updateBots()
    {
        $this->realTimeClient->getBots()->then(function(array $bots) {
            $this->bots->update($bots);
        });
    }

    public function updateChannels()
    {
        $this->realTimeClient->getChannels()->then(function(array $channels) {
            $this->channels->update($channels);
        });
    }

    protected function updateAuthedUser(Closure $authedUserUpdated)
    {
        $this->realTimeClient->getAuthedUser()->then(function(User $user) use ($authedUserUpdated) {
            $this->authedUser = $user;
            $authedUserUpdated($user);
        });
    }

    protected function initChannelUpdateHandlers()
    {
        $events = ['channel_created', 'channel_deleted', 'channel_rename'];
        foreach ($events as $event) {
            $this->onEvent($event, [$this, 'updateChannels']);
        }
    }

    protected function initUserUpdateHandlers()
    {
        $events = ['user_change'];
        foreach ($events as $event) {
            $this->onEvent($event, [$this, 'updateUsers']);
        }
    }

    protected function useWebSocket() : bool
    {
        return (bool) $this->get('use.websocket', false);
    }
}