CommandController.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Extbase\Mvc\Controller;
 
/*
 * 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!
 */
 
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition;
use ‪TYPO3\CMS\Extbase\Mvc\Cli\ConsoleOutput;
use ‪TYPO3\CMS\Extbase\Mvc\Cli\Request;
use ‪TYPO3\CMS\Extbase\Mvc\Cli\Response;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchCommandException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\StopActionException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\UnsupportedRequestTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\RequestInterface;
use ‪TYPO3\CMS\Extbase\Mvc\ResponseInterface;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
 
class ‪CommandController implements ‪CommandControllerInterface
{
    protected ‪$request;
 
    protected ‪$response;
 
    protected ‪$arguments;
 
    protected ‪$commandMethodName = '';
 
    protected ‪$requestAdminPermissions = false;
 
    protected ‪$reflectionService;
 
    protected ‪$objectManager;
 
    protected ‪$output;
 
    public function ‪__construct()
    {
        trigger_error('Extbase Command Controllers will be removed in TYPO3 v10.0. Migrate to symfony/console commands instead.', E_USER_DEPRECATED);
    }
 
    public function ‪injectObjectManager(‪ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
    }
 
    public function ‪injectReflectionService(‪ReflectionService ‪$reflectionService)
    {
        $this->reflectionService = ‪$reflectionService;
    }
 
    public function ‪canProcessRequest(\‪TYPO3\CMS\‪Extbase\Mvc\‪RequestInterface ‪$request)
    {
        return ‪$request instanceof ‪Request;
    }
 
    public function ‪processRequest(‪RequestInterface ‪$request, ‪ResponseInterface ‪$response)
    {
        if (!$this->‪canProcessRequest($request)) {
            throw new ‪UnsupportedRequestTypeException(sprintf('%s only supports command line requests – requests of type "%s" given.', static::class, get_class(‪$request)), 1300787096);
        }
 
        $this->request = ‪$request;
        $this->request->‪setDispatched(true);
        $this->response = ‪$response;
 
        $this->commandMethodName = $this->‪resolveCommandMethodName();
        $this->‪output = $this->objectManager->get(ConsoleOutput::class);
        $this->arguments = $this->objectManager->get(Arguments::class);
        $this->‪initializeCommandMethodArguments();
        $this->‪mapRequestArgumentsToControllerArguments();
        $this->‪initializeBackendAuthentication();
        $this->‪callCommandMethod();
    }
 
    protected function ‪resolveCommandMethodName()
    {
        ‪$commandMethodName = $this->request->getControllerCommandName() . 'Command';
        if (!is_callable([$this, ‪$commandMethodName])) {
            throw new ‪NoSuchCommandException(sprintf('A command method "%s()" does not exist in controller "%s".', ‪$commandMethodName, static::class), 1300902143);
        }
        return ‪$commandMethodName;
    }
 
    protected function ‪initializeCommandMethodArguments()
    {
        $methodParameters = $this->reflectionService
            ->getClassSchema(static::class)
            ->getMethod($this->commandMethodName)['params'] ?? [];
 
        foreach ($methodParameters as $parameterName => $parameterInfo) {
            $dataType = null;
            if (isset($parameterInfo['type'])) {
                $dataType = $parameterInfo['type'];
            } elseif ($parameterInfo['array']) {
                $dataType = 'array';
            }
            if ($dataType === null) {
                throw new ‪InvalidArgumentTypeException(sprintf('The argument type for parameter $%s of method %s->%s() could not be detected.', $parameterName, static::class, $this->commandMethodName), 1306755296);
            }
            $defaultValue = ($parameterInfo['defaultValue'] ?? null);
            $this->arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === false, $defaultValue);
        }
    }
 
    protected function ‪mapRequestArgumentsToControllerArguments()
    {
        foreach ($this->arguments as $argument) {
            $argumentName = $argument->getName();
            if ($this->request->hasArgument($argumentName)) {
                $argument->setValue($this->request->getArgument($argumentName));
                continue;
            }
            if (!$argument->isRequired()) {
                continue;
            }
            $argumentValue = null;
            $commandArgumentDefinition = $this->objectManager->get(CommandArgumentDefinition::class, $argumentName, true, null);
            while ($argumentValue === null) {
                $argumentValue = $this->‪output->ask(sprintf('<comment>Please specify the required argument "%s":</comment> ', $commandArgumentDefinition->getDashedName()));
            }
            $argument->setValue($argumentValue);
        }
    }
 
    protected function ‪initializeBackendAuthentication()
    {
        $backendUserAuthentication = $this->‪getBackendUserAuthentication();
        if ($backendUserAuthentication !== null) {
            $backendUserAuthentication->backendCheckLogin();
        }
    }
 
    protected function ‪forward($commandName, $controllerObjectName = null, array ‪$arguments = [])
    {
        $this->request->setDispatched(false);
        $this->request->setControllerCommandName($commandName);
        if ($controllerObjectName !== null) {
            $this->request->setControllerObjectName($controllerObjectName);
        }
        $this->request->setArguments(‪$arguments);
 
        $this->arguments->removeAll();
        throw new StopActionException('forward', 1476107661);
    }
 
    protected function ‪callCommandMethod()
    {
        $preparedArguments = [];
        foreach ($this->arguments as $argument) {
            $preparedArguments[] = $argument->getValue();
        }
        $commandResult = call_user_func_array([$this, $this->commandMethodName], $preparedArguments);
        if (is_string($commandResult) && $commandResult !== '') {
            $this->response->appendContent($commandResult);
        } elseif (is_object($commandResult) && method_exists($commandResult, '__toString')) {
            $this->response->appendContent((string)$commandResult);
        }
    }
 
    protected function ‪output($text, array ‪$arguments = [])
    {
        $this->‪output->output($text, ‪$arguments);
    }
 
    protected function ‪outputLine($text = '', array ‪$arguments = [])
    {
        $this->‪output->outputLine($text, ‪$arguments);
    }
 
    protected function ‪outputFormatted($text = '', array ‪$arguments = [], $leftPadding = 0)
    {
        $this->‪output->outputFormatted($text, ‪$arguments, $leftPadding);
    }
 
    protected function ‪quit($exitCode = 0)
    {
        $this->response->setExitCode($exitCode);
        throw new ‪StopActionException('quit', 1476107681);
    }
 
    protected function ‪sendAndExit($exitCode = 0)
    {
        $this->response->send();
        exit($exitCode);
    }
 
    protected function ‪getBackendUserAuthentication()
    {
        return ‪$GLOBALS['BE_USER'] ?? null;
    }
}