Client::updateChannels() - Code Metrics - Inspection of "ClientTest" - nopolabs/yabot - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6ce725...0a0fa0 )

by Dan

created 2017-06-03 06:52 UTC

Client::updateChannels() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	0

<?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\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 Channels */
    private $channels;

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

    public function __construct(
        RealTimeClient $realTimeClient,
        Users $users,
        Channels $channels,
        array $config = [],
        LoggerInterface $log = null)
    {
        $this->realTimeClient = $realTimeClient;
        $this->users = $users;
        $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->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()
    {
        return $this->realTimeClient->disconnect();
    }

    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 = [])
    {
        $parameters = array_merge([
            'text' => $text,
            'channel' => $channel->getId(),
            'as_user' => true,
        ], $additionalParameters);

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

    /**
     * @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|Channel
     */
    public function getChannelById($id)
    {
        return $this->channels->byId($id);
    }

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

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

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

    protected 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']);
        }
    }
}

1			<?php
2
3			namespace Nopolabs\Yabot\Slack;
4
5
6			use Closure;
7			use Nopolabs\Yabot\Helpers\ConfigTrait;
8			use Nopolabs\Yabot\Helpers\LogTrait;
9			use Psr\Log\LoggerInterface;
10			use React\Promise\PromiseInterface;
11			use Slack\Channel;
12			use Slack\ChannelInterface;
13			use Slack\Payload;
14			use Slack\RealTimeClient;
15			use Slack\User;
16
17			class Client
18			{
19			use ConfigTrait;
20			use LogTrait;
21
22			/** @var RealTimeClient */
23			private $realTimeClient;
24
25			/** @var Users */
26			private $users;
27
28			/** @var Channels */
29			private $channels;
30
31			/** @var User */
32			protected $authedUser;
33
34			public function __construct(
35			RealTimeClient $realTimeClient,
36			Users $users,
37			Channels $channels,
38			array $config = [],
39			LoggerInterface $log = null)
40			{
41			$this->realTimeClient = $realTimeClient;
42			$this->users = $users;
43			$this->channels = $channels;
44			$this->setConfig($config);
45			$this->setLog($log);
46			}
47
48			public function init() : Client
49			{
50			$this->initChannelUpdateHandlers();
51			$this->initUserUpdateHandlers();
52
53			return $this;
54			}
55
56			public function update(Closure $authedUserUpdated)
57			{
58			$this->updateUsers();
59			$this->updateChannels();
60			$this->updateAuthedUser($authedUserUpdated);
61			}
62
63			public function onEvent($event, array $onEvent)
64			{
65			$this->realTimeClient->on($event, function(Payload $payload) use ($onEvent) {
66			call_user_func($onEvent, $payload);
67			});
68			}
69
70			public function getRealTimeClient()
71			{
72			return $this->realTimeClient;
73			}
74
75			public function getAuthedUser()
76			{
77			return $this->authedUser;
78			}
79
80			public function getAuthedUsername()
81			{
82			return $this->authedUser->getUsername();
83			}
84
85			public function connect() : PromiseInterface
86			{
87			return $this->realTimeClient->connect();
88			}
89
90			public function disconnect()
91			{
92			return $this->realTimeClient->disconnect();
93			}
94
95			public function say($text, $channelOrName, array $additionalParameters = [])
96			{
97			$channel = $channelOrName;
98			if (!($channel instanceof ChannelInterface)) {
99			$channel = $this->getChannelByName($channelOrName);
100			if (!($channel instanceof ChannelInterface)) {
101			$channel = $this->getChannelById($channelOrName);
102			if (!($channel instanceof ChannelInterface)) {
103			$this->warning('No channel, trying to say: '.$text);
104			return;
105			}
106			}
107			}
108
109			if (empty($additionalParameters) && $this->useWebSocket()) {
110			// WebSocket send does not support message formatting.
111			$this->send($text, $channel);
112			return;
113			}
114
115			// Http post send supports message formatting.
116			$this->post($text, $channel, $additionalParameters);
117			}
118
119			public function send($text, ChannelInterface $channel)
120			{
121			$this->realTimeClient->send($text, $channel);
122			}
123
124			public function post($text, ChannelInterface $channel, array $additionalParameters = [])
125			{
126			$parameters = array_merge([
127			'text' => $text,
128			'channel' => $channel->getId(),
129			'as_user' => true,
130			], $additionalParameters);
131
132			$this->realTimeClient->apiCall('chat.postMessage', $parameters);
133			}
134
135			/**
136			* @param $id
137			* @return null\|User
138			*/
139			public function getUserById($id)
140			{
141			return $this->users->byId($id);
142			}
143
144			/**
145			* @param $name
146			* @return null\|User
147			*/
148			public function getUserByName($name)
149			{
150			return $this->users->byName($name);
151			}
152
153			/**
154			* @param $id
155			* @return null\|Channel
156			*/
157			public function getChannelById($id)
158			{
159			return $this->channels->byId($id);
160			}
161
162			/**
163			* @param $name
164			* @return null\|Channel
165			*/
166			public function getChannelByName($name)
167			{
168			return $this->channels->byName($name);
169			}
170
171			protected function useWebSocket() : bool
172			{
173			return (bool) $this->get('use.websocket', false);
174			}
175
176			protected function updateUsers()
177			{
178			$this->realTimeClient->getUsers()->then(function(array $users) {
179			$this->users->update($users);
180			});
181			}
182
183			protected function updateChannels()
184			{
185			$this->realTimeClient->getChannels()->then(function(array $channels) {
186			$this->channels->update($channels);
187			});
188			}
189
190			protected function updateAuthedUser(Closure $authedUserUpdated)
191			{
192			$this->realTimeClient->getAuthedUser()->then(function(User $user) use ($authedUserUpdated) {
193			$this->authedUser = $user;
194			$authedUserUpdated($user);
195			});
196			}
197
198			protected function initChannelUpdateHandlers()
199			{
200			$events = ['channel_created', 'channel_deleted', 'channel_rename'];
201			foreach ($events as $event) {
202			$this->onEvent($event, [$this, 'updateChannels']);
203			}
204			}
205
206			protected function initUserUpdateHandlers()
207			{
208			$events = ['user_change'];
209			foreach ($events as $event) {
210			$this->onEvent($event, [$this, 'updateUsers']);
211			}
212			}
213			}

nopolabs / yabot

Push — master ( 6ce725...0a0fa0 )

Client::updateChannels() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like