Botan::shortenUrl() - Code Metrics - Inspection of "Botan improvements and misc fixes" - akalongman/php-telegram-bot - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#365)

unknown

created 2016-12-27 18:56 UTC

Botan::shortenUrl() C

↳ Parent: Botan

Complexity

Conditions	8
Paths	31

Size

Total Lines	41
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	72

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	41
ccs	0
cts	36
cp	0
rs	5.3846
cc	8
eloc	26
nc	31
nop	2
crap	72

<?php
/**
 * This file is part of the TelegramBot package.
 *
 * (c) Avtandil Kikabidze aka LONGMAN <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Longman\TelegramBot;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use Longman\TelegramBot\Entities\Update;
use Longman\TelegramBot\Exception\TelegramException;

/**
 * Class Botan
 *
 * Integration with http://botan.io statistics service for Telegram bots
 */
class Botan
{
    /**
     * Botan.io API URL
     *
     * @var string
     */
    protected static $api_base_uri = 'https://api.botan.io';

    /**
     * Yandex AppMetrica application key
     *
     * @var string
     */
    protected static $token = '';

    /**
     * Guzzle Client object
     *
     * @var \GuzzleHttp\Client
     */
    private static $client;

    /**
     * The actual command that is going to be reported
     *
     *  Set as public to let the developers either:
     *  - block tracking from inside commands by setting the value to non-existent command
     *  - override which command is tracked when commands call other commands with executeCommand()
     *
     * @var string
     */
    public static $command = '';

    /**
     * Initialize Botan
     *
     * @param  string $token
     * @param  array  $options
     *
     * @throws \Longman\TelegramBot\Exception\TelegramException
     */
    public static function initializeBotan($token, array $options = [])
    {
        if (empty($token)) {
            throw new TelegramException('Botan token is empty!');
        }

        $options_default = [
            'timeout' => 3
        ];

        $options = array_merge($options_default, $options);

        if (!is_numeric($options['timeout'])) {
            throw new TelegramException('Timeout must be a number!');
        }

        self::$token  = $token;
        self::$client = new Client(['base_uri' => self::$api_base_uri, 'timeout' => $options['timeout']]);

        BotanDB::initializeBotanDb();
    }

    /**
     * Lock function to make sure only the first command is reported (the one user requested)
     *
     *  This is in case commands are calling other commands with executeCommand()
     *
     * @param string $command
     */
    public static function lock($command = '')
    {
        if (empty(self::$command)) {
            self::$command = strtolower($command);
        }
    }

    /**
     * Track function
     *
     * @param  \Longman\TelegramBot\Entities\Update $update
     * @param  string $command
     *
     * @return bool|string
     * @throws \Longman\TelegramBot\Exception\TelegramException
     */
    public static function track(Update $update, $command = '')
    {
        $command = strtolower($command);

        if (empty(self::$token) || $command !== self::$command) {
            return false;
        }

        if (empty($update)) {
            throw new TelegramException('Update object is empty!');
        }

        // Release the lock in case this is getUpdates instance in foreach loop
        self::$command = '';

        $data = [];
        $update_data = (array) $update; // For now, this is the only way
        $update_type = $update->getUpdateType();

        $update_object_names = [
            'message' => 'Message',
            'edited_message' => 'Edited Message',
            'channel_post' => 'Channel Post',
            'edited_channel_post' => 'Edited Channel Post',
            'inline_query' => 'Inline Query',
            'chosen_inline_result' => 'Chosen Inline Result',
            'callback_query' => 'Callback Query'
        ];

        if (in_array($update_type, ['message', 'edited_message', 'channel_post', 'edited_channel_post', 'inline_query', 'chosen_inline_result', 'callback_query'], true)) {
            $data       = $update_data[$update_type];
            $event_name = $update_object_names[$update_type];

            if ($update_type === 'message') {
                if ($update->getMessage()->getEntities()) {
                    foreach ($update->getMessage()->getEntities() as $entity) {
                        if ($entity->getType() === 'bot_command' && $entity->getOffset() === 0) {
                            if ($command === 'generic') {
                                $command = 'Generic';
                            } elseif ($command === 'genericmessage') {  // This should not happen as it equals normal message but leaving it as a fail-safe
                                $command = 'Generic Message';
                            } else {
                                $command = '/' . $command;
                            }

                            $event_name = 'Command (' . $command . ')';
                            break;
                        }
                    }
                }
            }
        }

        if (empty($event_name)) {
            TelegramLog::error("Botan.io stats report failed, no suitable update object found!");
            return false;
        }

        // In case there is no from field assign id = 0
        if (isset($data['from']['id'])) {
            $uid = $data['from']['id'];
        } else {
            $uid = 0;
        }

        try {
            $response = self::$client->post(
                str_replace(
                    ['#TOKEN', '#UID', '#NAME'],
                    [self::$token, $uid, urlencode($event_name)],
                    '/track?token=#TOKEN&uid=#UID&name=#NAME'
                ),
                [
                    'headers' => [
                        'Content-Type' => 'application/json'
                    ],
                    'json' => $data
                ]
            );

            $response = (string) $response->getBody();
        } catch (RequestException $e) {
            $response = ($e->getResponse()) ? (string) $e->getResponse()->getBody() : '';
        } finally {
            $responseData = json_decode($response, true);

            if ($responseData['status'] !== 'accepted') {
                if (!empty($response)) {
                    TelegramLog::debug("Botan.io stats report failed, API reply: $response");
                } else {
                    TelegramLog::debug("Botan.io stats report failed, API returned empty response!");
                }

                return false;
            }

            return $responseData;
        }
    }

