|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
namespace Telegram\Bot; |
|
4
|
|
|
|
|
5
|
|
|
use Illuminate\Contracts\Container\Container; |
|
6
|
|
|
use Telegram\Bot\Commands\CommandBus; |
|
7
|
|
|
use Telegram\Bot\Events\EmitsEvents; |
|
8
|
|
|
use Telegram\Bot\Events\UpdateWasReceived; |
|
9
|
|
|
use Telegram\Bot\Exceptions\TelegramSDKException; |
|
10
|
|
|
use Telegram\Bot\FileUpload\InputFile; |
|
11
|
|
|
use Telegram\Bot\HttpClients\HttpClientInterface; |
|
12
|
|
|
use Telegram\Bot\Objects\Chat; |
|
13
|
|
|
use Telegram\Bot\Objects\ChatMember; |
|
14
|
|
|
use Telegram\Bot\Objects\File; |
|
15
|
|
|
use Telegram\Bot\Objects\Message; |
|
16
|
|
|
use Telegram\Bot\Objects\UnknownObject; |
|
17
|
|
|
use Telegram\Bot\Objects\Update; |
|
18
|
|
|
use Telegram\Bot\Objects\User; |
|
19
|
|
|
use Telegram\Bot\Objects\UserProfilePhotos; |
|
20
|
|
|
use Telegram\Bot\Keyboard\Keyboard; |
|
21
|
|
|
|
|
22
|
|
|
/** |
|
23
|
|
|
* Class Api. |
|
24
|
|
|
* |
|
25
|
|
|
* @mixin Commands\CommandBus |
|
26
|
|
|
*/ |
|
27
|
|
|
class Api |
|
28
|
|
|
{ |
|
29
|
|
|
use EmitsEvents; |
|
30
|
|
|
|
|
31
|
|
|
/** |
|
32
|
|
|
* @var string Version number of the Telegram Bot PHP SDK. |
|
33
|
|
|
*/ |
|
34
|
|
|
const VERSION = '3.0.0'; |
|
35
|
|
|
|
|
36
|
|
|
/** |
|
37
|
|
|
* @var string The name of the environment variable that contains the Telegram Bot API Access Token. |
|
38
|
|
|
*/ |
|
39
|
|
|
const BOT_TOKEN_ENV_NAME = 'TELEGRAM_BOT_TOKEN'; |
|
40
|
|
|
|
|
41
|
|
|
/** |
|
42
|
|
|
* @var TelegramClient The Telegram client service. |
|
43
|
|
|
*/ |
|
44
|
|
|
protected $client; |
|
45
|
|
|
|
|
46
|
|
|
/** |
|
47
|
|
|
* @var string Telegram Bot API Access Token. |
|
48
|
|
|
*/ |
|
49
|
|
|
protected $accessToken = null; |
|
50
|
|
|
|
|
51
|
|
|
/** |
|
52
|
|
|
* @var TelegramResponse|null Stores the last request made to Telegram Bot API. |
|
53
|
|
|
*/ |
|
54
|
|
|
protected $lastResponse; |
|
55
|
|
|
|
|
56
|
|
|
/** |
|
57
|
|
|
* @var bool Indicates if the request to Telegram will be asynchronous (non-blocking). |
|
58
|
|
|
*/ |
|
59
|
|
|
protected $isAsyncRequest = false; |
|
60
|
|
|
|
|
61
|
|
|
/** |
|
62
|
|
|
* @var CommandBus|null Telegram Command Bus. |
|
63
|
|
|
*/ |
|
64
|
|
|
protected $commandBus = null; |
|
65
|
|
|
|
|
66
|
|
|
/** |
|
67
|
|
|
* @var Container IoC Container |
|
68
|
|
|
*/ |
|
69
|
|
|
protected static $container = null; |
|
70
|
|
|
|
|
71
|
|
|
/** |
|
72
|
|
|
* Timeout of the request in seconds. |
|
73
|
|
|
* |
|
74
|
|
|
* @var int |
|
75
|
|
|
*/ |
|
76
|
|
|
protected $timeOut = 60; |
|
77
|
|
|
|
|
78
|
|
|
/** |
|
79
|
|
|
* Connection timeout of the request in seconds. |
|
80
|
|
|
* |
|
81
|
|
|
* @var int |
|
82
|
|
|
*/ |
|
83
|
|
|
protected $connectTimeOut = 10; |
|
84
|
|
|
|
|
85
|
|
|
/** |
|
86
|
|
|
* Instantiates a new Telegram super-class object. |
|
87
|
|
|
* |
|
88
|
|
|
* |
|
89
|
|
|
* @param string $token The Telegram Bot API Access Token. |
|
90
|
|
|
* @param bool $async (Optional) Indicates if the request to Telegram |
|
91
|
|
|
* will be asynchronous (non-blocking). |
|
92
|
|
|
* @param HttpClientInterface $httpClientHandler (Optional) Custom HTTP Client Handler. |
|
93
|
|
|
* |
|
94
|
|
|
* @throws TelegramSDKException |
|
95
|
|
|
*/ |
|
96
|
66 |
|
public function __construct($token = null, $async = false, $httpClientHandler = null) |
|
97
|
|
|
{ |
|
98
|
66 |
|
$this->accessToken = isset($token) ? $token : getenv(static::BOT_TOKEN_ENV_NAME); |
|
99
|
66 |
|
if (!$this->accessToken) { |
|
100
|
2 |
|
throw new TelegramSDKException('Required "token" not supplied in config and could not find fallback environment variable "'.static::BOT_TOKEN_ENV_NAME.'"'); |
|
101
|
|
|
} |
|
102
|
|
|
|
|
103
|
66 |
|
if (isset($async)) { |
|
104
|
66 |
|
$this->setAsyncRequest($async); |
|
105
|
66 |
|
} |
|
106
|
|
|
|
|
107
|
66 |
|
$this->client = new TelegramClient($httpClientHandler); |
|
108
|
66 |
|
$this->commandBus = new CommandBus($this); |
|
109
|
66 |
|
} |
|
110
|
|
|
|
|
111
|
|
|
/** |
|
112
|
|
|
* Invoke Bots Manager. |
|
113
|
|
|
* |
|
114
|
|
|
* @param $config |
|
115
|
|
|
* |
|
116
|
|
|
* @return BotsManager |
|
117
|
|
|
*/ |
|
118
|
|
|
public static function manager($config) |
|
119
|
|
|
{ |
|
120
|
|
|
return new BotsManager($config); |
|
121
|
|
|
} |
|
122
|
|
|
|
|
123
|
|
|
/** |
|
124
|
|
|
* Returns the TelegramClient service. |
|
125
|
|
|
* |
|
126
|
|
|
* @return TelegramClient |
|
127
|
|
|
*/ |
|
128
|
6 |
|
public function getClient() |
|
129
|
|
|
{ |
|
130
|
6 |
|
return $this->client; |
|
131
|
|
|
} |
|
132
|
|
|
|
|
133
|
|
|
/** |
|
134
|
|
|
* Returns Telegram Bot API Access Token. |
|
135
|
|
|
* |
|
136
|
|
|
* @return string |
|
137
|
|
|
*/ |
|
138
|
42 |
|
public function getAccessToken() |
|
139
|
|
|
{ |
|
140
|
42 |
|
return $this->accessToken; |
|
141
|
|
|
} |
|
142
|
|
|
|
|
143
|
|
|
/** |
|
144
|
|
|
* Returns the last response returned from API request. |
|
145
|
|
|
* |
|
146
|
|
|
* @return TelegramResponse |
|
147
|
|
|
*/ |
|
148
|
2 |
|
public function getLastResponse() |
|
149
|
|
|
{ |
|
150
|
2 |
|
return $this->lastResponse; |
|
151
|
|
|
} |
|
152
|
|
|
|
|
153
|
|
|
/** |
|
154
|
|
|
* Sets the bot access token to use with API requests. |
|
155
|
|
|
* |
|
156
|
|
|
* @param string $accessToken The bot access token to save. |
|
157
|
|
|
* |
|
158
|
|
|
* @throws \InvalidArgumentException |
|
159
|
|
|
* |
|
160
|
|
|
* @return Api |
|
161
|
|
|
*/ |
|
162
|
8 |
|
public function setAccessToken($accessToken) |
|
163
|
|
|
{ |
|
164
|
8 |
|
if (is_string($accessToken)) { |
|
165
|
2 |
|
$this->accessToken = $accessToken; |
|
166
|
|
|
|
|
167
|
2 |
|
return $this; |
|
168
|
|
|
} |
|
169
|
|
|
|
|
170
|
6 |
|
throw new \InvalidArgumentException('The Telegram bot access token must be of type "string"'); |
|
171
|
|
|
} |
|
172
|
|
|
|
|
173
|
|
|
/** |
|
174
|
|
|
* Make this request asynchronous (non-blocking). |
|
175
|
|
|
* |
|
176
|
|
|
* @param bool $isAsyncRequest |
|
177
|
|
|
* |
|
178
|
|
|
* @return Api |
|
179
|
|
|
*/ |
|
180
|
66 |
|
public function setAsyncRequest($isAsyncRequest) |
|
181
|
|
|
{ |
|
182
|
66 |
|
$this->isAsyncRequest = $isAsyncRequest; |
|
183
|
|
|
|
|
184
|
66 |
|
return $this; |
|
185
|
|
|
} |
|
186
|
|
|
|
|
187
|
|
|
/** |
|
188
|
|
|
* Check if this is an asynchronous request (non-blocking). |
|
189
|
|
|
* |
|
190
|
|
|
* @return bool |
|
191
|
|
|
*/ |
|
192
|
42 |
|
public function isAsyncRequest() |
|
193
|
|
|
{ |
|
194
|
42 |
|
return $this->isAsyncRequest; |
|
195
|
|
|
} |
|
196
|
|
|
|
|
197
|
|
|
/** |
|
198
|
|
|
* Returns SDK's Command Bus. |
|
199
|
|
|
* |
|
200
|
|
|
* @return CommandBus |
|
201
|
|
|
*/ |
|
202
|
8 |
|
public function getCommandBus() |
|
203
|
|
|
{ |
|
204
|
8 |
|
return $this->commandBus; |
|
205
|
|
|
} |
|
206
|
|
|
|
|
207
|
|
|
/** |
|
208
|
|
|
* A simple method for testing your bot's auth token. |
|
209
|
|
|
* Returns basic information about the bot in form of a User object. |
|
210
|
|
|
* |
|
211
|
|
|
* @link https://core.telegram.org/bots/api#getme |
|
212
|
|
|
* |
|
213
|
|
|
* @throws TelegramSDKException |
|
214
|
|
|
* |
|
215
|
|
|
* @return User |
|
216
|
|
|
*/ |
|
217
|
4 |
|
public function getMe() |
|
218
|
|
|
{ |
|
219
|
4 |
|
$response = $this->post('getMe'); |
|
220
|
|
|
|
|
221
|
2 |
|
return new User($response->getDecodedBody()); |
|
222
|
|
|
} |
|
223
|
|
|
|
|
224
|
|
|
/** |
|
225
|
|
|
* Send text messages. |
|
226
|
|
|
* |
|
227
|
|
|
* <code> |
|
228
|
|
|
* $params = [ |
|
229
|
|
|
* 'chat_id' => '', |
|
230
|
|
|
* 'text' => '', |
|
231
|
|
|
* 'parse_mode' => '', |
|
232
|
|
|
* 'disable_web_page_preview' => '', |
|
233
|
|
|
* 'disable_notification' => '', |
|
234
|
|
|
* 'reply_to_message_id' => '', |
|
235
|
|
|
* 'reply_markup' => '', |
|
236
|
|
|
* ]; |
|
237
|
|
|
* </code> |
|
238
|
|
|
* |
|
239
|
|
|
* @link https://core.telegram.org/bots/api#sendmessage |
|
240
|
|
|
* |
|
241
|
|
|
* @param array $params |
|
242
|
|
|
* |
|
243
|
|
|
* @var int|string $params ['chat_id'] |
|
244
|
|
|
* @var string $params ['text'] |
|
245
|
|
|
* @var string $params ['parse_mode'] |
|
246
|
|
|
* @var bool $params ['disable_web_page_preview'] |
|
247
|
|
|
* @var bool $params ['disable_notification'] |
|
248
|
|
|
* @var int $params ['reply_to_message_id'] |
|
249
|
|
|
* @var string $params ['reply_markup'] |
|
250
|
|
|
* |
|
251
|
|
|
* @throws TelegramSDKException |
|
252
|
|
|
* |
|
253
|
|
|
* @return Message |
|
254
|
|
|
*/ |
|
255
|
4 |
|
public function sendMessage(array $params) |
|
256
|
|
|
{ |
|
257
|
4 |
|
$response = $this->post('sendMessage', $params); |
|
258
|
|
|
|
|
259
|
4 |
|
return new Message($response->getDecodedBody()); |
|
260
|
|
|
} |
|
261
|
|
|
|
|
262
|
|
|
/** |
|
263
|
|
|
* Forward messages of any kind. |
|
264
|
|
|
* |
|
265
|
|
|
* <code> |
|
266
|
|
|
* $params = [ |
|
267
|
|
|
* 'chat_id' => '', |
|
268
|
|
|
* 'from_chat_id' => '', |
|
269
|
|
|
* 'disable_notification' => '', |
|
270
|
|
|
* 'message_id' => '', |
|
271
|
|
|
* ]; |
|
272
|
|
|
* </code> |
|
273
|
|
|
* |
|
274
|
|
|
* @link https://core.telegram.org/bots/api#forwardmessage |
|
275
|
|
|
* |
|
276
|
|
|
* @param array $params |
|
277
|
|
|
* |
|
278
|
|
|
* @var int|string $params ['chat_id'] |
|
279
|
|
|
* @var int $params ['from_chat_id'] |
|
280
|
|
|
* @var bool $params ['disable_notification'] |
|
281
|
|
|
* @var int $params ['message_id'] |
|
282
|
|
|
* |
|
283
|
|
|
* @throws TelegramSDKException |
|
284
|
|
|
* |
|
285
|
|
|
* @return Message |
|
286
|
|
|
*/ |
|
287
|
2 |
|
public function forwardMessage(array $params) |
|
288
|
|
|
{ |
|
289
|
2 |
|
$response = $this->post('forwardMessage', $params); |
|
290
|
|
|
|
|
291
|
2 |
|
return new Message($response->getDecodedBody()); |
|
292
|
|
|
} |
|
293
|
|
|
|
|
294
|
|
|
/** |
|
295
|
|
|
* Send Photos. |
|
296
|
|
|
* |
|
297
|
|
|
* <code> |
|
298
|
|
|
* $params = [ |
|
299
|
|
|
* 'chat_id' => '', |
|
300
|
|
|
* 'photo' => '', |
|
301
|
|
|
* 'caption' => '', |
|
302
|
|
|
* 'disable_notification' => '', |
|
303
|
|
|
* 'reply_to_message_id' => '', |
|
304
|
|
|
* 'reply_markup' => '', |
|
305
|
|
|
* ]; |
|
306
|
|
|
* </code> |
|
307
|
|
|
* |
|
308
|
|
|
* @link https://core.telegram.org/bots/api#sendphoto |
|
309
|
|
|
* |
|
310
|
|
|
* @param array $params |
|
311
|
|
|
* |
|
312
|
|
|
* @var int|string $params ['chat_id'] |
|
313
|
|
|
* @var string $params ['photo'] |
|
314
|
|
|
* @var string $params ['caption'] |
|
315
|
|
|
* @var bool $params ['disable_notification'] |
|
316
|
|
|
* @var int $params ['reply_to_message_id'] |
|
317
|
|
|
* @var string $params ['reply_markup'] |
|
318
|
|
|
* |
|
319
|
|
|
* @throws TelegramSDKException |
|
320
|
|
|
* |
|
321
|
|
|
* @return Message |
|
322
|
|
|
*/ |
|
323
|
4 |
|
public function sendPhoto(array $params) |
|
324
|
|
|
{ |
|
325
|
4 |
|
$response = $this->uploadFile('sendPhoto', $params); |
|
326
|
|
|
|
|
327
|
4 |
|
return new Message($response->getDecodedBody()); |
|
328
|
|
|
} |
|
329
|
|
|
|
|
330
|
|
|
/** |
|
331
|
|
|
* Send regular audio files. |
|
332
|
|
|
* |
|
333
|
|
|
* <code> |
|
334
|
|
|
* $params = [ |
|
335
|
|
|
* 'chat_id' => '', |
|
336
|
|
|
* 'audio' => '', |
|
337
|
|
|
* 'duration' => '', |
|
338
|
|
|
* 'performer' => '', |
|
339
|
|
|
* 'title' => '', |
|
340
|
|
|
* 'disable_notification' => '', |
|
341
|
|
|
* 'reply_to_message_id' => '', |
|
342
|
|
|
* 'reply_markup' => '', |
|
343
|
|
|
* ]; |
|
344
|
|
|
* </code> |
|
345
|
|
|
* |
|
346
|
|
|
* @link https://core.telegram.org/bots/api#sendaudio |
|
347
|
|
|
* |
|
348
|
|
|
* @param array $params |
|
349
|
|
|
* |
|
350
|
|
|
* @var int|string $params ['chat_id'] |
|
351
|
|
|
* @var string $params ['audio'] |
|
352
|
|
|
* @var int $params ['duration'] |
|
353
|
|
|
* @var string $params ['performer'] |
|
354
|
|
|
* @var string $params ['title'] |
|
355
|
|
|
* @var bool $params ['disable_notification'] |
|
356
|
|
|
* @var int $params ['reply_to_message_id'] |
|
357
|
|
|
* @var string $params ['reply_markup'] |
|
358
|
|
|
* |
|
359
|
|
|
* @throws TelegramSDKException |
|
360
|
|
|
* |
|
361
|
|
|
* @return Message |
|
362
|
|
|
*/ |
|
363
|
2 |
|
public function sendAudio(array $params) |
|
364
|
|
|
{ |
|
365
|
2 |
|
$response = $this->uploadFile('sendAudio', $params); |
|
366
|
|
|
|
|
367
|
2 |
|
return new Message($response->getDecodedBody()); |
|
368
|
|
|
} |
|
369
|
|
|
|
|
370
|
|
|
/** |
|
371
|
|
|
* Send general files. |
|
372
|
|
|
* |
|
373
|
|
|
* <code> |
|
374
|
|
|
* $params = [ |
|
375
|
|
|
* 'chat_id' => '', |
|
376
|
|
|
* 'document' => '', |
|
377
|
|
|
* 'caption' => '', |
|
378
|
|
|
* 'disable_notification' => '', |
|
379
|
|
|
* 'reply_to_message_id' => '', |
|
380
|
|
|
* 'reply_markup' => '', |
|
381
|
|
|
* ]; |
|
382
|
|
|
* </code> |
|
383
|
|
|
* |
|
384
|
|
|
* @link https://core.telegram.org/bots/api#senddocument |
|
385
|
|
|
* |
|
386
|
|
|
* @param array $params |
|
387
|
|
|
* |
|
388
|
|
|
* @var int|string $params ['chat_id'] |
|
389
|
|
|
* @var string $params ['document'] |
|
390
|
|
|
* @var string $params ['caption'] |
|
391
|
|
|
* @var bool $params ['disable_notification'] |
|
392
|
|
|
* @var int $params ['reply_to_message_id'] |
|
393
|
|
|
* @var string $params ['reply_markup'] |
|
394
|
|
|
* |
|
395
|
|
|
* @throws TelegramSDKException |
|
396
|
|
|
* |
|
397
|
|
|
* @return Message |
|
398
|
|
|
*/ |
|
399
|
2 |
|
public function sendDocument(array $params) |
|
400
|
|
|
{ |
|
401
|
2 |
|
$response = $this->uploadFile('sendDocument', $params); |
|
402
|
|
|
|
|
403
|
2 |
|
return new Message($response->getDecodedBody()); |
|
404
|
|
|
} |
|
405
|
|
|
|
|
406
|
|
|
/** |
|
407
|
|
|
* Send .webp stickers. |
|
408
|
|
|
* |
|
409
|
|
|
* <code> |
|
410
|
|
|
* $params = [ |
|
411
|
|
|
* 'chat_id' => '', |
|
412
|
|
|
* 'sticker' => '', |
|
413
|
|
|
* 'disable_notification' => '', |
|
414
|
|
|
* 'reply_to_message_id' => '', |
|
415
|
|
|
* 'reply_markup' => '', |
|
416
|
|
|
* ]; |
|
417
|
|
|
* </code> |
|
418
|
|
|
* |
|
419
|
|
|
* @link https://core.telegram.org/bots/api#sendsticker |
|
420
|
|
|
* |
|
421
|
|
|
* @param array $params |
|
422
|
|
|
* |
|
423
|
|
|
* @var int|string $params ['chat_id'] |
|
424
|
|
|
* @var string $params ['sticker'] |
|
425
|
|
|
* @var bool $params ['disable_notification'] |
|
426
|
|
|
* @var int $params ['reply_to_message_id'] |
|
427
|
|
|
* @var string $params ['reply_markup'] |
|
428
|
|
|
* |
|
429
|
|
|
* @throws TelegramSDKException |
|
430
|
|
|
* |
|
431
|
|
|
* @return Message |
|
432
|
|
|
*/ |
|
433
|
2 |
|
public function sendSticker(array $params) |
|
434
|
|
|
{ |
|
435
|
2 |
|
if (is_file($params['sticker']) && (pathinfo($params['sticker'], PATHINFO_EXTENSION) !== 'webp')) { |
|
436
|
|
|
throw new TelegramSDKException('Invalid Sticker Provided. Supported Format: Webp'); |
|
437
|
|
|
} |
|
438
|
|
|
|
|
439
|
2 |
|
$response = $this->uploadFile('sendSticker', $params); |
|
440
|
|
|
|
|
441
|
2 |
|
return new Message($response->getDecodedBody()); |
|
442
|
|
|
} |
|
443
|
|
|
|
|
444
|
|
|
/** |
|
445
|
|
|
* Send Video File, Telegram clients support mp4 videos (other formats may be sent as Document). |
|
446
|
|
|
* |
|
447
|
|
|
* <code> |
|
448
|
|
|
* $params = [ |
|
449
|
|
|
* 'chat_id' => '', |
|
450
|
|
|
* 'video' => '', |
|
451
|
|
|
* 'duration' => '', |
|
452
|
|
|
* 'width' => '', |
|
453
|
|
|
* 'height' => '', |
|
454
|
|
|
* 'caption' => '', |
|
455
|
|
|
* 'disable_notification' => '', |
|
456
|
|
|
* 'reply_to_message_id' => '', |
|
457
|
|
|
* 'reply_markup' => '', |
|
458
|
|
|
* ]; |
|
459
|
|
|
* </code> |
|
460
|
|
|
* |
|
461
|
|
|
* @see sendDocument |
|
462
|
|
|
* @link https://core.telegram.org/bots/api#sendvideo |
|
463
|
|
|
* |
|
464
|
|
|
* @param array $params |
|
465
|
|
|
* |
|
466
|
|
|
* @var int|string $params ['chat_id'] |
|
467
|
|
|
* @var string $params ['video'] |
|
468
|
|
|
* @var int $params ['duration'] |
|
469
|
|
|
* @var int $params ['width'] |
|
470
|
|
|
* @var int $params ['height'] |
|
471
|
|
|
* @var string $params ['caption'] |
|
472
|
|
|
* @var bool $params ['disable_notification'] |
|
473
|
|
|
* @var int $params ['reply_to_message_id'] |
|
474
|
|
|
* @var string $params ['reply_markup'] |
|
475
|
|
|
* |
|
476
|
|
|
* @throws TelegramSDKException |
|
477
|
|
|
* |
|
478
|
|
|
* @return Message |
|
479
|
|
|
*/ |
|
480
|
2 |
|
public function sendVideo(array $params) |
|
481
|
|
|
{ |
|
482
|
2 |
|
$response = $this->uploadFile('sendVideo', $params); |
|
483
|
|
|
|
|
484
|
2 |
|
return new Message($response->getDecodedBody()); |
|
485
|
|
|
} |
|
486
|
|
|
|
|
487
|
|
|
/** |
|
488
|
|
|
* Send voice audio files. |
|
489
|
|
|
* |
|
490
|
|
|
* <code> |
|
491
|
|
|
* $params = [ |
|
492
|
|
|
* 'chat_id' => '', |
|
493
|
|
|
* 'voice' => '', |
|
494
|
|
|
* 'duration' => '', |
|
495
|
|
|
* 'disable_notification' => '', |
|
496
|
|
|
* 'reply_to_message_id' => '', |
|
497
|
|
|
* 'reply_markup' => '', |
|
498
|
|
|
* ]; |
|
499
|
|
|
* </code> |
|
500
|
|
|
* |
|
501
|
|
|
* @link https://core.telegram.org/bots/api#sendaudio |
|
502
|
|
|
* |
|
503
|
|
|
* @param array $params |
|
504
|
|
|
* |
|
505
|
|
|
* @var int|string $params ['chat_id'] |
|
506
|
|
|
* @var string $params ['voice'] |
|
507
|
|
|
* @var int $params ['duration'] |
|
508
|
|
|
* @var bool $params ['disable_notification'] |
|
509
|
|
|
* @var int $params ['reply_to_message_id'] |
|
510
|
|
|
* @var string $params ['reply_markup'] |
|
511
|
|
|
* |
|
512
|
|
|
* @throws TelegramSDKException |
|
513
|
|
|
* |
|
514
|
|
|
* @return Message |
|
515
|
|
|
*/ |
|
516
|
2 |
|
public function sendVoice(array $params) |
|
517
|
|
|
{ |
|
518
|
2 |
|
$response = $this->uploadFile('sendVoice', $params); |
|
519
|
|
|
|
|
520
|
2 |
|
return new Message($response->getDecodedBody()); |
|
521
|
|
|
} |
|
522
|
|
|
|
|
523
|
|
|
/** |
|
524
|
|
|
* Send point on the map. |
|
525
|
|
|
* |
|
526
|
|
|
* <code> |
|
527
|
|
|
* $params = [ |
|
528
|
|
|
* 'chat_id' => '', |
|
529
|
|
|
* 'latitude' => '', |
|
530
|
|
|
* 'longitude' => '', |
|
531
|
|
|
* 'disable_notification' => '', |
|
532
|
|
|
* 'reply_to_message_id' => '', |
|
533
|
|
|
* 'reply_markup' => '', |
|
534
|
|
|
* ]; |
|
535
|
|
|
* </code> |
|
536
|
|
|
* |
|
537
|
|
|
* @link https://core.telegram.org/bots/api#sendlocation |
|
538
|
|
|
* |
|
539
|
|
|
* @param array $params |
|
540
|
|
|
* |
|
541
|
|
|
* @var int|string $params ['chat_id'] |
|
542
|
|
|
* @var float $params ['latitude'] |
|
543
|
|
|
* @var float $params ['longitude'] |
|
544
|
|
|
* @var bool $params ['disable_notification'] |
|
545
|
|
|
* @var int $params ['reply_to_message_id'] |
|
546
|
|
|
* @var string $params ['reply_markup'] |
|
547
|
|
|
* |
|
548
|
|
|
* @throws TelegramSDKException |
|
549
|
|
|
* |
|
550
|
|
|
* @return Message |
|
551
|
|
|
*/ |
|
552
|
2 |
|
public function sendLocation(array $params) |
|
553
|
|
|
{ |
|
554
|
2 |
|
$response = $this->post('sendLocation', $params); |
|
555
|
|
|
|
|
556
|
2 |
|
return new Message($response->getDecodedBody()); |
|
557
|
|
|
} |
|
558
|
|
|
|
|
559
|
|
|
/** |
|
560
|
|
|
* Send information about a venue. |
|
561
|
|
|
* |
|
562
|
|
|
* <code> |
|
563
|
|
|
* $params = [ |
|
564
|
|
|
* 'chat_id' => '', |
|
565
|
|
|
* 'latitude' => '', |
|
566
|
|
|
* 'longitude' => '', |
|
567
|
|
|
* 'title' => '', |
|
568
|
|
|
* 'address' => '', |
|
569
|
|
|
* 'foursquare_id' => '', |
|
570
|
|
|
* 'disable_notification' => '', |
|
571
|
|
|
* 'reply_to_message_id' => '', |
|
572
|
|
|
* 'reply_markup' => '', |
|
573
|
|
|
* ]; |
|
574
|
|
|
* </code> |
|
575
|
|
|
* |
|
576
|
|
|
* @link https://core.telegram.org/bots/api#sendvenue |
|
577
|
|
|
* |
|
578
|
|
|
* @param array $params |
|
579
|
|
|
* |
|
580
|
|
|
* @var int|string $params ['chat_id'] |
|
581
|
|
|
* @var float $params ['latitude'] |
|
582
|
|
|
* @var float $params ['longitude'] |
|
583
|
|
|
* @var string $params ['title'] |
|
584
|
|
|
* @var string $params ['address'] |
|
585
|
|
|
* @var string $params ['foursquare_id'] |
|
586
|
|
|
* @var bool $params ['disable_notification'] |
|
587
|
|
|
* @var int $params ['reply_to_message_id'] |
|
588
|
|
|
* @var string $params ['reply_markup'] |
|
589
|
|
|
* |
|
590
|
|
|
* @throws TelegramSDKException |
|
591
|
|
|
* |
|
592
|
|
|
* @return Message |
|
593
|
|
|
*/ |
|
594
|
|
|
public function sendVenue(array $params) |
|
595
|
|
|
{ |
|
596
|
|
|
$response = $this->post('sendVenue', $params); |
|
597
|
|
|
|
|
598
|
|
|
return new Message($response->getDecodedBody()); |
|
599
|
|
|
} |
|
600
|
|
|
|
|
601
|
|
|
/** |
|
602
|
|
|
* Send phone contacts. |
|
603
|
|
|
* |
|
604
|
|
|
* <code> |
|
605
|
|
|
* $params = [ |
|
606
|
|
|
* 'chat_id' => '', |
|
607
|
|
|
* 'phone_number' => '', |
|
608
|
|
|
* 'first_name' => '', |
|
609
|
|
|
* 'last_name' => '', |
|
610
|
|
|
* 'disable_notification' => '', |
|
611
|
|
|
* 'reply_to_message_id' => '', |
|
612
|
|
|
* 'reply_markup' => '', |
|
613
|
|
|
* ]; |
|
614
|
|
|
* </code> |
|
615
|
|
|
* |
|
616
|
|
|
* @link https://core.telegram.org/bots/api#sendcontact |
|
617
|
|
|
* |
|
618
|
|
|
* @param array $params |
|
619
|
|
|
* |
|
620
|
|
|
* @var int|string $params ['chat_id'] |
|
621
|
|
|
* @var string $params ['phone_number'] |
|
622
|
|
|
* @var string $params ['first_name'] |
|
623
|
|
|
* @var string $params ['last_name'] |
|
624
|
|
|
* @var bool $params ['disable_notification'] |
|
625
|
|
|
* @var int $params ['reply_to_message_id'] |
|
626
|
|
|
* @var string $params ['reply_markup'] |
|
627
|
|
|
* |
|
628
|
|
|
* @throws TelegramSDKException |
|
629
|
|
|
* |
|
630
|
|
|
* @return Message |
|
631
|
|
|
*/ |
|
632
|
|
|
public function sendContact(array $params) |
|
633
|
|
|
{ |
|
634
|
|
|
$response = $this->post('sendContact', $params); |
|
635
|
|
|
|
|
636
|
|
|
return new Message($response->getDecodedBody()); |
|
637
|
|
|
} |
|
638
|
|
|
|
|
639
|
|
|
/** |
|
640
|
|
|
* Broadcast a Chat Action. |
|
641
|
|
|
* |
|
642
|
|
|
* <code> |
|
643
|
|
|
* $params = [ |
|
644
|
|
|
* 'chat_id' => '', |
|
645
|
|
|
* 'action' => '', |
|
646
|
|
|
* ]; |
|
647
|
|
|
* </code> |
|
648
|
|
|
* |
|
649
|
|
|
* @link https://core.telegram.org/bots/api#sendchataction |
|
650
|
|
|
* |
|
651
|
|
|
* @param array $params |
|
652
|
|
|
* |
|
653
|
|
|
* @var int|string $params ['chat_id'] |
|
654
|
|
|
* @var string $params ['action'] |
|
655
|
|
|
* |
|
656
|
|
|
* @throws TelegramSDKException |
|
657
|
|
|
* |
|
658
|
|
|
* @return bool |
|
659
|
|
|
*/ |
|
660
|
4 |
|
public function sendChatAction(array $params) |
|
661
|
|
|
{ |
|
662
|
|
|
$validActions = [ |
|
663
|
4 |
|
'typing', |
|
664
|
4 |
|
'upload_photo', |
|
665
|
4 |
|
'record_video', |
|
666
|
4 |
|
'upload_video', |
|
667
|
4 |
|
'record_audio', |
|
668
|
4 |
|
'upload_audio', |
|
669
|
4 |
|
'upload_document', |
|
670
|
4 |
|
'find_location', |
|
671
|
4 |
|
]; |
|
672
|
|
|
|
|
673
|
4 |
|
if (isset($params['action']) && in_array($params['action'], $validActions)) { |
|
674
|
2 |
|
$this->post('sendChatAction', $params); |
|
675
|
|
|
|
|
676
|
2 |
|
return true; |
|
677
|
|
|
} |
|
678
|
|
|
|
|
679
|
2 |
|
throw new TelegramSDKException('Invalid Action! Accepted value: '.implode(', ', $validActions)); |
|
680
|
|
|
} |
|
681
|
|
|
|
|
682
|
|
|
/** |
|
683
|
|
|
* Returns a list of profile pictures for a user. |
|
684
|
|
|
* |
|
685
|
|
|
* <code> |
|
686
|
|
|
* $params = [ |
|
687
|
|
|
* 'user_id' => '', |
|
688
|
|
|
* 'offset' => '', |
|
689
|
|
|
* 'limit' => '', |
|
690
|
|
|
* ]; |
|
691
|
|
|
* </code> |
|
692
|
|
|
* |
|
693
|
|
|
* @link https://core.telegram.org/bots/api#getuserprofilephotos |
|
694
|
|
|
* |
|
695
|
|
|
* @param array $params |
|
696
|
|
|
* |
|
697
|
|
|
* @var int $params ['user_id'] |
|
698
|
|
|
* @var int $params ['offset'] |
|
699
|
|
|
* @var int $params ['limit'] |
|
700
|
|
|
* |
|
701
|
|
|
* @throws TelegramSDKException |
|
702
|
|
|
* |
|
703
|
|
|
* @return UserProfilePhotos |
|
704
|
|
|
*/ |
|
705
|
|
|
public function getUserProfilePhotos(array $params) |
|
706
|
|
|
{ |
|
707
|
|
|
$response = $this->post('getUserProfilePhotos', $params); |
|
708
|
|
|
|
|
709
|
|
|
return new UserProfilePhotos($response->getDecodedBody()); |
|
710
|
|
|
} |
|
711
|
|
|
|
|
712
|
|
|
/** |
|
713
|
|
|
* Returns basic info about a file and prepare it for downloading. |
|
714
|
|
|
* |
|
715
|
|
|
* <code> |
|
716
|
|
|
* $params = [ |
|
717
|
|
|
* 'file_id' => '', |
|
718
|
|
|
* ]; |
|
719
|
|
|
* </code> |
|
720
|
|
|
* |
|
721
|
|
|
* The file can then be downloaded via the link |
|
722
|
|
|
* https://api.telegram.org/file/bot<token>/<file_path>, |
|
723
|
|
|
* where <file_path> is taken from the response. |
|
724
|
|
|
* |
|
725
|
|
|
* @link https://core.telegram.org/bots/api#getFile |
|
726
|
|
|
* |
|
727
|
|
|
* @param array $params |
|
728
|
|
|
* |
|
729
|
|
|
* @var string $params ['file_id'] |
|
730
|
|
|
* |
|
731
|
|
|
* @throws TelegramSDKException |
|
732
|
|
|
* |
|
733
|
|
|
* @return File |
|
734
|
|
|
*/ |
|
735
|
2 |
|
public function getFile(array $params) |
|
736
|
|
|
{ |
|
737
|
2 |
|
$response = $this->post('getFile', $params); |
|
738
|
|
|
|
|
739
|
2 |
|
return new File($response->getDecodedBody()); |
|
740
|
|
|
} |
|
741
|
|
|
|
|
742
|
|
|
/** |
|
743
|
|
|
* Bot to leave a group, supergroup or channel. |
|
744
|
|
|
* |
|
745
|
|
|
* <code> |
|
746
|
|
|
* $params = [ |
|
747
|
|
|
* 'chat_id' => '', |
|
748
|
|
|
* ]; |
|
749
|
|
|
* </code> |
|
750
|
|
|
* |
|
751
|
|
|
* @link https://core.telegram.org/bots/api/#leavechat |
|
752
|
|
|
* |
|
753
|
|
|
* @param array $params |
|
754
|
|
|
* |
|
755
|
|
|
* @var int|string $params ['chat_id'] |
|
756
|
|
|
* |
|
757
|
|
|
* @return TelegramResponse |
|
758
|
|
|
*/ |
|
759
|
|
|
public function leaveChat(array $params) |
|
760
|
|
|
{ |
|
761
|
|
|
return $this->post('leaveChat', $params); |
|
762
|
|
|
} |
|
763
|
|
|
|
|
764
|
|
|
/** |
|
765
|
|
|
* Kick a user from a group or a supergroup. |
|
766
|
|
|
* |
|
767
|
|
|
* In the case of supergroups, the user will not be able to return to the group on their own using |
|
768
|
|
|
* invite links etc., unless unbanned first. |
|
769
|
|
|
* |
|
770
|
|
|
* The bot must be an administrator in the group for this to work. |
|
771
|
|
|
* |
|
772
|
|
|
* <code> |
|
773
|
|
|
* $params = [ |
|
774
|
|
|
* 'chat_id' => '', |
|
775
|
|
|
* 'user_id' => '', |
|
776
|
|
|
* ]; |
|
777
|
|
|
* </code> |
|
778
|
|
|
* |
|
779
|
|
|
* @link https://core.telegram.org/bots/api#kickchatmember |
|
780
|
|
|
* |
|
781
|
|
|
* @param array $params |
|
782
|
|
|
* |
|
783
|
|
|
* @var int|string $params ['chat_id'] |
|
784
|
|
|
* @var int $params ['user_id'] |
|
785
|
|
|
* |
|
786
|
|
|
* @throws TelegramSDKException |
|
787
|
|
|
* |
|
788
|
|
|
* @return bool |
|
789
|
|
|
*/ |
|
790
|
|
|
public function kickChatMember(array $params) |
|
791
|
|
|
{ |
|
792
|
|
|
$this->post('kickChatMember', $params); |
|
793
|
|
|
|
|
794
|
|
|
return true; |
|
795
|
|
|
} |
|
796
|
|
|
|
|
797
|
|
|
/** |
|
798
|
|
|
* Unban a previously kicked user in a supergroup. |
|
799
|
|
|
* |
|
800
|
|
|
* The user will not return to the group automatically, but will be able to join via link, etc. |
|
801
|
|
|
* |
|
802
|
|
|
* The bot must be an administrator in the group for this to work. |
|
803
|
|
|
* |
|
804
|
|
|
* <code> |
|
805
|
|
|
* $params = [ |
|
806
|
|
|
* 'chat_id' => '', |
|
807
|
|
|
* 'user_id' => '', |
|
808
|
|
|
* ]; |
|
809
|
|
|
* </code> |
|
810
|
|
|
* |
|
811
|
|
|
* @link https://core.telegram.org/bots/api#unbanchatmember |
|
812
|
|
|
* |
|
813
|
|
|
* @param array $params |
|
814
|
|
|
* |
|
815
|
|
|
* @var int|string $params ['chat_id'] |
|
816
|
|
|
* @var int $params ['user_id'] |
|
817
|
|
|
* |
|
818
|
|
|
* @throws TelegramSDKException |
|
819
|
|
|
* |
|
820
|
|
|
* @return bool |
|
821
|
|
|
*/ |
|
822
|
|
|
public function unbanChatMember(array $params) |
|
823
|
|
|
{ |
|
824
|
|
|
$this->post('unbanChatMember', $params); |
|
825
|
|
|
|
|
826
|
|
|
return true; |
|
827
|
|
|
} |
|
828
|
|
|
|
|
829
|
|
|
/** |
|
830
|
|
|
* Get up to date information about the chat (current name of the user for one-on-one conversations, |
|
831
|
|
|
* current username of a user, group or channel, |
|
832
|
|
|
* |
|
833
|
|
|
* <code> |
|
834
|
|
|
* $params = [ |
|
835
|
|
|
* 'chat_id' => '', |
|
836
|
|
|
* ]; |
|
837
|
|
|
* </code> |
|
838
|
|
|
* |
|
839
|
|
|
* @link https://core.telegram.org/bots/api#getchat |
|
840
|
|
|
* |
|
841
|
|
|
* @param array $params |
|
842
|
|
|
* |
|
843
|
|
|
* @var string|int $params ['chat_id'] Unique identifier for the target chat or username of the target supergroup or channel (in the format @channelusername) |
|
844
|
|
|
* |
|
845
|
|
|
* @throws TelegramSDKException |
|
846
|
|
|
* |
|
847
|
|
|
* @return Chat |
|
848
|
|
|
*/ |
|
849
|
|
|
public function getChat(array $params) |
|
850
|
|
|
{ |
|
851
|
|
|
$response = $this->post('getChat', $params); |
|
852
|
|
|
|
|
853
|
|
|
return new Chat($response->getDecodedBody()); |
|
854
|
|
|
} |
|
855
|
|
|
|
|
856
|
|
|
/** |
|
857
|
|
|
* Get a list of administrators in a chat. |
|
858
|
|
|
* |
|
859
|
|
|
* <code> |
|
860
|
|
|
* $params = [ |
|
861
|
|
|
* 'chat_id' => '', |
|
862
|
|
|
* ]; |
|
863
|
|
|
* </code> |
|
864
|
|
|
* |
|
865
|
|
|
* @link https://core.telegram.org/bots/api#getchatadministrators |
|
866
|
|
|
* |
|
867
|
|
|
* @param array $params |
|
868
|
|
|
* |
|
869
|
|
|
* @var string|int $params ['chat_id'] Unique identifier for the target chat or username of the target supergroup or channel (in the format @channelusername); |
|
870
|
|
|
* |
|
871
|
|
|
* @throws TelegramSDKException |
|
872
|
|
|
* |
|
873
|
|
|
* @return ChatMember[] |
|
874
|
|
|
*/ |
|
875
|
|
|
public function getChatAdministrators(array $params) |
|
876
|
|
|
{ |
|
877
|
|
|
$response = $this->post('getChatAdministrators', $params); |
|
878
|
|
|
|
|
879
|
|
|
return collect($response->getResult()) |
|
880
|
|
|
->map(function ($admin) { |
|
881
|
|
|
return new ChatMember($admin); |
|
882
|
|
|
}) |
|
883
|
|
|
->all(); |
|
884
|
|
|
} |
|
885
|
|
|
|
|
886
|
|
|
/** |
|
887
|
|
|
* Get the number of members in a chat |
|
888
|
|
|
* |
|
889
|
|
|
* <code> |
|
890
|
|
|
* $params = [ |
|
891
|
|
|
* 'chat_id' => '', |
|
892
|
|
|
* ]; |
|
893
|
|
|
* </code> |
|
894
|
|
|
* |
|
895
|
|
|
* @link https://core.telegram.org/bots/api#getchatmemberscount |
|
896
|
|
|
* |
|
897
|
|
|
* @param array $params |
|
898
|
|
|
* |
|
899
|
|
|
* @var string|int $params ['chat_id'] Unique identifier for the target chat or username of the target supergroup or channel (in the format @channelusername) |
|
900
|
|
|
* |
|
901
|
|
|
* @throws TelegramSDKException |
|
902
|
|
|
* |
|
903
|
|
|
* @return int |
|
904
|
|
|
*/ |
|
905
|
|
|
public function getChatMembersCount(array $params) |
|
906
|
|
|
{ |
|
907
|
|
|
$response = $this->post('getChatMembersCount', $params); |
|
908
|
|
|
|
|
909
|
|
|
return $response->getResult(); |
|
910
|
|
|
} |
|
911
|
|
|
|
|
912
|
|
|
/** |
|
913
|
|
|
* Get information about a member of a chat. |
|
914
|
|
|
* |
|
915
|
|
|
* <code> |
|
916
|
|
|
* $params = [ |
|
917
|
|
|
* 'chat_id' => '', |
|
918
|
|
|
* 'user_id' => '', |
|
919
|
|
|
* ]; |
|
920
|
|
|
* </code> |
|
921
|
|
|
* |
|
922
|
|
|
* @link https://core.telegram.org/bots/api#getchatmember |
|
923
|
|
|
* |
|
924
|
|
|
* @param array $params |
|
925
|
|
|
* |
|
926
|
|
|
* @var string|int $params ['chat_id'] Unique identifier for the target chat or username of the target supergroup or channel (in the format @channelusername) |
|
927
|
|
|
* @var int $params ['user_id'] Unique identifier of the target user. |
|
928
|
|
|
* |
|
929
|
|
|
* @throws TelegramSDKException |
|
930
|
|
|
* |
|
931
|
|
|
* @return ChatMember |
|
932
|
|
|
*/ |
|
933
|
|
|
public function getChatMember(array $params) |
|
934
|
|
|
{ |
|
935
|
|
|
$response = $this->post('getChatMember', $params); |
|
936
|
|
|
|
|
937
|
|
|
return new ChatMember($response->getDecodedBody()); |
|
938
|
|
|
} |
|
939
|
|
|
|
|
940
|
|
|
/** |
|
941
|
|
|
* Send answers to callback queries sent from inline keyboards. |
|
942
|
|
|
* |
|
943
|
|
|
* he answer will be displayed to the user as a notification at the top of the chat screen or as an alert. |
|
944
|
|
|
* |
|
945
|
|
|
* <code> |
|
946
|
|
|
* $params = [ |
|
947
|
|
|
* 'callback_query_id' => '', |
|
948
|
|
|
* 'text' => '', |
|
949
|
|
|
* 'show_alert' => '', |
|
950
|
|
|
* ]; |
|
951
|
|
|
* </code> |
|
952
|
|
|
* |
|
953
|
|
|
* @link https://core.telegram.org/bots/api#answerCallbackQuery |
|
954
|
|
|
* |
|
955
|
|
|
* @param array $params |
|
956
|
|
|
* |
|
957
|
|
|
* @var string $params ['callback_query_id'] |
|
958
|
|
|
* @var string $params ['text'] |
|
959
|
|
|
* @var bool $params ['show_alert'] |
|
960
|
|
|
* |
|
961
|
|
|
* @throws TelegramSDKException |
|
962
|
|
|
* |
|
963
|
|
|
* @return bool |
|
964
|
|
|
*/ |
|
965
|
|
|
public function answerCallbackQuery(array $params) |
|
966
|
|
|
{ |
|
967
|
|
|
$this->post('answerCallbackQuery', $params); |
|
968
|
|
|
|
|
969
|
|
|
return true; |
|
970
|
|
|
} |
|
971
|
|
|
|
|
972
|
|
|
|
|
973
|
|
|
/** |
|
974
|
|
|
* Edit text messages sent by the bot or via the bot (for inline bots). |
|
975
|
|
|
* |
|
976
|
|
|
* <code> |
|
977
|
|
|
* $params = [ |
|
978
|
|
|
* 'chat_id' => '', |
|
979
|
|
|
* 'message_id' => '', |
|
980
|
|
|
* 'inline_message_id' => '', |
|
981
|
|
|
* 'text' => '', |
|
982
|
|
|
* 'parse_mode' => '', |
|
983
|
|
|
* 'disable_web_page_preview' => '', |
|
984
|
|
|
* 'reply_markup' => '', |
|
985
|
|
|
* ]; |
|
986
|
|
|
* </code> |
|
987
|
|
|
* |
|
988
|
|
|
* @link https://core.telegram.org/bots/api#editMessageText |
|
989
|
|
|
* |
|
990
|
|
|
* @param array $params |
|
991
|
|
|
* |
|
992
|
|
|
* @var int|string $params ['chat_id'] |
|
993
|
|
|
* @var int $params ['message_id'] |
|
994
|
|
|
* @var string $params ['inline_message_id'] |
|
995
|
|
|
* @var string $params ['text'] |
|
996
|
|
|
* @var string $params ['parse_mode'] |
|
997
|
|
|
* @var bool $params ['disable_web_page_preview'] |
|
998
|
|
|
* @var string $params ['reply_markup'] |
|
999
|
|
|
* |
|
1000
|
|
|
* @throws TelegramSDKException |
|
1001
|
|
|
* |
|
1002
|
|
|
* @return Message|bool |
|
1003
|
|
|
*/ |
|
1004
|
|
|
public function editMessageText(array $params) |
|
1005
|
|
|
{ |
|
1006
|
|
|
$response = $this->post('editMessageText', $params); |
|
1007
|
|
|
|
|
1008
|
|
|
return new Message($response->getDecodedBody()); |
|
1009
|
|
|
} |
|
1010
|
|
|
|
|
1011
|
|
|
/** |
|
1012
|
|
|
* Edit captions of messages sent by the bot or via the bot (for inline bots). |
|
1013
|
|
|
* |
|
1014
|
|
|
* <code> |
|
1015
|
|
|
* $params = [ |
|
1016
|
|
|
* 'chat_id' => '', |
|
1017
|
|
|
* 'message_id' => '', |
|
1018
|
|
|
* 'inline_message_id' => '', |
|
1019
|
|
|
* 'caption' => '', |
|
1020
|
|
|
* 'reply_markup' => '', |
|
1021
|
|
|
* ]; |
|
1022
|
|
|
* </code> |
|
1023
|
|
|
* |
|
1024
|
|
|
* @link https://core.telegram.org/bots/api#editMessageCaption |
|
1025
|
|
|
* |
|
1026
|
|
|
* @param array $params |
|
1027
|
|
|
* |
|
1028
|
|
|
* @var int|string $params ['chat_id'] |
|
1029
|
|
|
* @var int $params ['message_id'] |
|
1030
|
|
|
* @var string $params ['inline_message_id'] |
|
1031
|
|
|
* @var string $params ['caption'] |
|
1032
|
|
|
* @var string $params ['reply_markup'] |
|
1033
|
|
|
* |
|
1034
|
|
|
* @throws TelegramSDKException |
|
1035
|
|
|
* |
|
1036
|
|
|
* @return Message|bool |
|
1037
|
|
|
*/ |
|
1038
|
|
|
public function editMessageCaption(array $params) |
|
1039
|
|
|
{ |
|
1040
|
|
|
$response = $this->post('editMessageCaption', $params); |
|
1041
|
|
|
|
|
1042
|
|
|
return new Message($response->getDecodedBody()); |
|
1043
|
|
|
} |
|
1044
|
|
|
|
|
1045
|
|
|
/** |
|
1046
|
|
|
* Edit only the reply markup of messages sent by the bot or via the bot (for inline bots). |
|
1047
|
|
|
* |
|
1048
|
|
|
* <code> |
|
1049
|
|
|
* $params = [ |
|
1050
|
|
|
* 'chat_id' => '', |
|
1051
|
|
|
* 'message_id' => '', |
|
1052
|
|
|
* 'inline_message_id' => '', |
|
1053
|
|
|
* 'reply_markup' => '', |
|
1054
|
|
|
* ]; |
|
1055
|
|
|
* </code> |
|
1056
|
|
|
* |
|
1057
|
|
|
* @link https://core.telegram.org/bots/api#editMessageReplyMarkup |
|
1058
|
|
|
* |
|
1059
|
|
|
* @param array $params |
|
1060
|
|
|
* |
|
1061
|
|
|
* @var int|string $params ['chat_id'] |
|
1062
|
|
|
* @var int $params ['message_id'] |
|
1063
|
|
|
* @var string $params ['inline_message_id'] |
|
1064
|
|
|
* @var string $params ['reply_markup'] |
|
1065
|
|
|
* |
|
1066
|
|
|
* @throws TelegramSDKException |
|
1067
|
|
|
* |
|
1068
|
|
|
* @return Message|bool |
|
1069
|
|
|
*/ |
|
1070
|
|
|
public function editMessageReplyMarkup(array $params) |
|
1071
|
|
|
{ |
|
1072
|
|
|
$response = $this->post('editMessageReplyMarkup', $params); |
|
1073
|
|
|
|
|
1074
|
|
|
return new Message($response->getDecodedBody()); |
|
1075
|
|
|
} |
|
1076
|
|
|
|
|
1077
|
|
|
/** |
|
1078
|
|
|
* Use this method to send answers to an inline query. |
|
1079
|
|
|
* |
|
1080
|
|
|
* <code> |
|
1081
|
|
|
* $params = [ |
|
1082
|
|
|
* 'inline_query_id' => '', |
|
1083
|
|
|
* 'results' => [], |
|
1084
|
|
|
* 'cache_time' => 0, |
|
1085
|
|
|
* 'is_personal' => false, |
|
1086
|
|
|
* 'next_offset' => '', |
|
1087
|
|
|
* 'switch_pm_text' => '', |
|
1088
|
|
|
* 'switch_pm_parameter' => '', |
|
1089
|
|
|
* ]; |
|
1090
|
|
|
* </code> |
|
1091
|
|
|
* |
|
1092
|
|
|
* @link https://core.telegram.org/bots/api#answerinlinequery |
|
1093
|
|
|
* |
|
1094
|
|
|
* @param array $params |
|
1095
|
|
|
* |
|
1096
|
|
|
* @var string $params ['inline_query_id'] |
|
1097
|
|
|
* @var array $params ['results'] |
|
1098
|
|
|
* @var int|null $params ['cache_time'] |
|
1099
|
|
|
* @var bool|null $params ['is_personal'] |
|
1100
|
|
|
* @var string|null $params ['next_offset'] |
|
1101
|
|
|
* @var string|null $params ['switch_pm_text'] |
|
1102
|
|
|
* @var string|null $params ['switch_pm_parameter'] |
|
1103
|
|
|
* |
|
1104
|
|
|
* @throws TelegramSDKException |
|
1105
|
|
|
* |
|
1106
|
|
|
* @return bool |
|
1107
|
|
|
*/ |
|
1108
|
|
|
public function answerInlineQuery(array $params = []) |
|
1109
|
|
|
{ |
|
1110
|
|
|
if (is_array($params['results'])) { |
|
1111
|
|
|
$params['results'] = json_encode($params['results']); |
|
1112
|
|
|
} |
|
1113
|
|
|
|
|
1114
|
|
|
$this->post('answerInlineQuery', $params); |
|
1115
|
|
|
|
|
1116
|
|
|
return true; |
|
1117
|
|
|
} |
|
1118
|
|
|
|
|
1119
|
6 |
|
/** |
|
1120
|
|
|
* Set a Webhook to receive incoming updates via an outgoing webhook. |
|
1121
|
6 |
|
* |
|
1122
|
2 |
|
* <code> |
|
1123
|
|
|
* $params = [ |
|
1124
|
|
|
* 'url' => '', |
|
1125
|
4 |
|
* 'certificate' => '', |
|
1126
|
2 |
|
* ]; |
|
1127
|
|
|
* </code> |
|
1128
|
|
|
* |
|
1129
|
2 |
|
* @link https://core.telegram.org/bots/api#setwebhook |
|
1130
|
|
|
* |
|
1131
|
|
|
* @param array $params |
|
1132
|
|
|
* |
|
1133
|
|
|
* @var string $params ['url'] HTTPS url to send updates to. |
|
1134
|
|
|
* @var string $params ['certificate'] Upload your public key certificate so that the root certificate in |
|
1135
|
|
|
* use can be checked. |
|
1136
|
|
|
* |
|
1137
|
|
|
* @throws TelegramSDKException |
|
1138
|
|
|
* |
|
1139
|
|
|
* @return TelegramResponse |
|
1140
|
|
|
*/ |
|
1141
|
|
|
public function setWebhook(array $params) |
|
1142
|
|
|
{ |
|
1143
|
|
|
if (filter_var($params['url'], FILTER_VALIDATE_URL) === false) { |
|
1144
|
|
|
throw new TelegramSDKException('Invalid URL Provided'); |
|
1145
|
|
|
} |
|
1146
|
|
|
|
|
1147
|
|
|
if (parse_url($params['url'], PHP_URL_SCHEME) !== 'https') { |
|
1148
|
|
|
throw new TelegramSDKException('Invalid URL, should be a HTTPS url.'); |
|
1149
|
|
|
} |
|
1150
|
|
|
|
|
1151
|
|
|
return $this->uploadFile('setWebhook', $params); |
|
1152
|
|
|
} |
|
1153
|
|
|
|
|
1154
|
|
|
/** |
|
1155
|
|
|
* Returns a webhook update sent by Telegram. |
|
1156
|
|
|
* Works only if you set a webhook. |
|
1157
|
|
|
* |
|
1158
|
|
|
* @see setWebhook |
|
1159
|
|
|
* |
|
1160
|
|
|
* @return Update |
|
1161
|
|
|
*/ |
|
1162
|
|
|
public function getWebhookUpdate($shouldEmitEvent = true) |
|
1163
|
|
|
{ |
|
1164
|
|
|
$body = json_decode(file_get_contents('php://input'), true); |
|
1165
|
|
|
|
|
1166
|
|
|
$update = new Update($body); |
|
1167
|
|
|
|
|
1168
|
|
|
if ($shouldEmitEvent) { |
|
1169
|
|
|
$this->emitEvent(new UpdateWasReceived($update, $this)); |
|
1170
|
|
|
} |
|
1171
|
|
|
|
|
1172
|
|
|
return $update; |
|
1173
|
|
|
} |
|
1174
|
|
|
|
|
1175
|
2 |
|
/** |
|
1176
|
|
|
* Alias for getWebhookUpdate |
|
1177
|
2 |
|
* |
|
1178
|
|
|
* @deprecated Call method getWebhookUpdate (note lack of letter s at end) |
|
1179
|
2 |
|
* To be removed in next major version. |
|
1180
|
|
|
* |
|
1181
|
|
|
* @param bool $shouldEmitEvent |
|
1182
|
|
|
* |
|
1183
|
|
|
* @return Update |
|
1184
|
|
|
*/ |
|
1185
|
|
|
public function getWebhookUpdates($shouldEmitEvent = true) |
|
1186
|
|
|
{ |
|
1187
|
|
|
return $this->getWebhookUpdate($shouldEmitEvent); |
|
1188
|
|
|
} |
|
1189
|
|
|
|
|
1190
|
|
|
/** |
|
1191
|
|
|
* Removes the outgoing webhook (if any). |
|
1192
|
|
|
* |
|
1193
|
|
|
* @throws TelegramSDKException |
|
1194
|
|
|
* |
|
1195
|
|
|
* @return TelegramResponse |
|
1196
|
|
|
*/ |
|
1197
|
|
|
public function removeWebhook() |
|
1198
|
|
|
{ |
|
1199
|
|
|
$url = ''; |
|
1200
|
|
|
|
|
1201
|
|
|
return $this->post('setWebhook', compact('url')); |
|
1202
|
|
|
} |
|
1203
|
|
|
|
|
1204
|
|
|
/** |
|
1205
|
6 |
|
* Use this method to receive incoming updates using long polling. |
|
1206
|
|
|
* |
|
1207
|
6 |
|
* <code> |
|
1208
|
|
|
* $params = [ |
|
1209
|
6 |
|
* 'offset' => '', |
|
1210
|
|
|
* 'limit' => '', |
|
1211
|
|
|
* 'timeout' => '', |
|
1212
|
6 |
|
* ]; |
|
1213
|
|
|
* </code> |
|
1214
|
6 |
|
* |
|
1215
|
6 |
|
* @link https://core.telegram.org/bots/api#getupdates |
|
1216
|
6 |
|
* |
|
1217
|
|
|
* @param array $params |
|
1218
|
6 |
|
* @param bool $shouldEmitEvents |
|
1219
|
6 |
|
* @var int|null $params ['offset'] |
|
1220
|
6 |
|
* @var int|null $params ['limit'] |
|
1221
|
|
|
* @var int|null $params ['timeout'] |
|
1222
|
|
|
* |
|
1223
|
|
|
* @throws TelegramSDKException |
|
1224
|
|
|
* |
|
1225
|
|
|
* @return Update[] |
|
1226
|
|
|
*/ |
|
1227
|
|
|
public function getUpdates(array $params = [], $shouldEmitEvents = true) |
|
1228
|
|
|
{ |
|
1229
|
|
|
$response = $this->post('getUpdates', $params); |
|
1230
|
|
|
|
|
1231
|
|
|
return collect($response->getResult()) |
|
1232
|
|
|
->map(function ($data) use ($shouldEmitEvents) { |
|
1233
|
|
|
|
|
1234
|
|
|
$update = new Update($data); |
|
1235
|
|
|
|
|
1236
|
|
|
if ($shouldEmitEvents) { |
|
1237
|
|
|
$this->emitEvent(new UpdateWasReceived($update, $this)); |
|
1238
|
|
|
} |
|
1239
|
|
|
|
|
1240
|
|
|
return $update; |
|
1241
|
|
|
}) |
|
1242
|
|
|
->all(); |
|
1243
|
|
|
} |
|
1244
|
|
|
|
|
1245
|
|
|
|
|
1246
|
|
|
/** |
|
1247
|
|
|
* Builds a custom keyboard markup. |
|
1248
|
|
|
* |
|
1249
|
|
|
* <code> |
|
1250
|
|
|
* $params = [ |
|
1251
|
|
|
* 'keyboard' => '', |
|
1252
|
|
|
* 'resize_keyboard' => '', |
|
1253
|
|
|
* 'one_time_keyboard' => '', |
|
1254
|
|
|
* 'selective' => '', |
|
1255
|
|
|
* ]; |
|
1256
|
|
|
* </code> |
|
1257
|
|
|
* |
|
1258
|
|
|
* @deprecated Use Telegram\Bot\Keyboard\Keyboard::make(array $params = []) instead. |
|
1259
|
|
|
* To be removed in next major version. |
|
1260
|
|
|
* |
|
1261
|
|
|
* @link https://core.telegram.org/bots/api#replykeyboardmarkup |
|
1262
|
|
|
* |
|
1263
|
|
|
* @param array $params |
|
1264
|
|
|
* |
|
1265
|
|
|
* @var array $params ['keyboard'] |
|
1266
|
|
|
* @var bool $params ['resize_keyboard'] |
|
1267
|
|
|
* @var bool $params ['one_time_keyboard'] |
|
1268
|
|
|
* @var bool $params ['selective'] |
|
1269
|
|
|
* |
|
1270
|
|
|
* @return string |
|
1271
|
|
|
*/ |
|
1272
|
|
|
public function replyKeyboardMarkup(array $params) |
|
1273
|
|
|
{ |
|
1274
|
|
|
return Keyboard::make($params); |
|
1275
|
|
|
} |
|
1276
|
|
|
|
|
1277
|
|
|
/** |
|
1278
|
|
|
* Hide the current custom keyboard and display the default letter-keyboard. |
|
1279
|
|
|
* |
|
1280
|
|
|
* <code> |
|
1281
|
|
|
* $params = [ |
|
1282
|
|
|
* 'hide_keyboard' => true, |
|
1283
|
|
|
* 'selective' => false, |
|
1284
|
|
|
* ]; |
|
1285
|
|
|
* </code> |
|
1286
|
|
|
* |
|
1287
|
|
|
* @deprecated Use Telegram\Bot\Keyboard\Keyboard::hide(array $params = []) instead. |
|
1288
|
|
|
* To be removed in next major version. |
|
1289
|
|
|
* |
|
1290
|
|
|
* @link https://core.telegram.org/bots/api#replykeyboardhide |
|
1291
|
|
|
* |
|
1292
|
|
|
* @param array $params |
|
1293
|
|
|
* |
|
1294
|
|
|
* @var bool $params ['hide_keyboard'] |
|
1295
|
|
|
* @var bool $params ['selective'] |
|
1296
|
|
|
* |
|
1297
|
|
|
* @return string |
|
1298
|
|
|
*/ |
|
1299
|
|
|
public static function replyKeyboardHide(array $params = []) |
|
1300
|
|
|
{ |
|
1301
|
|
|
return Keyboard::hide($params); |
|
1302
|
|
|
} |
|
1303
|
|
|
|
|
1304
|
|
|
/** |
|
1305
|
|
|
* Display a reply interface to the user (act as if the user has selected the bot‘s message and tapped ’Reply'). |
|
1306
|
|
|
* |
|
1307
|
|
|
* <code> |
|
1308
|
|
|
* $params = [ |
|
1309
|
|
|
* 'force_reply' => true, |
|
1310
|
|
|
* 'selective' => false, |
|
1311
|
|
|
* ]; |
|
1312
|
|
|
* </code> |
|
1313
|
|
|
* |
|
1314
|
|
|
* @deprecated Use Telegram\Bot\Keyboard\Keyboard::forceReply(array $params = []) instead. |
|
1315
|
|
|
* To be removed in next major version. |
|
1316
|
6 |
|
* |
|
1317
|
|
|
* @link https://core.telegram.org/bots/api#forcereply |
|
1318
|
6 |
|
* |
|
1319
|
|
|
* @param array $params |
|
1320
|
|
|
* |
|
1321
|
|
|
* @var bool $params ['force_reply'] |
|
1322
|
|
|
* @var bool $params ['selective'] |
|
1323
|
|
|
* |
|
1324
|
|
|
* @return Keyboard |
|
1325
|
6 |
|
*/ |
|
1326
|
6 |
|
public static function forceReply(array $params = []) |
|
1327
|
|
|
{ |
|
1328
|
6 |
|
return Keyboard::forceReply($params); |
|
1329
|
6 |
|
} |
|
1330
|
6 |
|
|
|
1331
|
6 |
|
/** |
|
1332
|
|
|
* Processes Inbound Commands. |
|
1333
|
|
|
* |
|
1334
|
6 |
|
* @param bool $webhook |
|
1335
|
6 |
|
* |
|
1336
|
6 |
|
* @return Update|Update[] |
|
1337
|
6 |
|
*/ |
|
1338
|
6 |
|
public function commandsHandler($webhook = false) |
|
1339
|
6 |
|
{ |
|
1340
|
|
|
if ($webhook) { |
|
1341
|
6 |
|
$update = $this->getWebhookUpdates(); |
|
|
|
|
|
|
1342
|
|
|
$this->processCommand($update); |
|
1343
|
|
|
|
|
1344
|
|
|
return $update; |
|
1345
|
|
|
} |
|
1346
|
|
|
|
|
1347
|
|
|
$updates = $this->getUpdates(); |
|
1348
|
|
|
$highestId = -1; |
|
1349
|
6 |
|
|
|
1350
|
|
|
foreach ($updates as $update) { |
|
1351
|
6 |
|
$highestId = $update->getUpdateId(); |
|
1352
|
|
|
$this->processCommand($update); |
|
1353
|
6 |
|
} |
|
1354
|
6 |
|
|
|
1355
|
6 |
|
//An update is considered confirmed as soon as getUpdates is called with an offset higher than its update_id. |
|
1356
|
6 |
|
if ($highestId != -1) { |
|
1357
|
|
|
$params = []; |
|
1358
|
|
|
$params['offset'] = $highestId + 1; |
|
1359
|
|
|
$params['limit'] = 1; |
|
1360
|
|
|
$this->markUpdateAsRead($params); |
|
1361
|
|
|
} |
|
1362
|
|
|
|
|
1363
|
|
|
return $updates; |
|
1364
|
|
|
} |
|
1365
|
|
|
|
|
1366
|
|
|
/** |
|
1367
|
|
|
* Check update object for a command and process. |
|
1368
|
|
|
* |
|
1369
|
|
|
* @param Update $update |
|
1370
|
|
|
*/ |
|
1371
|
|
|
public function processCommand(Update $update) |
|
1372
|
|
|
{ |
|
1373
|
|
|
$message = $update->getMessage(); |
|
1374
|
|
|
|
|
1375
|
|
|
if ($message !== null && $message->has('text')) { |
|
1376
|
|
|
$this->getCommandBus()->handler($message->getText(), $update); |
|
1377
|
|
|
} |
|
1378
|
|
|
} |
|
1379
|
|
|
|
|
1380
|
|
|
/** |
|
1381
|
|
|
* Helper to Trigger Commands. |
|
1382
|
|
|
* |
|
1383
|
|
|
* @param string $name Command Name |
|
1384
|
|
|
* @param Update $update Update Object |
|
1385
|
|
|
* |
|
1386
|
|
|
* @return mixed |
|
1387
|
|
|
*/ |
|
1388
|
|
|
public function triggerCommand($name, Update $update) |
|
1389
|
|
|
{ |
|
1390
|
|
|
return $this->getCommandBus()->execute($name, $update->getMessage()->getText(), $update); |
|
1391
|
|
|
} |
|
1392
|
|
|
|
|
1393
|
|
|
/** |
|
1394
|
|
|
* Determine if a given type is the message. |
|
1395
|
|
|
* |
|
1396
|
|
|
* @deprecated Call method isType directly on Message object |
|
1397
|
|
|
* To be removed in next major version. |
|
1398
|
|
|
* |
|
1399
|
|
|
* @param string $type |
|
1400
|
|
|
* @param Update|Message $object |
|
1401
|
|
|
* |
|
1402
|
|
|
* @throws \ErrorException |
|
1403
|
|
|
* |
|
1404
|
|
|
*/ |
|
1405
|
|
|
public function isMessageType($type, $object) |
|
|
|
|
|
|
1406
|
|
|
{ |
|
1407
|
|
|
trigger_error('This method has been deprecated. Use isType() on the Message object instead.', E_USER_DEPRECATED); |
|
1408
|
|
|
} |
|
1409
|
|
|
|
|
1410
|
|
|
/** |
|
1411
|
|
|
* Detect Message Type Based on Update or Message Object. |
|
1412
|
|
|
* |
|
1413
|
|
|
* @deprecated Call method detectType directly on Message object |
|
1414
|
|
|
* To be removed in next major version. |
|
1415
|
|
|
* |
|
1416
|
|
|
* @param Update|Message $object |
|
1417
|
|
|
* |
|
1418
|
|
|
* @throws \ErrorException |
|
1419
|
|
|
* |
|
1420
|
|
|
* @return string|null |
|
1421
|
|
|
*/ |
|
1422
|
|
|
public function detectMessageType($object) |
|
|
|
|
|
|
1423
|
|
|
{ |
|
1424
|
|
|
trigger_error('This method has been deprecated. Use detectType() on the Message object instead.', E_USER_DEPRECATED); |
|
1425
|
|
|
} |
|
1426
|
|
|
|
|
1427
|
|
|
/** |
|
1428
|
|
|
* Sends a GET request to Telegram Bot API and returns the result. |
|
1429
|
|
|
* |
|
1430
|
|
|
* @param string $endpoint |
|
1431
|
|
|
* @param array $params |
|
1432
|
|
|
* |
|
1433
|
|
|
* @throws TelegramSDKException |
|
1434
|
|
|
* |
|
1435
|
|
|
* @return TelegramResponse |
|
1436
|
|
|
*/ |
|
1437
|
40 |
|
protected function get($endpoint, $params = []) |
|
1438
|
|
|
{ |
|
1439
|
40 |
|
if (array_key_exists('reply_markup', $params)) { |
|
1440
|
16 |
|
$params['reply_markup'] = (string)$params['reply_markup']; |
|
1441
|
16 |
|
} |
|
1442
|
|
|
|
|
1443
|
24 |
|
return $this->sendRequest( |
|
1444
|
|
|
'GET', |
|
1445
|
|
|
$endpoint, |
|
1446
|
|
|
$params |
|
1447
|
24 |
|
); |
|
1448
|
|
|
} |
|
1449
|
|
|
|
|
1450
|
40 |
|
/** |
|
1451
|
40 |
|
* Sends a POST request to Telegram Bot API and returns the result. |
|
1452
|
40 |
|
* |
|
1453
|
|
|
* @param string $endpoint |
|
1454
|
40 |
|
* @param array $params |
|
1455
|
|
|
* @param bool $fileUpload Set true if a file is being uploaded. |
|
1456
|
|
|
* |
|
1457
|
|
|
* @return TelegramResponse |
|
1458
|
|
|
*/ |
|
1459
|
|
|
protected function post($endpoint, array $params = [], $fileUpload = false) |
|
1460
|
|
|
{ |
|
1461
|
|
|
if ($fileUpload) { |
|
1462
|
|
|
$params = ['multipart' => $params]; |
|
1463
|
|
|
} else { |
|
1464
|
|
|
|
|
1465
|
|
|
if (array_key_exists('reply_markup', $params)) { |
|
1466
|
|
|
$params['reply_markup'] = (string)$params['reply_markup']; |
|
1467
|
|
|
} |
|
1468
|
16 |
|
|
|
1469
|
|
|
$params = ['form_params' => $params]; |
|
1470
|
16 |
|
} |
|
1471
|
|
|
|
|
1472
|
16 |
|
return $this->sendRequest( |
|
1473
|
16 |
|
'POST', |
|
1474
|
16 |
|
$endpoint, |
|
1475
|
|
|
$params |
|
1476
|
16 |
|
); |
|
1477
|
|
|
} |
|
1478
|
|
|
|
|
1479
|
|
|
/** |
|
1480
|
|
|
* Sends a multipart/form-data request to Telegram Bot API and returns the result. |
|
1481
|
16 |
|
* Used primarily for file uploads. |
|
1482
|
16 |
|
* |
|
1483
|
16 |
|
* @param string $endpoint |
|
1484
|
16 |
|
* @param array $params |
|
1485
|
|
|
* |
|
1486
|
16 |
|
* @throws TelegramSDKException |
|
1487
|
16 |
|
* |
|
1488
|
|
|
* @return TelegramResponse |
|
1489
|
16 |
|
*/ |
|
1490
|
|
|
protected function uploadFile($endpoint, array $params = []) |
|
1491
|
|
|
{ |
|
1492
|
|
|
$multipart_params = collect($params) |
|
1493
|
|
|
->reject(function ($value) { |
|
1494
|
|
|
return is_null($value); |
|
1495
|
|
|
}) |
|
1496
|
|
|
->map(function ($contents, $name) { |
|
1497
|
|
|
|
|
1498
|
|
|
if (!is_resource($contents) && $this->isValidFileOrUrl($name, $contents)) { |
|
1499
|
|
|
$contents = (new InputFile($contents))->open(); |
|
1500
|
|
|
} |
|
1501
|
|
|
|
|
1502
|
|
|
return [ |
|
1503
|
40 |
|
'name' => $name, |
|
1504
|
|
|
'contents' => $contents, |
|
1505
|
|
|
]; |
|
1506
|
|
|
}) |
|
1507
|
|
|
//Reset the keys on the collection |
|
1508
|
40 |
|
->values() |
|
1509
|
|
|
->all(); |
|
1510
|
40 |
|
|
|
1511
|
|
|
return $this->post($endpoint, $multipart_params, true); |
|
1512
|
|
|
} |
|
1513
|
|
|
|
|
1514
|
|
|
/** |
|
1515
|
|
|
* Sends a request to Telegram Bot API and returns the result. |
|
1516
|
|
|
* |
|
1517
|
|
|
* @param string $method |
|
1518
|
|
|
* @param string $endpoint |
|
1519
|
|
|
* @param array $params |
|
1520
|
|
|
* |
|
1521
|
|
|
* @throws TelegramSDKException |
|
1522
|
40 |
|
* |
|
1523
|
|
|
* @return TelegramResponse |
|
1524
|
|
|
*/ |
|
1525
|
|
|
protected function sendRequest( |
|
1526
|
|
|
$method, |
|
1527
|
40 |
|
$endpoint, |
|
1528
|
40 |
|
array $params = [] |
|
1529
|
40 |
|
) { |
|
1530
|
40 |
|
$request = $this->request($method, $endpoint, $params); |
|
1531
|
40 |
|
|
|
1532
|
40 |
|
return $this->lastResponse = $this->client->sendRequest($request); |
|
1533
|
40 |
|
} |
|
1534
|
40 |
|
|
|
1535
|
40 |
|
/** |
|
1536
|
|
|
* Instantiates a new TelegramRequest entity. |
|
1537
|
|
|
* |
|
1538
|
|
|
* @param string $method |
|
1539
|
|
|
* @param string $endpoint |
|
1540
|
|
|
* @param array $params |
|
1541
|
|
|
* |
|
1542
|
|
|
* @return TelegramRequest |
|
1543
|
|
|
*/ |
|
1544
|
|
|
protected function request( |
|
1545
|
|
|
$method, |
|
1546
|
|
|
$endpoint, |
|
1547
|
|
|
array $params = [] |
|
1548
|
2 |
|
) { |
|
1549
|
|
|
return new TelegramRequest( |
|
1550
|
2 |
|
$this->getAccessToken(), |
|
1551
|
2 |
|
$method, |
|
1552
|
|
|
$endpoint, |
|
1553
|
|
|
$params, |
|
1554
|
|
|
$this->isAsyncRequest(), |
|
1555
|
|
|
$this->getTimeOut(), |
|
1556
|
|
|
$this->getConnectTimeOut() |
|
1557
|
|
|
); |
|
1558
|
|
|
} |
|
1559
|
|
|
|
|
1560
|
|
|
/** |
|
1561
|
|
|
* Magic method to process any "get" requests. |
|
1562
|
|
|
* |
|
1563
|
|
|
* @param $method |
|
1564
|
|
|
* @param $arguments |
|
1565
|
|
|
* |
|
1566
|
|
|
* @throws TelegramSDKException |
|
1567
|
|
|
* |
|
1568
|
|
|
* @return bool|TelegramResponse|UnknownObject |
|
1569
|
|
|
*/ |
|
1570
|
|
|
public function __call($method, $arguments) |
|
1571
|
|
|
{ |
|
1572
|
|
|
if (preg_match('/^\w+Commands?/', $method, $matches)) { |
|
1573
|
|
|
return call_user_func_array([$this->getCommandBus(), $matches[0]], $arguments); |
|
1574
|
|
|
} |
|
1575
|
|
|
|
|
1576
|
|
|
$action = substr($method, 0, 3); |
|
1577
|
|
|
if ($action === 'get') { |
|
1578
|
|
|
/* @noinspection PhpUndefinedFunctionInspection */ |
|
1579
|
2 |
|
$class_name = studly_case(substr($method, 3)); |
|
1580
|
|
|
$class = 'Telegram\Bot\Objects\\'.$class_name; |
|
1581
|
2 |
|
$response = $this->post($method, $arguments[0] ?: []); |
|
1582
|
2 |
|
|
|
1583
|
|
|
if (class_exists($class)) { |
|
1584
|
|
|
return new $class($response->getDecodedBody()); |
|
1585
|
|
|
} |
|
1586
|
|
|
|
|
1587
|
|
|
return $response; |
|
1588
|
|
|
} |
|
1589
|
2 |
|
$response = $this->post($method, $arguments[0]); |
|
1590
|
|
|
|
|
1591
|
2 |
|
return new UnknownObject($response->getDecodedBody()); |
|
1592
|
|
|
} |
|
1593
|
|
|
|
|
1594
|
|
|
/** |
|
1595
|
|
|
* Set the IoC Container. |
|
1596
|
|
|
* |
|
1597
|
|
|
* @param $container Container instance |
|
1598
|
|
|
* |
|
1599
|
|
|
* @return void |
|
1600
|
|
|
*/ |
|
1601
|
|
|
public static function setContainer(Container $container) |
|
1602
|
|
|
{ |
|
1603
|
|
|
self::$container = $container; |
|
1604
|
|
|
} |
|
1605
|
|
|
|
|
1606
|
|
|
/** |
|
1607
|
40 |
|
* Get the IoC Container. |
|
1608
|
|
|
* |
|
1609
|
40 |
|
* @return Container |
|
1610
|
|
|
*/ |
|
1611
|
|
|
public function getContainer() |
|
1612
|
|
|
{ |
|
1613
|
|
|
return self::$container; |
|
1614
|
|
|
} |
|
1615
|
|
|
|
|
1616
|
|
|
/** |
|
1617
|
2 |
|
* Check if IoC Container has been set. |
|
1618
|
|
|
* |
|
1619
|
2 |
|
* @return boolean |
|
1620
|
|
|
*/ |
|
1621
|
2 |
|
public function hasContainer() |
|
1622
|
|
|
{ |
|
1623
|
|
|
return self::$container !== null; |
|
1624
|
|
|
} |
|
1625
|
|
|
|
|
1626
|
|
|
/** |
|
1627
|
40 |
|
* @return int |
|
1628
|
|
|
*/ |
|
1629
|
40 |
|
public function getTimeOut() |
|
1630
|
|
|
{ |
|
1631
|
|
|
return $this->timeOut; |
|
1632
|
|
|
} |
|
1633
|
|
|
|
|
1634
|
|
|
/** |
|
1635
|
|
|
* @param int $timeOut |
|
1636
|
|
|
* |
|
1637
|
2 |
|
* @return $this |
|
1638
|
|
|
*/ |
|
1639
|
2 |
|
public function setTimeOut($timeOut) |
|
1640
|
|
|
{ |
|
1641
|
2 |
|
$this->timeOut = $timeOut; |
|
1642
|
|
|
|
|
1643
|
|
|
return $this; |
|
1644
|
|
|
} |
|
1645
|
|
|
|
|
1646
|
|
|
/** |
|
1647
|
|
|
* @return int |
|
1648
|
|
|
*/ |
|
1649
|
|
|
public function getConnectTimeOut() |
|
1650
|
|
|
{ |
|
1651
|
6 |
|
return $this->connectTimeOut; |
|
1652
|
|
|
} |
|
1653
|
6 |
|
|
|
1654
|
|
|
/** |
|
1655
|
|
|
* @param int $connectTimeOut |
|
1656
|
|
|
* |
|
1657
|
|
|
* @return $this |
|
1658
|
|
|
*/ |
|
1659
|
|
|
public function setConnectTimeOut($connectTimeOut) |
|
1660
|
|
|
{ |
|
1661
|
|
|
$this->connectTimeOut = $connectTimeOut; |
|
1662
|
|
|
|
|
1663
|
|
|
return $this; |
|
1664
|
|
|
} |
|
1665
|
16 |
|
|
|
1666
|
|
|
/** |
|
1667
|
|
|
* An alias for getUpdates that helps readability. |
|
1668
|
16 |
|
* |
|
1669
|
2 |
|
* @param $params |
|
1670
|
|
|
* |
|
1671
|
|
|
* @return Objects\Update[] |
|
1672
|
|
|
*/ |
|
1673
|
|
|
protected function markUpdateAsRead($params) |
|
1674
|
14 |
|
{ |
|
1675
|
|
|
return $this->getUpdates($params, false); |
|
1676
|
|
|
} |
|
1677
|
|
|
|
|
1678
|
|
|
/** |
|
1679
|
14 |
|
* Determines if the string passed to be uploaded is a valid |
|
1680
|
|
|
* file on the local file system, or a valid remote URL. |
|
1681
|
|
|
* |
|
1682
|
|
|
* @param string $name |
|
1683
|
|
|
* @param string $contents |
|
1684
|
14 |
|
* |
|
1685
|
|
|
* @return bool |
|
1686
|
|
|
*/ |
|
1687
|
|
|
protected function isValidFileOrUrl($name, $contents) |
|
1688
|
|
|
{ |
|
1689
|
|
|
//Don't try to open a url as an actual file when using this method to setWebhook. |
|
1690
|
|
|
if ($name == 'url') { |
|
1691
|
|
|
return false; |
|
1692
|
|
|
} |
|
1693
|
|
|
|
|
1694
|
|
|
//If a certificate name is passed, we must check for the file existing on the local server, |
|
1695
|
|
|
// otherwise telegram ignores the fact it wasn't sent and no error is thrown. |
|
1696
|
|
|
if ($name == 'certificate') { |
|
1697
|
|
|
return true; |
|
1698
|
|
|
} |
|
1699
|
|
|
|
|
1700
|
|
|
//Is the content a valid file name. |
|
1701
|
|
|
if (is_readable($contents)) { |
|
1702
|
|
|
return true; |
|
1703
|
|
|
} |
|
1704
|
|
|
|
|
1705
|
|
|
//Is the content a valid URL |
|
1706
|
|
|
return filter_var($contents, FILTER_VALIDATE_URL); |
|
1707
|
|
|
} |
|
1708
|
|
|
} |
|
1709
|
|
|
|
irazasyed /
telegram-bot-sdk
Loading history...
This method has been deprecated. The supplier of the class has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead.