BlitzPHP\Tasks\TaskRunner

Complexity

Total Complexity

23

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	6
Bugs	3	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	withTestTime()	0	5	1
B	run()	0	44	11
A	updateLogs()	0	35	5
A	__construct()	0	3	1
A	only()	0	5	1
A	cliWrite()	0	18	4

<?php

declare(strict_types=1);

/**
 * This file is part of BlitzPHP Tasks.
 *
 * (c) 2025 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Tasks;

use Ahc\Cli\Output\Color;
use Ahc\Cli\Output\Writer;
use BlitzPHP\Utilities\Date;
use Throwable;

/**
 * @credit <a href="https://tasks.codeigniter.com">CodeIgniter4 - CodeIgniter\Tasks\TaskRunner</a>
 */
class TaskRunner
{
    protected Scheduler $scheduler;
    protected ?string $testTime = null;

    /**
     * Stocke les alias des tâches à exécuter
     * Si vide, toutes les tâches seront exécutées selon leur planification.
     *
     * @var list<mixed>

The type BlitzPHP\Tasks\list was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected array $only = [];

    /**
     * Instance de la sortie de la console
     */
    protected static ?Writer $writter = null;

    public function __construct(?Scheduler $scheduler = null)
    {
        $this->scheduler = $scheduler ?? service('scheduler');
    }

    /**
     * Point d'entrée principal pour l'exécution des tâches au sein du système.
     * Il s'occupe également de la collecte des données de sortie et de l'envoi de notifications si nécessaire.
     */
    public function run(): void
    {
        $tasks = $this->scheduler->getTasks();

        if ($tasks === []) {
            return;
        }

        foreach ($tasks as $task) {
            // Si des tâches spécifiques ont été choisies, sauter l'exécution des tâches restantes.
            if (! empty($this->only) && ! in_array($task->name, $this->only, true)) {
                continue;
            }

            if (! $task->shouldRun($this->testTime) && empty($this->only)) {
                continue;
            }

            $error  = null;
            $start  = Date::now();
            $output = null;

The assignment to $output is dead and can be removed.

            $this->cliWrite('Traitement: ' . ($task->name ?: 'Task'), Color::GREEN);

            try {
                $output = $task->run();

                $this->cliWrite('Exécuté: ' . ($task->name ?: 'Task'), Color::CYAN);
            } catch (Throwable $e) {
                $this->cliWrite('Échoué: ' . ($task->name ?: 'Task'), Color::RED);

                logger()->error($e->getMessage(), $e->getTrace());
                $error = $e;
            } finally {
                // Sauvegarde des informations sur les performances
                $taskLog = new TaskLog([
                    'task'     => $task,
                    'output'   => $output,
                    'runStart' => $start,
                    'runEnd'   => Date::now(),
                    'error'    => $error,
                ]);

                $this->updateLogs($taskLog);
            }
        }
    }

    /**
     * Spécifier les tâches à exécuter
     *
     * @param list<mixed> $tasks
     */
    public function only(array $tasks = []): self
    {
        $this->only = $tasks;

It seems like $tasks of type array is incompatible with the declared type BlitzPHP\Tasks\list of property $only.

        return $this;
    }

    /**
     * Définit une heure qui sera utilisée.
     * Permet de définir une heure spécifique par rapport à laquelle le test sera effectué.
     * Doit être dans un format compatible avec DateTime.
     */
    public function withTestTime(string $time): self
    {
        $this->testTime = $time;

        return $this;
    }

    /**
     * Ecrire une ligne dans l'interface de ligne de commande
     */
    protected function cliWrite(string $text, ?int $foreground = null): void
    {
        // Sauter l'écriture pour cli dans les tests
        if (on_test()) {
            return;
        }

        if (! is_cli()) {
            return;
        }

        if (static::$writter === null) {
            static::$writter = new Writer();
        }

        static::$writter->write(
            text: static::$writter->colorizer()->line('[' . date('Y-m-d H:i:s') . '] ' . $text, ['fg' => $foreground]),

The method colorizer() does not exist on null.

            eol: true,
        );
    }

    /**
     * Ajoute le journal des performances
     */
    protected function updateLogs(TaskLog $taskLog): void
    {
        if (parametre('tasks.log_performance') === false) {
            return;
        }

        // un nom « unique » sera renvoyé s'il n'a pas été défini
        $name = $taskLog->task->name;

        $data = [
            'task'     => $name,
            'type'     => $taskLog->task->getType(),
            'start'    => $taskLog->runStart->format('Y-m-d H:i:s'),
            'duration' => $taskLog->duration(),
            'output'   => $taskLog->output ?? null,
            'error'    => serialize($taskLog->error ?? null),
        ];

        // Obtenir les logs existants
        $logs = parametre("tasks.log-{$name}");
        if (empty($logs)) {
            $logs = [];
        }

        // Assurez-vous que nous avons de la place pour un de plus
        /** @var int $maxLogsPerTask */
        $maxLogsPerTask = parametre('tasks.max_logs_per_task');
        if ((is_countable($logs) ? count($logs) : 0) > $maxLogsPerTask) {

It seems like $logs can also be of type boolean and double and integer; however, parameter $value of count() does only seem to accept Countable|array, maybe add an additional type check?

            array_pop($logs);
        }

        // Add the log to the top of the array
        array_unshift($logs, $data);

        parametre("tasks.log-{$name}", $logs);
    }
}