ActionController.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\Extbase\Mvc\Controller;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use ‪TYPO3\CMS\Core\Messaging\AbstractMessage;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\Event\Mvc\BeforeActionCallEvent;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\Exception\RequiredArgumentMissingException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchActionException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\StopActionException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\UnsupportedRequestTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\Request;
use ‪TYPO3\CMS\Extbase\Mvc\RequestInterface;
use ‪TYPO3\CMS\Extbase\Mvc\ResponseInterface;
use ‪TYPO3\CMS\Extbase\Mvc\View\GenericViewResolver;
use ‪TYPO3\CMS\Extbase\Mvc\View\NotFoundView;
use ‪TYPO3\CMS\Extbase\Mvc\View\ViewInterface;
use ‪TYPO3\CMS\Extbase\Mvc\View\ViewResolverInterface;
use ‪TYPO3\CMS\Extbase\Mvc\Web\ReferringRequest;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
use ‪TYPO3\CMS\Extbase\Security\Cryptography\HashService;
use ‪TYPO3\CMS\Extbase\Service\CacheService;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ConjunctionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
use ‪TYPO3\CMS\Extbase\Validation\ValidatorResolver;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use TYPO3Fluid\Fluid\View\TemplateView;
 
class ‪ActionController implements ‪ControllerInterface
{
    protected ‪$reflectionService;
 
    protected ‪$cacheService;
 
    protected ‪$hashService;
 
    private ‪$viewResolver;
 
    protected ‪$view;
 
    protected ‪$defaultViewObjectName = \TYPO3\CMS\Fluid\View\TemplateView::class;
 
    protected ‪$actionMethodName = 'indexAction';
 
    protected ‪$errorMethodName = 'errorAction';
 
    protected ‪$mvcPropertyMappingConfigurationService;
 
    protected ‪$eventDispatcher;
 
    protected ‪$request;
 
    protected ‪$response;
 
    protected ‪$signalSlotDispatcher;
 
    protected ‪$objectManager;
 
    protected ‪$uriBuilder;
 
    protected ‪$settings;
 
    protected ‪$validatorResolver;
 
    protected ‪$arguments;
 
    protected ‪$supportedRequestTypes = [Request::class];
 
    protected ‪$controllerContext;
 
    protected ‪$configurationManager;
 
