BotsManager::disconnect() - Code Metrics - Inspection of "Multi-Bot Support - WIP" - irazasyed/telegram-bot-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 776bcf...e74f71 )

by Irfaq

created 2015-12-30 03:30 UTC

BotsManager::disconnect() A

↳ Parent: BotsManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
ccs	0
cts	4
cp	0
rs	9.4286
cc	2
eloc	3
nc	2
nop	1
crap	6

<?php

namespace Telegram\Bot;

use Illuminate\Contracts\Config\Repository;
use Illuminate\Contracts\Foundation\Application;
use InvalidArgumentException;

/**
 * Class BotsManager
 *
 * @TODO Add methods in docblock for autocompletion from Api file.
 */
class BotsManager
{
    /**
     * The config instance.
     *
     * @var \Illuminate\Contracts\Config\Repository
     */
    protected $config;

    /**
     * The app instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application
     */
    protected $app;

    /**
     * @var string Config Name
     */
    protected $configName = 'telegram';

    /**
     * The active bot instances.
     *
     * @var array
     */
    protected $bots = [];

    /**
     * TelegramManager constructor.
     *
     * @param Repository  $config
     * @param Application $app
     */
    public function __construct(Repository $config, Application $app)
    {
        $this->config = $config;
        $this->app = $app;
    }

    /**
     * Get the configuration for a bot.
     *
     * @param string $name
     *
     * @throws \InvalidArgumentException
     *
     * @return array
     */
    public function getBotConfig($name)
    {
        $name = $name ?: $this->getDefaultBot();

        $bots = $this->getConfig('bots');
        if (!is_array($config = array_get($bots, $name)) && !$config) {
            throw new InvalidArgumentException("Bot [$name] not configured.");
        }

        $config['bot'] = $name;

        return $config;
    }

    /**
     * Get a bot instance.
     *
     * @param string $name
     *
     * @return object
     */
    public function bot($name = null)
    {
        $name = $name ?: $this->getDefaultBot();

        if (!isset($this->bots[$name])) {
            $this->bots[$name] = $this->makeBot($name);
        }

        return $this->bots[$name];
    }

    /**
     * Reconnect to the given bot.
     *
     * @param string $name
     *
     * @return object
     */
    public function reconnect($name = null)
    {
        $name = $name ?: $this->getDefaultBot();
        $this->disconnect($name);

        return $this->bot($name);
    }

    /**
     * Disconnect from the given bot.
     *
     * @param string $name
     *
     * @return void
     */
    public function disconnect($name = null)
    {
        $name = $name ?: $this->getDefaultBot();
        unset($this->bots[$name]);
    }

    /**
     * Get the specified configuration value for Telegram.
     *
     * @param  string $key
     * @param  mixed  $default
     *
     * @return mixed
     */
    public function getConfig($key, $default = null)
    {
        return $this->config->get($this->configName.'.'.$key, $default);
    }

    /**
     * Get the default bot name.
     *
     * @return string
     */
    public function getDefaultBot()
    {
        return $this->getConfig('default');
    }

    /**
     * Set the default bot name.
     *
     * @param string $name
     *
     * @return void
     */
    public function setDefaultBot($name)
    {
        $this->config->set($this->configName.'.default', $name);
    }

    /**
     * Return all of the created bots.
     *
     * @return object[]
     */
    public function getBots()
    {
        return $this->bots;
    }

    /**
     * De-duplicate an array.
     *
     * @param array $array
     *
     * @return array
     */
    protected function deduplicateArray(array $array)
    {
        return array_values(array_unique($array));
    }

    /**
     * Make the bot instance.
     *
     * @param string $name
     *
     * @return Api
     */
    protected function makeBot($name)
    {
        $config = $this->getBotConfig($name);

        $token = array_get($config, 'token');
        $commands = array_get($config, 'commands', []);

        $telegram = new Api(
            $token,
            $this->getConfig('async_requests', false),
            $this->getConfig('http_client_handler', null)
        );

        // Check if DI needs to be enabled for Commands
        if ($this->getConfig('resolve_command_dependencies', true)) {
            $telegram->setContainer($this->app);
        }

        $commands = $this->parseBotCommands($commands);

        // Register Commands
        $telegram->addCommands($commands);

        return $telegram;
    }

