AbstractTask.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Scheduler\Task;
 
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Scheduler\Domain\Repository\SchedulerTaskRepository;
use ‪TYPO3\CMS\Scheduler\Execution;
use ‪TYPO3\CMS\Scheduler\Scheduler;
 
abstract class ‪AbstractTask implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    public const ‪TYPE_SINGLE = 1;
    public const ‪TYPE_RECURRING = 2;
 
    protected ‪$scheduler;
 
    protected int ‪$taskUid = 0;
 
    protected ‪$disabled = false;
 
    protected ‪$runOnNextCronJob = false;
 
    protected ‪$execution;
 
    protected ‪$executionTime = 0;
 
    protected string ‪$description = '';
 
    protected ‪$taskGroup = 0;
 
    public function ‪__construct()
    {
        // Using makeInstance instead of setScheduler() here as the logger is injected due to LoggerAwareTrait
        $this->scheduler = GeneralUtility::makeInstance(Scheduler::class);
        $this->execution = GeneralUtility::makeInstance(Execution::class);
    }
 
    abstract public function ‪execute();
 
    public function ‪getAdditionalInformation()
    {
        return '';
    }
 
    public function ‪setTaskUid($id): void
    {
        $this->taskUid = (int)$id;
    }
 
    public function ‪getTaskUid(): int
    {
        return ‪$this->taskUid;
    }
 
    public function ‪getTaskTitle()
    {
        return $this->‪getLanguageService()->sL(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][static::class]['title'] ?? '');
    }
 
    public function ‪getTaskDescription()
    {
        return $this->‪getLanguageService()->sL(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][static::class]['description'] ?? '');
    }
 
    public function ‪getTaskClassName()
    {
        return static::class;
    }
 
    public function ‪isDisabled()
    {
        return ‪$this->disabled;
    }
 
    public function ‪setDisabled($flag)
    {
        if ($flag) {
            $this->disabled = true;
        } else {
            $this->disabled = false;
        }
    }
 
    public function ‪setRunOnNextCronJob($flag)
    {
        $this->runOnNextCronJob = $flag;
    }
 
    public function ‪getRunOnNextCronJob()
    {
        return ‪$this->runOnNextCronJob;
    }
 
    public function ‪setExecutionTime($timestamp)
    {
        $this->executionTime = (int)$timestamp;
    }
 
    public function ‪getTaskGroup()
    {
        return ‪$this->taskGroup;
    }
 
    public function ‪setTaskGroup(‪$taskGroup)
    {
        $this->taskGroup = (int)‪$taskGroup;
    }
 
    public function ‪getExecutionTime()
    {
        return ‪$this->executionTime;
    }
 
    public function ‪setDescription(‪$description): void
    {
        $this->‪description = (string)‪$description;
    }
 
    public function ‪getDescription()
    {
        return ‪$this->description;
    }
 
    public function ‪setScheduler()
    {
        $this->scheduler = GeneralUtility::makeInstance(Scheduler::class);
        $this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
    }
 
    public function ‪unsetScheduler()
    {
        $this->scheduler = null;
        unset($this->logger);
    }
 
    public function ‪registerSingleExecution($timestamp)
    {
        ‪$execution = GeneralUtility::makeInstance(Execution::class);
        ‪$execution->‪setStart($timestamp);
        ‪$execution->‪setInterval(0);
        ‪$execution->‪setEnd($timestamp);
        ‪$execution->‪setCronCmd('');
        ‪$execution->‪setMultiple(false);
        ‪$execution->‪setIsNewSingleExecution(true);
        // Replace existing execution object
        $this->execution = ‪$execution;
    }
 
    public function ‪registerRecurringExecution($start, $interval, $end = 0, $multiple = false, $cron_cmd = '')
    {
        ‪$execution = GeneralUtility::makeInstance(Execution::class);
        // Set general values
        ‪$execution->‪setStart($start);
        ‪$execution->‪setEnd($end);
        ‪$execution->‪setMultiple($multiple);
        if (empty($cron_cmd)) {
            // Use interval
            ‪$execution->‪setInterval($interval);
            ‪$execution->‪setCronCmd('');
        } else {
            // Use cron syntax
            ‪$execution->‪setInterval(0);
            ‪$execution->‪setCronCmd($cron_cmd);
        }
        // Replace existing execution object
        $this->execution = ‪$execution;
    }
 
    public function ‪setExecution(Execution ‪$execution)
    {
        $this->execution = ‪$execution;
    }
 
    public function ‪getExecution()
    {
        return ‪$this->execution;
    }
 
    public function ‪getNextDueExecution()
    {
        // NOTE: this call may throw an exception, but we let it bubble up
        return $this->execution->getNextExecution();
    }
 
    public function ‪areMultipleExecutionsAllowed()
    {
        return $this->execution->getMultiple();
    }
 
    public function ‪save()
    {
        return GeneralUtility::makeInstance(SchedulerTaskRepository::class)->update($this);
    }
 
    public function ‪stop()
    {
        $this->execution = GeneralUtility::makeInstance(Execution::class);
    }
 
    public function ‪getType()
    {
        if (!empty($this->‪getExecution()->getInterval()) || !empty($this->‪getExecution()->getCronCmd())) {
            return ‪self::TYPE_RECURRING;
        }
        return ‪self::TYPE_SINGLE;
    }
 
    protected function ‪logException(\‪Exception $e)
    {
        $this->logger->error('A Task Exception was captured.', ['exception' => $e]);
    }
 
    protected function ‪getLanguageService(): ?‪LanguageService
    {
        return ‪$GLOBALS['LANG'] ?? null;
    }
}