    public function ‪injectConfigurationManager(‪ConfigurationManagerInterface ‪$configurationManager)
    {
        $this->configurationManager = ‪$configurationManager;
        $this->settings = $this->configurationManager->‪getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_SETTINGS);
    }
 
    public function ‪injectObjectManager(‪ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
        $this->arguments = $this->objectManager->‪get(Arguments::class);
    }
 
    public function ‪injectSignalSlotDispatcher(‪Dispatcher ‪$signalSlotDispatcher)
    {
        $this->signalSlotDispatcher = ‪$signalSlotDispatcher;
    }
 
    public function ‪injectValidatorResolver(‪ValidatorResolver ‪$validatorResolver)
    {
        $this->validatorResolver = ‪$validatorResolver;
    }
 
    public function ‪injectViewResolver(‪ViewResolverInterface ‪$viewResolver)
    {
        $this->viewResolver = ‪$viewResolver;
    }
 
    public function ‪injectReflectionService(‪ReflectionService ‪$reflectionService)
    {
        $this->reflectionService = ‪$reflectionService;
    }
 
    public function ‪injectCacheService(‪CacheService ‪$cacheService)
    {
        $this->cacheService = ‪$cacheService;
    }
 
    public function ‪injectHashService(‪HashService ‪$hashService)
    {
        $this->hashService = ‪$hashService;
    }
 
    public function ‪injectMvcPropertyMappingConfigurationService(MvcPropertyMappingConfigurationService ‪$mvcPropertyMappingConfigurationService)
    {
        $this->mvcPropertyMappingConfigurationService = ‪$mvcPropertyMappingConfigurationService;
    }
 
    public function ‪injectEventDispatcher(EventDispatcherInterface ‪$eventDispatcher): void
    {
        $this->eventDispatcher = ‪$eventDispatcher;
    }
 
    protected function ‪initializeView(‪ViewInterface ‪$view)
    {
    }
 
    protected function ‪initializeAction()
    {
    }
 
    protected function ‪initializeActionMethodArguments()
    {
        $methodParameters = $this->reflectionService
            ->getClassSchema(static::class)
            ->getMethod($this->actionMethodName)->getParameters();
 
        foreach ($methodParameters as $parameterName => $parameter) {
            $dataType = null;
            if ($parameter->getType() !== null) {
                $dataType = $parameter->getType();
            } elseif ($parameter->isArray()) {
                $dataType = 'array';
            }
            if ($dataType === null) {
                throw new InvalidArgumentTypeException('The argument type for parameter $' . $parameterName . ' of method ' . static::class . '->' . $this->actionMethodName . '() could not be detected.', 1253175643);
            }
            $defaultValue = $parameter->hasDefaultValue() ? $parameter->getDefaultValue() : null;
            $this->arguments->addNewArgument($parameterName, $dataType, !$parameter->isOptional(), $defaultValue);
        }
    }
 
    protected function ‪initializeActionMethodValidators()
    {
        if ($this->arguments->count() === 0) {
            return;
        }
 
        $classSchemaMethod = $this->reflectionService->getClassSchema(static::class)
            ->getMethod($this->actionMethodName);
 
        foreach ($this->arguments as $argument) {
            $classSchemaMethodParameter = $classSchemaMethod->getParameter($argument->getName());
            /*
             * At this point validation is skipped if there is an IgnoreValidation annotation.
             *
             * todo: IgnoreValidation annotations could be evaluated in the ClassSchema and result in
             * todo: no validators being applied to the method parameter.
             */
            if ($classSchemaMethodParameter->ignoreValidation()) {
                continue;
            }
 
            // todo: It's quite odd that an instance of ConjunctionValidator is created directly here.
            // todo: \TYPO3\CMS\Extbase\Validation\ValidatorResolver::getBaseValidatorConjunction could/should be used
            // todo: here, to benefit of the built in 1st level cache of the ValidatorResolver.
            ‪$validator = $this->objectManager->get(ConjunctionValidator::class);
 
            foreach ($classSchemaMethodParameter->getValidators() as $validatorDefinition) {
                $validatorInstance = $this->objectManager->get(
                    $validatorDefinition['className'],
                    $validatorDefinition['options']
                );
 
                ‪$validator->addValidator(
                    $validatorInstance
                );
            }
 
            $baseValidatorConjunction = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
            if ($baseValidatorConjunction->count() > 0) {
                ‪$validator->addValidator($baseValidatorConjunction);
            }
            $argument->setValidator(‪$validator);
        }
    }
 
    public function ‪initializeControllerArgumentsBaseValidators()
    {
        foreach ($this->arguments as $argument) {
            ‪$validator = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
            if (‪$validator !== null) {
                $argument->setValidator(‪$validator);
            }
        }
    }
 
    public function ‪processRequest(RequestInterface ‪$request, ResponseInterface ‪$response)
    {
        if (!$this->‪canProcessRequest($request)) {
            throw new UnsupportedRequestTypeException(static::class . ' does not support requests of type "' . get_class(‪$request) . '". Supported types are: ' . implode(' ', $this->supportedRequestTypes), 1187701131);
        }
 
        $setRequestCallable = [‪$response, 'setRequest'];
        if (is_callable($setRequestCallable)) {
            $setRequestCallable(‪$request);
        }
        $this->request = ‪$request;
        $this->request->‪setDispatched(true);
        $this->response = ‪$response;
        $this->uriBuilder = $this->objectManager->get(UriBuilder::class);
        $this->uriBuilder->‪setRequest(‪$request);
        $this->actionMethodName = $this->‪resolveActionMethodName();
        $this->‪initializeActionMethodArguments();
        $this->‪initializeActionMethodValidators();
        $this->mvcPropertyMappingConfigurationService->initializePropertyMappingConfigurationFromRequest(‪$request, $this->arguments);
        $this->‪initializeAction();
        $actionInitializationMethodName = 'initialize' . ucfirst($this->actionMethodName);
        $callable = [$this, $actionInitializationMethodName];
        if (method_exists($this, $actionInitializationMethodName)) {
            // todo: replace method_exists with is_callable or even both
            //       method_exists alone does not guarantee that $callable is actually callable
            call_user_func($callable);
        }
        $this->‪mapRequestArgumentsToControllerArguments();
        $this->controllerContext = $this->‪buildControllerContext();
        $this->view = $this->‪resolveView();
        if ($this->view !== null) {
            $this->‪initializeView($this->view);
        }
        $this->‪callActionMethod();
        $this->‪renderAssetsForRequest($request);
    }
 
    protected function ‪renderAssetsForRequest(‪$request)
    {
        if (!$this->view instanceof TemplateView) {
            // Only TemplateView (from Fluid engine, so this includes all TYPO3 Views based
            // on TYPO3's AbstractTemplateView) supports renderSection(). The method is not
            // declared on ViewInterface - so we must assert a specific class. We silently skip
            // asset processing if the View doesn't match, so we don't risk breaking custom Views.
            return;
        }
        $pageRenderer = GeneralUtility::makeInstance(PageRenderer::class);
        $variables = ['request' => ‪$request, 'arguments' => ‪$this->arguments];
        $headerAssets = $this->view->renderSection('HeaderAssets', $variables, true);
        $footerAssets = $this->view->renderSection('FooterAssets', $variables, true);
        if (!empty(trim($headerAssets))) {
            $pageRenderer->addHeaderData($headerAssets);
        }
        if (!empty(trim($footerAssets))) {
            $pageRenderer->addFooterData($footerAssets);
        }
    }
 
    protected function ‪resolveActionMethodName()
    {
        ‪$actionMethodName = $this->request->getControllerActionName() . 'Action';
        if (!method_exists($this, ‪$actionMethodName)) {
            throw new NoSuchActionException('An action "' . ‪$actionMethodName . '" does not exist in controller "' . static::class . '".', 1186669086);
        }
        return ‪$actionMethodName;
    }
 
    protected function ‪callActionMethod()
    {
        $preparedArguments = [];
        foreach ($this->arguments as $argument) {
            $preparedArguments[] = $argument->getValue();
        }
        $validationResult = $this->arguments->validate();
        if (!$validationResult->hasErrors()) {
            $this->eventDispatcher->dispatch(new ‪BeforeActionCallEvent(static::class, $this->actionMethodName, $preparedArguments));
            $actionResult = $this->{$this->actionMethodName}(...$preparedArguments);
        } else {
            $actionResult = $this->{$this->errorMethodName}();
        }
 
        if ($actionResult === null && $this->view instanceof ViewInterface) {
            $this->response->appendContent($this->view->render());
        } elseif (is_string($actionResult) && $actionResult !== '') {
            $this->response->appendContent($actionResult);
        } elseif (is_object($actionResult) && method_exists($actionResult, '__toString')) {
            $this->response->appendContent((string)$actionResult);
        }
    }
 
    protected function ‪emitBeforeCallActionMethodSignal(array $preparedArguments)
    {
        trigger_error(
            __METHOD__ . ' is deprecated and will be removed in version 11.0 - use PSR-14 events instead.',
            E_USER_DEPRECATED
        );
        $this->signalSlotDispatcher->dispatch(__CLASS__, 'beforeCallActionMethod', [static::class, $this->actionMethodName, $preparedArguments]);
    }
 
    protected function ‪resolveView()
    {
        if ($this->viewResolver instanceof ‪GenericViewResolver) {
            /*
             * This setter is not part of the ViewResolverInterface as it's only necessary to set
             * the default view class from this point when using the generic view resolver which
             * must respect the possibly overridden property defaultViewObjectName.
             */
            $this->viewResolver->setDefaultViewClass($this->defaultViewObjectName);
        }
 
        ‪$view = $this->viewResolver->resolve(
            $this->request->getControllerObjectName(),
            $this->request->getControllerActionName(),
            $this->request->getFormat()
        );
 
        if (‪$view instanceof ViewInterface) {
            $this->‪setViewConfiguration(‪$view);
            if (‪$view->‪canRender($this->controllerContext) === false) {
                ‪$view = null;
            }
        }
        if (!isset(‪$view)) {
            ‪$view = $this->objectManager->get(NotFoundView::class);
            ‪$view->‪assign('errorMessage', 'No template was found. View could not be resolved for action "'
                . $this->request->getControllerActionName() . '" in class "' . $this->request->getControllerObjectName() . '"');
        }
        ‪$view->‪setControllerContext($this->controllerContext);
        if (method_exists(‪$view, 'injectSettings')) {
            ‪$view->injectSettings($this->settings);
        }
        ‪$view->‪initializeView();
        // In TYPO3.Flow, solved through Object Lifecycle methods, we need to call it explicitly
        ‪$view->‪assign('settings', $this->settings);
        // same with settings injection.
        return ‪$view;
    }
 
    protected function ‪setViewConfiguration(ViewInterface ‪$view)
    {
        // Template Path Override
        $extbaseFrameworkConfiguration = $this->configurationManager->getConfiguration(
            ‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK
        );
 
        // set TemplateRootPaths
        $viewFunctionName = 'setTemplateRootPaths';
        if (method_exists(‪$view, $viewFunctionName)) {
            $setting = 'templateRootPaths';
            $parameter = $this->‪getViewProperty($extbaseFrameworkConfiguration, $setting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                ‪$view->$viewFunctionName($parameter);
            }
        }
 
        // set LayoutRootPaths
        $viewFunctionName = 'setLayoutRootPaths';
        if (method_exists(‪$view, $viewFunctionName)) {
            $setting = 'layoutRootPaths';
            $parameter = $this->‪getViewProperty($extbaseFrameworkConfiguration, $setting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                ‪$view->$viewFunctionName($parameter);
            }
        }
 
        // set PartialRootPaths
        $viewFunctionName = 'setPartialRootPaths';
        if (method_exists(‪$view, $viewFunctionName)) {
            $setting = 'partialRootPaths';
            $parameter = $this->‪getViewProperty($extbaseFrameworkConfiguration, $setting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                ‪$view->$viewFunctionName($parameter);
            }
        }
    }
 
    protected function ‪getViewProperty($extbaseFrameworkConfiguration, $setting)
    {
        $values = [];
        if (
            !empty($extbaseFrameworkConfiguration['view'][$setting])
            && is_array($extbaseFrameworkConfiguration['view'][$setting])
        ) {
            $values = $extbaseFrameworkConfiguration['view'][$setting];
        }
 
        return $values;
    }
 
    protected function ‪errorAction()
    {
        $this->‪clearCacheOnError();
        $this->‪addErrorFlashMessage();
        $this->‪forwardToReferringRequest();
 
        return $this->‪getFlattenedValidationErrorMessage();
    }
 
    protected function ‪clearCacheOnError()
    {
        $extbaseSettings = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (isset($extbaseSettings['persistence']['enableAutomaticCacheClearing']) && $extbaseSettings['persistence']['enableAutomaticCacheClearing'] === '1') {
            if (isset(‪$GLOBALS['TSFE'])) {
                $pageUid = ‪$GLOBALS['TSFE']->id;
                $this->cacheService->clearPageCache([$pageUid]);
            }
        }
    }
 
    protected function ‪addErrorFlashMessage()
    {
        $errorFlashMessage = $this->‪getErrorFlashMessage();
        if ($errorFlashMessage !== false) {
            $this->‪addFlashMessage($errorFlashMessage, '', ‪FlashMessage::ERROR);
        }
    }
 
    protected function ‪getErrorFlashMessage()
    {
        return 'An error occurred while trying to call ' . static::class . '->' . $this->actionMethodName . '()';
    }
 
    protected function ‪forwardToReferringRequest()
    {
        $referringRequest = null;
        $referringRequestArguments = $this->request->getInternalArguments()['__referrer'] ?? null;
        if (is_string($referringRequestArguments['@request'] ?? null)) {
            $referrerArray = json_decode(
                $this->hashService->validateAndStripHmac($referringRequestArguments['@request']),
                true
            );
            ‪$arguments = [];
            if (is_string($referringRequestArguments['arguments'] ?? null)) {
                ‪$arguments = unserialize(
                    base64_decode($this->hashService->validateAndStripHmac($referringRequestArguments['arguments']))
                );
            }
            $referringRequest = new ReferringRequest();
            $referringRequest->setArguments(array_replace_recursive(‪$arguments, $referrerArray));
        }
 
        if ($referringRequest !== null) {
            $originalRequest = clone ‪$this->request;
            $this->request->‪setOriginalRequest($originalRequest);
            $this->request->setOriginalRequestMappingResults($this->arguments->validate());
            $this->‪forward(
                $referringRequest->getControllerActionName(),
                $referringRequest->getControllerName(),
                $referringRequest->getControllerExtensionName(),
                $referringRequest->getArguments()
            );
        }
    }
 
    protected function ‪getFlattenedValidationErrorMessage()
    {
        $outputMessage = 'Validation failed while trying to call ' . static::class . '->' . $this->actionMethodName . '().' . PHP_EOL;
        return $outputMessage;
    }
 
    public function ‪getControllerContext()
    {
        return ‪$this->controllerContext;
    }
 
    public function ‪addFlashMessage($messageBody, $messageTitle = '', $severity = ‪AbstractMessage::OK, $storeInSession = true)
    {
        if (!is_string($messageBody)) {
            throw new \InvalidArgumentException('The message body must be of type string, "' . gettype($messageBody) . '" given.', 1243258395);
        }
        /* @var \TYPO3\CMS\Core\Messaging\FlashMessage $flashMessage */
        $flashMessage = GeneralUtility::makeInstance(
            FlashMessage::class,
            (string)$messageBody,
            (string)$messageTitle,
            $severity,
            $storeInSession
        );
        $this->controllerContext->getFlashMessageQueue()->enqueue($flashMessage);
    }
 
    public function ‪canProcessRequest(‪RequestInterface ‪$request)
    {
        foreach ($this->supportedRequestTypes as $supportedRequestType) {
            if (‪$request instanceof $supportedRequestType) {
                return true;
            }
        }
        return false;
    }
 
    protected function ‪buildControllerContext()
    {
        ‪$controllerContext = $this->objectManager->get(ControllerContext::class);
        ‪$controllerContext->‪setRequest($this->request);
        ‪$controllerContext->‪setResponse($this->response);
        if ($this->arguments !== null) {
            ‪$controllerContext->‪setArguments($this->arguments);
        }
        ‪$controllerContext->‪setUriBuilder($this->uriBuilder);
 
        return ‪$controllerContext;
    }
 
    public function ‪forward($actionName, $controllerName = null, $extensionName = null, array ‪$arguments = null)
    {
        $this->request->setDispatched(false);
        $this->request->setControllerActionName($actionName);
 
        if ($controllerName !== null) {
            $this->request->setControllerName($controllerName);
        }
 
        if ($extensionName !== null) {
            $this->request->setControllerExtensionName($extensionName);
        }
 
        if (‪$arguments !== null) {
            $this->request->setArguments(‪$arguments);
        }
        throw new ‪StopActionException('forward', 1476045801);
    }
 
    protected function ‪redirect($actionName, $controllerName = null, $extensionName = null, array ‪$arguments = null, $pageUid = null, $delay = 0, $statusCode = 303)
    {
        if ($controllerName === null) {
            $controllerName = $this->request->getControllerName();
        }
        $this->uriBuilder->reset()->setCreateAbsoluteUri(true);
        if (‪MathUtility::canBeInterpretedAsInteger($pageUid)) {
            $this->uriBuilder->setTargetPageUid((int)$pageUid);
        }
        if (GeneralUtility::getIndpEnv('TYPO3_SSL')) {
            $this->uriBuilder->setAbsoluteUriScheme('https');
        }
        $uri = $this->uriBuilder->uriFor($actionName, ‪$arguments, $controllerName, $extensionName);
        $this->‪redirectToUri($uri, $delay, $statusCode);
    }
 
    protected function ‪redirectToUri($uri, $delay = 0, $statusCode = 303)
    {
        $this->objectManager->get(CacheService::class)->clearCachesOfRegisteredPageIds();
 
        $uri = $this->‪addBaseUriIfNecessary($uri);
        $escapedUri = htmlentities($uri, ENT_QUOTES, 'utf-8');
        $this->response->setContent('<html><head><meta http-equiv="refresh" content="' . (int)$delay . ';url=' . $escapedUri . '"/></head></html>');
        $this->response->setStatus($statusCode);
        $this->response->setHeader('Location', (string)$uri);
 
        // Avoid caching the plugin when we issue a redirect response
        // This means that even when an action is configured as cachable
        // we avoid the plugin to be cached, but keep the page cache untouched
        $contentObject = $this->configurationManager->getContentObject();
        if ($contentObject->getUserObjectType() === ‪ContentObjectRenderer::OBJECTTYPE_USER) {
            $contentObject->convertToUserIntObject();
        }
 
        throw new ‪StopActionException('redirectToUri', 1476045828);
    }
 
    protected function ‪addBaseUriIfNecessary($uri)
    {
        return GeneralUtility::locationHeaderUrl((string)$uri);
    }
 
    public function ‪throwStatus($statusCode, $statusMessage = null, $content = null)
    {
        $this->response->setStatus($statusCode, $statusMessage);
        if ($content === null) {
            $content = $this->response->getStatus();
        }
        $this->response->setContent($content);
        throw new StopActionException('throwStatus', 1476045871);
    }
 
    protected function ‪mapRequestArgumentsToControllerArguments()
    {
        foreach ($this->arguments as $argument) {
            $argumentName = $argument->getName();
            if ($this->request->hasArgument($argumentName)) {
                $argument->setValue($this->request->getArgument($argumentName));
            } elseif ($argument->isRequired()) {
                throw new RequiredArgumentMissingException('Required argument "' . $argumentName . '" is not set for ' . $this->request->getControllerObjectName() . '->' . $this->request->getControllerActionName() . '.', 1298012500);
            }
        }
    }
}