    /**
     * Url Shortener function
     *
     * @param  string  $url
     * @param  integer $user_id
     *
     * @return string
     * @throws \Longman\TelegramBot\Exception\TelegramException
     */
    public static function shortenUrl($url, $user_id)
    {
        if (empty(self::$token)) {
            return $url;
        }

        if (empty($user_id)) {
            throw new TelegramException('User id is empty!');
        }

        if ($cached = BotanDB::selectShortUrl($user_id, $url)) {
            return $cached;
        }

        try {
            $response = self::$client->post(
                str_replace(
                    ['#TOKEN', '#UID', '#URL'],
                    [self::$token, $user_id, urlencode($url)],
                    '/s/?token=#TOKEN&user_ids=#UID&url=#URL'
                )
            );

            $response = (string) $response->getBody();
        } catch (RequestException $e) {
            $response = ($e->getResponse()) ? (string) $e->getResponse()->getBody() : '';
        } finally {
            if (filter_var($response, FILTER_VALIDATE_URL) !== false) {
                BotanDB::insertShortUrl($user_id, $url, $response);
                return $response;
            } else {
                if (!empty($response)) {
                    TelegramLog::debug("Botan.io URL shortening failed for '$url', API reply: $response");
                } else {
                    TelegramLog::debug("Botan.io URL shortening failed for '$url', API returned empty response!");
                }

                return $url;
            }
        }
    }
}


