2024-11-01 15:47:02 -04:00
|
|
|
<?php
|
|
|
|
|
|
|
|
namespace TgBotLib;
|
|
|
|
|
2024-11-04 00:56:21 -05:00
|
|
|
use RuntimeException;
|
2024-11-01 15:47:02 -04:00
|
|
|
use TgBotLib\Abstracts\UpdateEvent;
|
2024-11-04 00:56:21 -05:00
|
|
|
use TgBotLib\Classes\Logger;
|
2024-11-03 18:25:42 -05:00
|
|
|
use TgBotLib\Enums\EventType;
|
2024-11-04 01:17:03 -05:00
|
|
|
use TgBotLib\Events\CommandEvent;
|
|
|
|
use TgBotLib\Objects\Update;
|
2024-11-04 00:56:21 -05:00
|
|
|
use Throwable;
|
2024-11-01 15:47:02 -04:00
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* PollingBot class that extends Bot for handling updates using polling.
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
class PollingBot extends Bot
|
|
|
|
{
|
|
|
|
private ?int $offset;
|
|
|
|
private int $limit;
|
|
|
|
private int $timeout;
|
|
|
|
private array $allowedUpdates;
|
2024-11-04 00:56:21 -05:00
|
|
|
private bool $fork;
|
2024-11-01 15:47:02 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructor for the class, initializing with a Bot instance.
|
|
|
|
*
|
|
|
|
* @param string $token
|
|
|
|
* @param string $endpoint
|
|
|
|
*/
|
|
|
|
public function __construct(string $token, string $endpoint='https://api.telegram.org')
|
|
|
|
{
|
|
|
|
parent::__construct($token, $endpoint);
|
|
|
|
$this->offset = null;
|
|
|
|
$this->limit = 100;
|
|
|
|
$this->timeout = 0;
|
|
|
|
$this->allowedUpdates = [];
|
2024-11-04 00:56:21 -05:00
|
|
|
$this->fork = false;
|
2024-11-01 15:47:02 -04:00
|
|
|
}
|
|
|
|
|
2024-11-04 00:56:21 -05:00
|
|
|
/**
|
|
|
|
* Sets the offset value.
|
|
|
|
*
|
|
|
|
* @param int $offset The offset value to be set.
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function setOffset(int $offset): void
|
|
|
|
{
|
|
|
|
$this->offset = $offset;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Retrieves the current offset value.
|
|
|
|
*
|
|
|
|
* @return int The current offset.
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function getOffset(): int
|
|
|
|
{
|
|
|
|
return $this->offset;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Sets the limit for the number of items to process.
|
|
|
|
*
|
|
|
|
* @param int $limit The maximum number of items to be processed.
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function setLimit(int $limit): void
|
|
|
|
{
|
|
|
|
$this->limit = $limit;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Retrieves the limit for the current operation.
|
|
|
|
*
|
|
|
|
* @return int The limit value.
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function getLimit(): int
|
|
|
|
{
|
|
|
|
return $this->limit;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Sets the timeout value.
|
|
|
|
*
|
|
|
|
* @param int $timeout The timeout value to set.
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function setTimeout(int $timeout): void
|
|
|
|
{
|
|
|
|
$this->timeout = $timeout;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Retrieves the current timeout setting.
|
|
|
|
*
|
|
|
|
* @return int The configured timeout value.
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function getTimeout(): int
|
|
|
|
{
|
|
|
|
return $this->timeout;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Sets the list of allowed updates.
|
|
|
|
*
|
|
|
|
* @param array $allowedUpdates The array of update types that should be allowed.
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function setAllowedUpdates(array $allowedUpdates): void
|
|
|
|
{
|
|
|
|
$this->allowedUpdates = $allowedUpdates;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getAllowedUpdates(): array
|
|
|
|
{
|
|
|
|
return $this->allowedUpdates;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Adds a new allowed update type to the list if it does not already exist.
|
|
|
|
*
|
|
|
|
* @param string $allowedUpdate The type of update to allow.
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function addAllowedUpdate(string $allowedUpdate): void
|
|
|
|
{
|
|
|
|
if(in_array($allowedUpdate, $this->allowedUpdates))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$this->allowedUpdates[] = $allowedUpdate;
|
|
|
|
}
|
|
|
|
|
2024-11-04 00:56:21 -05:00
|
|
|
/**
|
|
|
|
* Sets whether updates should be processed in a forked process
|
|
|
|
*
|
|
|
|
* @param bool $fork
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
public function setFork(bool $fork): void
|
|
|
|
{
|
|
|
|
$this->fork = $fork;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the current fork setting
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function getFork(): bool
|
|
|
|
{
|
|
|
|
return $this->fork;
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Handles incoming updates by fetching and processing them with appropriate event handlers.
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
public function handleUpdates(): void
|
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
$updates = $this->getUpdates(offset: ($this->offset ?: 0), limit: $this->limit, timeout: $this->timeout, allowed_updates: $this->retrieveAllowedUpdates());
|
|
|
|
|
|
|
|
if (empty($updates))
|
2024-11-01 15:47:02 -04:00
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the offset based on the last update ID
|
|
|
|
$lastUpdate = end($updates);
|
|
|
|
if ($lastUpdate->getUpdateId() > ($this->offset ?? 0))
|
|
|
|
{
|
|
|
|
$this->offset = $lastUpdate->getUpdateId() + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($this->fork)
|
|
|
|
{
|
|
|
|
$this->handleUpdatesInFork($updates);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
$this->processUpdates($updates);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handles updates in a forked child process
|
|
|
|
*
|
|
|
|
* @param array $updates
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
private function handleUpdatesInFork(array $updates): void
|
|
|
|
{
|
|
|
|
$pid = pcntl_fork();
|
|
|
|
|
|
|
|
if ($pid == -1)
|
|
|
|
{
|
|
|
|
// Fork failed
|
|
|
|
throw new RuntimeException('Failed to fork process for update handling');
|
|
|
|
}
|
|
|
|
elseif ($pid)
|
|
|
|
{
|
|
|
|
// Parent process
|
|
|
|
// Wait for child to finish to prevent zombie processes
|
|
|
|
pcntl_wait($status);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Child process
|
|
|
|
try
|
|
|
|
{
|
|
|
|
$this->processUpdates($updates);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
catch (Throwable $e)
|
2024-11-01 15:47:02 -04:00
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
Logger::getLogger()->error("Error in forked process: " . $e->getMessage());
|
|
|
|
exit(1);
|
2024-11-01 15:47:02 -04:00
|
|
|
}
|
2024-11-04 00:56:21 -05:00
|
|
|
}
|
|
|
|
}
|
2024-11-01 15:47:02 -04:00
|
|
|
|
2024-11-04 00:56:21 -05:00
|
|
|
/**
|
|
|
|
* Processes a batch of updates with appropriate event handlers
|
|
|
|
*
|
|
|
|
* @param array $updates
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
private function processUpdates(array $updates): void
|
|
|
|
{
|
2024-11-04 01:17:03 -05:00
|
|
|
/** @var Update $update */
|
2024-11-04 00:56:21 -05:00
|
|
|
foreach ($updates as $update)
|
|
|
|
{
|
2024-11-04 01:17:03 -05:00
|
|
|
// Check if the update contains a command
|
2024-11-04 01:17:47 -05:00
|
|
|
$command = $update?->getAnyMessage()?->getCommand();
|
2024-11-04 01:17:03 -05:00
|
|
|
if ($command !== null)
|
|
|
|
{
|
|
|
|
$commandHandlers = $this->getEventHandlersByCommand($command);
|
|
|
|
foreach ($commandHandlers as $commandHandler)
|
|
|
|
{
|
2024-11-04 01:19:44 -05:00
|
|
|
(new $commandHandler($update))->handle($this);
|
2024-11-04 01:17:03 -05:00
|
|
|
}
|
2024-11-04 01:19:44 -05:00
|
|
|
|
|
|
|
continue;
|
2024-11-04 01:17:03 -05:00
|
|
|
}
|
2024-11-01 18:21:40 -04:00
|
|
|
|
2024-11-04 01:17:03 -05:00
|
|
|
// Check if the update contains a callback query
|
|
|
|
$updateByType = $this->getEventHandlersByType(EventType::determineEventType($update));
|
2024-11-04 00:56:21 -05:00
|
|
|
if (count($updateByType) === 0)
|
2024-11-01 18:21:40 -04:00
|
|
|
{
|
|
|
|
// If no event handlers are found appropriate for the update type, use the generic update event handler
|
2024-11-04 00:56:21 -05:00
|
|
|
foreach ($this->getEventHandlersByType(EventType::UPDATE_EVENT) as $eventHandler)
|
2024-11-01 18:21:40 -04:00
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
/** @var UpdateEvent $eventHandler */
|
2024-11-01 18:21:40 -04:00
|
|
|
(new $eventHandler($update))->handle($this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2024-11-01 15:47:02 -04:00
|
|
|
{
|
2024-11-01 18:21:40 -04:00
|
|
|
// Otherwise, use the appropriate event handler for the update type
|
2024-11-04 00:56:21 -05:00
|
|
|
foreach ($updateByType as $eventHandler)
|
2024-11-01 18:21:40 -04:00
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
/** @var UpdateEvent $eventHandler */
|
2024-11-01 18:21:40 -04:00
|
|
|
(new $eventHandler($update))->handle($this);
|
|
|
|
}
|
2024-11-01 15:47:02 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-11-01 21:25:50 -04:00
|
|
|
/**
|
|
|
|
* Retrieves the allowed updates.
|
|
|
|
*
|
|
|
|
* @return array|null Returns an array of allowed updates if available, otherwise null.
|
|
|
|
*/
|
2024-11-01 15:47:02 -04:00
|
|
|
private function retrieveAllowedUpdates(): ?array
|
|
|
|
{
|
2024-11-04 00:56:21 -05:00
|
|
|
if (count($this->allowedUpdates) === 0)
|
2024-11-01 15:47:02 -04:00
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $this->allowedUpdates;
|
|
|
|
}
|
|
|
|
}
|