UpdateHandler::resolve() - Code Metrics - Inspection of "Updated `scrutinizer` configuration" - telegram-bot-php/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 4c2b59...061776 )

by Shahrad
created 2022-08-21 07:57 UTC
UpdateHandler::resolve() A

↳ Parent: UpdateHandler
Complexity

Conditions	6
Paths	13
Size

Total Lines	22
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	12
c	1
b	0
f	0
dl	0
loc	22
rs	9.2222
cc	6
nc	13
nop	2
<?php

namespace TelegramBot;

use TelegramBot\Entities\Update;
use TelegramBot\Exception\InvalidBotTokenException;
use TelegramBot\Interfaces\HandlerInterface;
use TelegramBot\Traits\HandlerTrait;
use TelegramBot\Util\Toolkit;

/**
 * UpdateHandler class
 *
 * @link    https://github.com/telegram-bot-php/core
 * @author  Shahrad Elahi (https://github.com/shahradelahi)
 * @license https://github.com/telegram-bot-php/core/blob/master/LICENSE (MIT License)
 */
class UpdateHandler extends Telegram implements HandlerInterface
{

    use HandlerTrait;

    /**
     * @var ?Update
     */
    protected ?Update $update;

    /**
     * @var Plugin[]
     */
    private array $plugins = [];

    /**
     * @var bool
     */
    private bool $active_spreader = false;

    /**
     * The default configuration of the webhook.
     *
     * @var array
     */
    private array $config = [
        'autoload_env_file' => false,
        'env_file_path' => null,
    ];

    /**
     * Webhook constructor.
     *
     * @param string $api_token The API key of the bot. Leave it blank for autoload from .env file.
     */
    public function __construct(string $api_token = '')
    {
        parent::__construct($api_token);

        if (!Telegram::validateToken(self::getApiToken())) {
        if (!Telegram::validateToken(/** @scrutinizer ignore-type */ self::getApiToken())) {
            throw new InvalidBotTokenException();
        }
    }

    /**
     * Add plugins to the receiver
     *
     * @param Plugin[]|array $plugins
     * @retrun void
     */
    public function addPlugins(Plugin|array $plugins): UpdateHandler
    {
        if (is_object($plugins)) {

            $plugins = [$plugins];
        }

        foreach ($plugins as $plugin) {
            if (!is_subclass_of($plugin, Plugin::class)) {
                throw new \RuntimeException(
                    sprintf('The plugin %s must be an instance of %s', get_class($plugin), Plugin::class)
                );
            }

            $reflection = Toolkit::reflectionClass($plugin);

            $this->plugins[] = [
                'class' => $plugin,
                'initialized' => is_object($plugin),
            ];
        }

        return $this;
    }

    /**
     * Match the update with the given plugins
     *
     * @param Plugin[]|array $plugins
     * @return void
     */
    private function loadPlugins(array $plugins): void
    {
        $update = $update ?? ($this->update ?? Telegram::getUpdate());


        foreach ($plugins as $plugin) {
            if (!is_subclass_of($plugin['class'], Plugin::class)) {
                throw new \InvalidArgumentException(sprintf(
                    'The plugin %s must be an instance of %s',
                    get_class($plugin['class']), Plugin::class
                ));
            }
        }

        if (!$update instanceof Update) {
            throw new \InvalidArgumentException(sprintf(
                'The update must be an instance of %s. %s given',
                Update::class, gettype($update)
            ));
        }

        $this->spreadUpdateWith($update, $plugins);
    }

    /**
     * This function will get update and spread it to the plugins
     *
     * @param Update $update
     * @param array<Plugin> $plugins
     * @return void
     */
    private function spreadUpdateWith(Update $update, array $plugins): void
    {
        $this->active_spreader = true;

        foreach ($plugins as $plugin) {
            if ($plugin['initialized'] === false) {
                $plugin['class'] = new $plugin['class']();
            }

            $plugin['class']->__execute($this, $update);
            if ($this->active_spreader === false) break;
        }

        $this->active_spreader = false;
    }

    /**
     * Resolve the request.
     *
     * @param ?Update $update The custom to work with
     * @param array $config The configuration of the receiver
     *
     * @retrun void
     */
    public function resolve(Update $update = null, array $config = []): void
    {
        if (!method_exists($this, '__process')) {
            throw new \RuntimeException('The method __process does not exist');
        }

        if (is_array($config)) $this->updateConfiguration($config);


        if (!empty($update)) $this->update = $update;
        else $this->update = Telegram::getUpdate() !== false ? Telegram::getUpdate() : null;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        if (empty($this->update)) {
            TelegramLog::error(
                'The update is empty, the request is not processed'
            );
            return;
        }

        putenv('TG_CURRENT_UPDATE=' . $this->update->getRawData(false));

        $this->__process($this->update);
        $this->loadPlugins($this->plugins);
    }

    /**
     * Resolve the request on single plugin.
     *
     * @param Plugin $plugin The plugin to work with
     * @param ?Update $update The custom to work with
     * @param array $config The configuration of the receiver
     * @return void
     */
    public static function resolveOn(Plugin $plugin, Update $update = null, array $config = []): void
    public static function resolveOn(Plugin $plugin, Update $update = null, /** @scrutinizer ignore-unused */ array $config = []): void
    {
        // TODO: Implement resolveOn() method.
    }

    /**
     * Update the configuration
     *
     * @param array $configuration
     * @return void
     */
    public function updateConfiguration(array $configuration): void
    {
        $this->config = array_merge($this->config, $configuration);
    }

    /**
     * Stop the spreader process
     *
     * @return void
     */
    public function stop(): void
    {
        $this->active_spreader = false;
    }

}
telegram-bot-php / core

Push — master ( 4c2b59...061776 )

UpdateHandler::resolve() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