1			<?php
2			/**
3			* This file is part of the TelegramBot package.
4			*
5			* (c) Avtandil Kikabidze aka LONGMAN <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Longman\TelegramBot;
12
13			use GuzzleHttp\Client;
14			use GuzzleHttp\Exception\RequestException;
15			use Longman\TelegramBot\Entities\Update;
16			use Longman\TelegramBot\Exception\TelegramException;
17
18			/**
19			* Class Botan
20			*
21			* Integration with http://botan.io statistics service for Telegram bots
22			*/
23			class Botan
24			{
25			/**
26			* Botan.io API URL
27			*
28			* @var string
29			*/
30			protected static $api_base_uri = 'https://api.botan.io';
31
32			/**
33			* Yandex AppMetrica application key
34			*
35			* @var string
36			*/
37			protected static $token = '';
38
39			/**
40			* Guzzle Client object
41			*
42			* @var \GuzzleHttp\Client
43			*/
44			private static $client;
45
46			/**
47			* The actual command that is going to be reported
48			*
49			* Set as public to let the developers either:
50			* - block tracking from inside commands by setting the value to non-existent command
51			* - override which command is tracked when commands call other commands with executeCommand()
52			*
53			* @var string
54			*/
55			public static $command = '';
56
57			/**
58			* Initialize Botan
59			*
60			* @param string $token
61			* @param array $options
62			*
63			* @throws \Longman\TelegramBot\Exception\TelegramException
64			*/
65			public static function initializeBotan($token, array $options = [])
66			{
67			if (empty($token)) {
68			throw new TelegramException('Botan token is empty!');
69			}
70
71			$options_default = [
72			'timeout' => 3
73			];
74
75			$options = array_merge($options_default, $options);
76
77			if (!is_numeric($options['timeout'])) {
78			throw new TelegramException('Timeout must be a number!');
79			}
80
81			self::$token = $token;
82			self::$client = new Client(['base_uri' => self::$api_base_uri, 'timeout' => $options['timeout']]);
83
84			BotanDB::initializeBotanDb();
85			}
86
87			/**
88			* Lock function to make sure only the first command is reported (the one user requested)
89			*
90			* This is in case commands are calling other commands with executeCommand()
91			*
92			* @param string $command
93			*/
94			public static function lock($command = '')
95			{
96			if (empty(self::$command)) {
97			self::$command = strtolower($command);
98			}
99			}
100
101			/**
102			* Track function
103			*
104			* @param \Longman\TelegramBot\Entities\Update $update
105			* @param string $command
106			*
107			* @return bool\|string
108			* @throws \Longman\TelegramBot\Exception\TelegramException
109			*/
110			public static function track(Update $update, $command = '')
111			{
112			$command = strtolower($command);
113
114			if (empty(self::$token) \|\| $command !== self::$command) {
115			return false;
116			}
117
118			if (empty($update)) {
119			throw new TelegramException('Update object is empty!');
120			}
121
122			// Release the lock in case this is getUpdates instance in foreach loop
123			self::$command = '';
124
125			$data = [];
126			$update_data = (array) $update; // For now, this is the only way
127			$update_type = $update->getUpdateType();
128
129			$update_object_names = [
130			'message' => 'Message',
131			'edited_message' => 'Edited Message',
132			'channel_post' => 'Channel Post',
133			'edited_channel_post' => 'Edited Channel Post',
134			'inline_query' => 'Inline Query',
135			'chosen_inline_result' => 'Chosen Inline Result',
136			'callback_query' => 'Callback Query'
137			];
138
139			if (in_array($update_type, ['message', 'edited_message', 'channel_post', 'edited_channel_post', 'inline_query', 'chosen_inline_result', 'callback_query'], true)) {
140			$data = $update_data[$update_type];
141			$event_name = $update_object_names[$update_type];
142
143			if ($update_type === 'message') {
144			if ($update->getMessage()->getEntities()) {
145			foreach ($update->getMessage()->getEntities() as $entity) {
146			if ($entity->getType() === 'bot_command' && $entity->getOffset() === 0) {
147			if ($command === 'generic') {
148			$command = 'Generic';
149			} elseif ($command === 'genericmessage') { // This should not happen as it equals normal message but leaving it as a fail-safe
150			$command = 'Generic Message';
151			} else {
152			$command = '/' . $command;
153			}
154
155			$event_name = 'Command (' . $command . ')';
156			break;
157			}
158			}
159			}
160			}
161			}
162
163			if (empty($event_name)) {
164			TelegramLog::error("Botan.io stats report failed, no suitable update object found!");
165			return false;
166			}
167
168			// In case there is no from field assign id = 0
169			if (isset($data['from']['id'])) {
170			$uid = $data['from']['id'];
171			} else {
172			$uid = 0;
173			}
174
175			try {
176			$response = self::$client->post(
177			str_replace(
178			['#TOKEN', '#UID', '#NAME'],
179			[self::$token, $uid, urlencode($event_name)],
180			'/track?token=#TOKEN&uid=#UID&name=#NAME'
181			),
182			[
183			'headers' => [
184			'Content-Type' => 'application/json'
185			],
186			'json' => $data
187			]
188			);
189
190			$response = (string) $response->getBody();
191			} catch (RequestException $e) {
192			$response = ($e->getResponse()) ? (string) $e->getResponse()->getBody() : '';
193			} finally {
194			$responseData = json_decode($response, true);
195
196			if ($responseData['status'] !== 'accepted') {
197			if (!empty($response)) {
198			TelegramLog::debug("Botan.io stats report failed, API reply: $response");
199			} else {
200			TelegramLog::debug("Botan.io stats report failed, API returned empty response!");
201			}
202
203			return false;
204			}
205
206			return $responseData;
207			}
208			}
209
210			/**
211			* Url Shortener function
212			*
213			* @param string $url
214			* @param integer $user_id
215			*
216			* @return string
217			* @throws \Longman\TelegramBot\Exception\TelegramException
218			*/
219			public static function shortenUrl($url, $user_id)
220			{
221			if (empty(self::$token)) {
222			return $url;
223			}
224
225			if (empty($user_id)) {
226			throw new TelegramException('User id is empty!');
227			}
228
229			if ($cached = BotanDB::selectShortUrl($user_id, $url)) {
230			return $cached;
231			}
232
233			try {
234			$response = self::$client->post(
235			str_replace(
236			['#TOKEN', '#UID', '#URL'],
237			[self::$token, $user_id, urlencode($url)],
238			'/s/?token=#TOKEN&user_ids=#UID&url=#URL'
239			)
240			);
241
242			$response = (string) $response->getBody();
243			} catch (RequestException $e) {
244			$response = ($e->getResponse()) ? (string) $e->getResponse()->getBody() : '';
245			} finally {
246			if (filter_var($response, FILTER_VALIDATE_URL) !== false) {
247			BotanDB::insertShortUrl($user_id, $url, $response);
248			return $response;
249			} else {
250			if (!empty($response)) {
251			TelegramLog::debug("Botan.io URL shortening failed for '$url', API reply: $response");
252			} else {
253			TelegramLog::debug("Botan.io URL shortening failed for '$url', API returned empty response!");
254			}
255
256			return $url;
257			}
258			}
259			}
260			}
261

akalongman / php-telegram-bot

Pull Request — develop (#365)

Botan::shortenUrl() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like