    /**
     * Builds the list of commands for the given commands array.
     *
     * @param array $commands
     *
     * @return array An array of commands which includes global and bot specific commands.
     */
    protected function parseBotCommands(array $commands)
    {
        $globalCommands = $this->getConfig('commands', []);
        $parsedCommands = $this->parseCommands($commands);

        return $this->deduplicateArray(array_merge($globalCommands, $parsedCommands));
    }

    /**
     * Parse an array of commands and build a list.
     *
     * @param array $commands
     *
     * @return array
     */
    protected function parseCommands(array $commands)
    {
        if (!is_array($commands)) {
            return $commands;
        }

        $commandGroups = $this->getConfig('command_groups');
        $sharedCommands = $this->getConfig('shared_commands');

        $results = [];
        foreach ($commands as $command) {
            // If the command is a group, we'll parse through the group of commands
            // and resolve the full class name.
            if (isset($commandGroups[$command])) {
                $results = array_merge(
                    $results, $this->parseCommands($commandGroups[$command])
                );

                continue;

            }

            // If this command is actually a shared command, we'll extract the full
            // class name out of the command list now.
            if (isset($sharedCommands[$command])) {
                $command = $sharedCommands[$command];
            }

            if (!in_array($command, $results)) {
                $results[] = $command;
            }
        }

        return $results;
    }

    /**
     * Magically pass methods to the default bot.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        return call_user_func_array([$this->bot(), $method], $parameters);
    }
}

1			<?php
2
3			namespace Telegram\Bot;
4
5			use Illuminate\Contracts\Config\Repository;
6			use Illuminate\Contracts\Foundation\Application;
7			use InvalidArgumentException;
8
9			/**
10			* Class BotsManager
11			*
12			* @TODO Add methods in docblock for autocompletion from Api file.
13			*/
14			class BotsManager
15			{
16			/**
17			* The config instance.
18			*
19			* @var \Illuminate\Contracts\Config\Repository
20			*/
21			protected $config;
22
23			/**
24			* The app instance.
25			*
26			* @var \Illuminate\Contracts\Foundation\Application
27			*/
28			protected $app;
29
30			/**
31			* @var string Config Name
32			*/
33			protected $configName = 'telegram';
34
35			/**
36			* The active bot instances.
37			*
38			* @var array
39			*/
40			protected $bots = [];
41
42			/**
43			* TelegramManager constructor.
44			*
45			* @param Repository $config
46			* @param Application $app
47			*/
48			public function __construct(Repository $config, Application $app)
49			{
50			$this->config = $config;
51			$this->app = $app;
52			}
53
54			/**
55			* Get the configuration for a bot.
56			*
57			* @param string $name
58			*
59			* @throws \InvalidArgumentException
60			*
61			* @return array
62			*/
63			public function getBotConfig($name)
64			{
65			$name = $name ?: $this->getDefaultBot();
66
67			$bots = $this->getConfig('bots');
68			if (!is_array($config = array_get($bots, $name)) && !$config) {
69			throw new InvalidArgumentException("Bot [$name] not configured.");
70			}
71
72			$config['bot'] = $name;
73
74			return $config;
75			}
76
77			/**
78			* Get a bot instance.
79			*
80			* @param string $name
81			*
82			* @return object
83			*/
84			public function bot($name = null)
85			{
86			$name = $name ?: $this->getDefaultBot();
87
88			if (!isset($this->bots[$name])) {
89			$this->bots[$name] = $this->makeBot($name);
90			}
91
92			return $this->bots[$name];
93			}
94
95			/**
96			* Reconnect to the given bot.
97			*
98			* @param string $name
99			*
100			* @return object
101			*/
102			public function reconnect($name = null)
103			{
104			$name = $name ?: $this->getDefaultBot();
105			$this->disconnect($name);
106
107			return $this->bot($name);
108			}
109
110			/**
111			* Disconnect from the given bot.
112			*
113			* @param string $name
114			*
115			* @return void
116			*/
117			public function disconnect($name = null)
118			{
119			$name = $name ?: $this->getDefaultBot();
120			unset($this->bots[$name]);
121			}
122
123			/**
124			* Get the specified configuration value for Telegram.
125			*
126			* @param string $key
127			* @param mixed $default
128			*
129			* @return mixed
130			*/
131			public function getConfig($key, $default = null)
132			{
133			return $this->config->get($this->configName.'.'.$key, $default);
134			}
135
136			/**
137			* Get the default bot name.
138			*
139			* @return string
140			*/
141			public function getDefaultBot()
142			{
143			return $this->getConfig('default');
144			}
145
146			/**
147			* Set the default bot name.
148			*
149			* @param string $name
150			*
151			* @return void
152			*/
153			public function setDefaultBot($name)
154			{
155			$this->config->set($this->configName.'.default', $name);
156			}
157
158			/**
159			* Return all of the created bots.
160			*
161			* @return object[]
162			*/
163			public function getBots()
164			{
165			return $this->bots;
166			}
167
168			/**
169			* De-duplicate an array.
170			*
171			* @param array $array
172			*
173			* @return array
174			*/
175			protected function deduplicateArray(array $array)
176			{
177			return array_values(array_unique($array));
178			}
179
180			/**
181			* Make the bot instance.
182			*
183			* @param string $name
184			*
185			* @return Api
186			*/
187			protected function makeBot($name)
188			{
189			$config = $this->getBotConfig($name);
190
191			$token = array_get($config, 'token');
192			$commands = array_get($config, 'commands', []);
193
194			$telegram = new Api(
195			$token,
196			$this->getConfig('async_requests', false),
197			$this->getConfig('http_client_handler', null)
198			);
199
200			// Check if DI needs to be enabled for Commands
201			if ($this->getConfig('resolve_command_dependencies', true)) {
202			$telegram->setContainer($this->app);
203			}
204
205			$commands = $this->parseBotCommands($commands);
206
207			// Register Commands
208			$telegram->addCommands($commands);
209
210			return $telegram;
211			}
212
213			/**
214			* Builds the list of commands for the given commands array.
215			*
216			* @param array $commands
217			*
218			* @return array An array of commands which includes global and bot specific commands.
219			*/
220			protected function parseBotCommands(array $commands)
221			{
222			$globalCommands = $this->getConfig('commands', []);
223			$parsedCommands = $this->parseCommands($commands);
224
225			return $this->deduplicateArray(array_merge($globalCommands, $parsedCommands));
226			}
227
228			/**
229			* Parse an array of commands and build a list.
230			*
231			* @param array $commands
232			*
233			* @return array
234			*/
235			protected function parseCommands(array $commands)
236			{
237			if (!is_array($commands)) {
238			return $commands;
239			}
240
241			$commandGroups = $this->getConfig('command_groups');
242			$sharedCommands = $this->getConfig('shared_commands');
243
244			$results = [];
245			foreach ($commands as $command) {
246			// If the command is a group, we'll parse through the group of commands
247			// and resolve the full class name.
248			if (isset($commandGroups[$command])) {
249			$results = array_merge(
250			$results, $this->parseCommands($commandGroups[$command])
251			);
252
253			continue;
254
255			}
256
257			// If this command is actually a shared command, we'll extract the full
258			// class name out of the command list now.
259			if (isset($sharedCommands[$command])) {
260			$command = $sharedCommands[$command];
261			}
262
263			if (!in_array($command, $results)) {
264			$results[] = $command;
265			}
266			}
267
268			return $results;
269			}
270
271			/**
272			* Magically pass methods to the default bot.
273			*
274			* @param string $method
275			* @param array $parameters
276			*
277			* @return mixed
278			*/
279			public function __call($method, $parameters)
280			{
281			return call_user_func_array([$this->bot(), $method], $parameters);
282			}
283			}

irazasyed / telegram-bot-sdk

Push — master ( 776bcf...e74f71 )

BotsManager::disconnect() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like