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 Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UriInterface;
use ‪TYPO3\CMS\Core\Crypto\HashService;
use ‪TYPO3\CMS\Core\Http\PropagateResponseException;
use ‪TYPO3\CMS\Core\Http\RedirectResponse;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Messaging\FlashMessageQueue;
use ‪TYPO3\CMS\Core\Messaging\FlashMessageService;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Type\ContextualFeedbackSeverity;
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\Http\ForwardResponse;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\Exception\RequiredArgumentMissingException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentNameException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchActionException;
use ‪TYPO3\CMS\Extbase\Mvc\ExtbaseRequestParameters;
use ‪TYPO3\CMS\Extbase\Mvc\Request;
use ‪TYPO3\CMS\Extbase\Mvc\RequestInterface;
use ‪TYPO3\CMS\Extbase\Mvc\View\GenericViewResolver;
use ‪TYPO3\CMS\Extbase\Mvc\View\ViewResolverInterface;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use ‪TYPO3\CMS\Extbase\Property\Exception\TargetNotFoundException;
use ‪TYPO3\CMS\Extbase\Property\PropertyMapper;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
use ‪TYPO3\CMS\Extbase\Security\HashScope;
use ‪TYPO3\CMS\Extbase\Service\ExtensionService;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ConjunctionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
use ‪TYPO3\CMS\Extbase\Validation\ValidatorResolver;
use ‪TYPO3\CMS\Fluid\Core\Rendering\RenderingContext;
use ‪TYPO3\CMS\Fluid\View\TemplateView;
use TYPO3Fluid\Fluid\View\AbstractTemplateView;
use TYPO3Fluid\Fluid\View\ViewInterface;
 
abstract class ‪ActionController implements ‪ControllerInterface
{
    protected ResponseFactoryInterface ‪$responseFactory;
    protected StreamFactoryInterface ‪$streamFactory;
    protected ‪HashService ‪$hashService;
 
    protected ‪ReflectionService ‪$reflectionService;
 
    private ‪ViewResolverInterface ‪$viewResolver;
 
    protected ‪$view;
 
    protected string ‪$defaultViewObjectName = TemplateView::class;
 
    protected string ‪$actionMethodName = 'indexAction';
 
    protected string ‪$errorMethodName = 'errorAction';
 
    protected ‪MvcPropertyMappingConfigurationService ‪$mvcPropertyMappingConfigurationService;
    protected EventDispatcherInterface ‪$eventDispatcher;
    protected ‪RequestInterface ‪$request;
    protected ‪UriBuilder ‪$uriBuilder;
 
    protected array ‪$settings;
 
    protected ‪ValidatorResolver ‪$validatorResolver;
 
    protected ‪Arguments ‪$arguments;
 
    protected ‪ConfigurationManagerInterface ‪$configurationManager;
 
    private ‪PropertyMapper ‪$propertyMapper;
 
    private ‪FlashMessageService ‪$internalFlashMessageService;
 
    private ‪ExtensionService ‪$internalExtensionService;
 
    final public function ‪injectResponseFactory(ResponseFactoryInterface ‪$responseFactory): void
    {
        $this->responseFactory = ‪$responseFactory;
    }
 
    final public function ‪injectStreamFactory(StreamFactoryInterface ‪$streamFactory): void
    {
        $this->streamFactory = ‪$streamFactory;
    }
 
    public function ‪injectConfigurationManager(‪ConfigurationManagerInterface ‪$configurationManager): void
    {
        $this->configurationManager = ‪$configurationManager;
        $this->settings = $this->configurationManager->‪getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_SETTINGS);
        $this->arguments = GeneralUtility::makeInstance(Arguments::class);
    }
 
    public function ‪injectValidatorResolver(ValidatorResolver ‪$validatorResolver): void
    {
        $this->validatorResolver = ‪$validatorResolver;
    }
 
    public function ‪injectViewResolver(ViewResolverInterface ‪$viewResolver): void
    {
        $this->viewResolver = ‪$viewResolver;
    }
 
    public function ‪injectReflectionService(ReflectionService ‪$reflectionService): void
    {
        $this->reflectionService = ‪$reflectionService;
    }
 
    public function ‪injectHashService(HashService ‪$hashService): void
    {
        $this->hashService = ‪$hashService;
    }
 
    public function ‪injectMvcPropertyMappingConfigurationService(‪MvcPropertyMappingConfigurationService ‪$mvcPropertyMappingConfigurationService): void
    {
        $this->mvcPropertyMappingConfigurationService = ‪$mvcPropertyMappingConfigurationService;
    }
 
    public function ‪injectEventDispatcher(EventDispatcherInterface ‪$eventDispatcher): void
    {
        $this->eventDispatcher = ‪$eventDispatcher;
    }
 
    public function ‪injectPropertyMapper(‪PropertyMapper ‪$propertyMapper): void
    {
        $this->propertyMapper = ‪$propertyMapper;
    }
 
    final public function ‪injectInternalFlashMessageService(FlashMessageService $flashMessageService): void
    {
        $this->internalFlashMessageService = $flashMessageService;
    }
 
    final public function ‪injectInternalExtensionService(ExtensionService $extensionService): void
    {
        $this->internalExtensionService = $extensionService;
    }
 
    protected function ‪initializeAction(): void {}
 
    protected function ‪initializeActionMethodArguments(): void
    {
        $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(): void
    {
        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
            //        no validators being applied to the method parameter.
            if ($classSchemaMethodParameter->ignoreValidation()) {
                continue;
            }
            ‪$validator = $this->validatorResolver->createValidator(ConjunctionValidator::class, []);
            foreach ($classSchemaMethodParameter->getValidators() as $validatorDefinition) {
                $validatorInstance = $this->validatorResolver->createValidator($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(): void
    {
        foreach ($this->arguments as $argument) {
            ‪$validator = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
            if (‪$validator !== null) {
                $argument->setValidator(‪$validator);
            }
        }
    }
 
    public function ‪processRequest(RequestInterface ‪$request): ResponseInterface
    {
        $this->request = ‪$request;
        $this->uriBuilder = GeneralUtility::makeInstance(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 (is_callable($callable)) {
            $callable();
        }
        $this->‪mapRequestArgumentsToControllerArguments();
        $this->view = $this->‪resolveView();
        if ($this->view !== null && method_exists($this, 'initializeView')) {
            $this->initializeView($this->view);
        }
        $response = $this->‪callActionMethod($request);
        $this->‪renderAssetsForRequest($request);
 
        return $response;
    }
 
    protected function ‪renderAssetsForRequest(RequestInterface ‪$request): void
    {
        if (!$this->view instanceof AbstractTemplateView) {
            // Only AbstractTemplateView (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(): string
    {
        ‪$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(RequestInterface ‪$request): ResponseInterface
    {
        // incoming request is not needed yet but can be passed into the action in the future like in symfony
        // todo: support this via method-reflection
 
        $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 instanceof ResponseInterface) {
            return $actionResult;
        }
        throw new \RuntimeException(
            sprintf(
                'Controller action %s did not return an instance of %s.',
                static::class . '::' . $this->actionMethodName,
                ResponseInterface::class
            ),
            1638554283
        );
    }
 
    protected function ‪resolveView(): ViewInterface
    {
        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()
        );
        $this->‪setViewConfiguration(‪$view);
        if (‪$view instanceof AbstractTemplateView) {
            $renderingContext = ‪$view->getRenderingContext();
            if ($renderingContext instanceof RenderingContext) {
                $renderingContext->setRequest($this->request);
            }
            $templatePaths = ‪$view->getRenderingContext()->getTemplatePaths();
            $templatePaths->fillDefaultsByPackageName($this->request->getControllerExtensionKey());
            $templatePaths->setFormat($this->request->getFormat());
        }
        if (method_exists(‪$view, 'injectSettings')) {
            ‪$view->injectSettings($this->settings);
        }
        ‪$view->assign('settings', $this->settings);
        return ‪$view;
    }
 
    protected function ‪setViewConfiguration(ViewInterface ‪$view): void
    {
        $configuration = $this->configurationManager->getConfiguration(
            ‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK
        );
        if (!empty($configuration['view']['templateRootPaths'])
            && is_array($configuration['view']['templateRootPaths'])
            && method_exists(‪$view, 'setTemplateRootPaths')
        ) {
            ‪$view->setTemplateRootPaths($configuration['view']['templateRootPaths']);
        }
        if (!empty($configuration['view']['layoutRootPaths'])
            && is_array($configuration['view']['layoutRootPaths'])
            && method_exists(‪$view, 'setLayoutRootPaths')
        ) {
            ‪$view->setLayoutRootPaths($configuration['view']['layoutRootPaths']);
        }
        if (!empty($configuration['view']['partialRootPaths'])
            && is_array($configuration['view']['partialRootPaths'])
            && method_exists(‪$view, 'setPartialRootPaths')
        ) {
            ‪$view->setPartialRootPaths($configuration['view']['partialRootPaths']);
        }
    }
 
    protected function ‪errorAction(): ResponseInterface
    {
        $this->‪addErrorFlashMessage();
        if (($response = $this->‪forwardToReferringRequest()) !== null) {
            return $response->withStatus(400);
        }
 
        $response = $this->‪htmlResponse($this->‪getFlattenedValidationErrorMessage());
        return $response->withStatus(400);
    }
 
    protected function ‪addErrorFlashMessage(): void
    {
        $errorFlashMessage = $this->‪getErrorFlashMessage();
        if ($errorFlashMessage !== false) {
            $this->‪addFlashMessage($errorFlashMessage, '', ContextualFeedbackSeverity::ERROR);
        }
    }
 
    protected function ‪getErrorFlashMessage(): bool|string
    {
        return 'An error occurred while trying to call ' . static::class . '->' . $this->actionMethodName . '()';
    }
 
    protected function ‪forwardToReferringRequest(): ?ResponseInterface
    {
        $extbaseRequestParameters = $this->request->getAttribute('extbase');
        $referringRequestArguments = $extbaseRequestParameters->getInternalArgument('__referrer') ?? null;
        if (is_string($referringRequestArguments['@request'] ?? null)) {
            $referrerArray = json_decode(
                $this->hashService->validateAndStripHmac($referringRequestArguments['@request'], HashScope::ReferringRequest->prefix()),
                true
            );
            ‪$arguments = [];
            if (is_string($referringRequestArguments['arguments'] ?? null)) {
                ‪$arguments = unserialize(
                    base64_decode($this->hashService->validateAndStripHmac($referringRequestArguments['arguments'], HashScope::ReferringArguments->prefix()))
                );
            }
            $replacedArguments = array_replace_recursive(‪$arguments, $referrerArray);
            $nonExtbaseBaseArguments = [];
            foreach ($replacedArguments as $argumentName => $argumentValue) {
                if (!is_string($argumentName) || $argumentName === '') {
                    throw new InvalidArgumentNameException('Invalid argument name.', 1623940985);
                }
                if (str_starts_with($argumentName, '__')
                    || in_array($argumentName, ['@extension', '@subpackage', '@controller', '@action', '@format'], true)
                ) {
                    // Don't handle internalArguments here, not needed for forwardResponse()
                    continue;
                }
                $nonExtbaseBaseArguments[$argumentName] = $argumentValue;
            }
            return (new ForwardResponse((string)($replacedArguments['@action'] ?? 'index')))
                ->withControllerName((string)($replacedArguments['@controller'] ?? 'Standard'))
                ->withExtensionName((string)($replacedArguments['@extension'] ?? ''))
                ->withArguments($nonExtbaseBaseArguments)
                ->withArgumentsValidationResult($this->arguments->validate());
        }
 
        return null;
    }
 
    protected function ‪getFlattenedValidationErrorMessage(): string
    {
        return 'Validation failed while trying to call ' . static::class . '->' . $this->actionMethodName . '().' . PHP_EOL;
    }
 
    public function ‪addFlashMessage(
        string $messageBody,
        string $messageTitle = '',
        ‪ContextualFeedbackSeverity $severity = ContextualFeedbackSeverity::OK,
        bool $storeInSession = true
    ): void {
        /* @var FlashMessage $flashMessage */
        $flashMessage = GeneralUtility::makeInstance(
            FlashMessage::class,
            $messageBody,
            $messageTitle,
            $severity,
            $storeInSession
        );
 
        $this->‪getFlashMessageQueue()->enqueue($flashMessage);
    }
 
    protected function ‪getFlashMessageQueue(string ‪$identifier = null): FlashMessageQueue
    {
        if (‪$identifier === null) {
            $pluginNamespace = $this->internalExtensionService->getPluginNamespace(
                $this->request->getControllerExtensionName(),
                $this->request->getPluginName()
            );
            ‪$identifier = 'extbase.flashmessages.' . $pluginNamespace;
        }
 
        return $this->internalFlashMessageService->getMessageQueueByIdentifier(‪$identifier);
    }
 
    protected function ‪redirect(
        ?string $actionName,
        ?string $controllerName = null,
        ?string $extensionName = null,
        ?array ‪$arguments = null,
        ?int $pageUid = null,
        $_ = null,
        int ‪$statusCode = 303
    ): ResponseInterface {
        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);
        return $this->‪redirectToUri($uri, null, ‪$statusCode);
    }
 
    protected function ‪redirectToUri(string|UriInterface $uri, $_ = null, int ‪$statusCode = 303): ResponseInterface
    {
        $uri = $this->‪addBaseUriIfNecessary((string)$uri);
        return new RedirectResponse($uri, ‪$statusCode);
    }
 
    protected function ‪addBaseUriIfNecessary(string $uri): string
    {
        return GeneralUtility::locationHeaderUrl($uri);
    }
 
    public function ‪throwStatus(int ‪$statusCode, string $statusMessage = '', ?string $content = null): never
    {
        if ($content === null) {
            $content = ‪$statusCode . ' ' . $statusMessage;
        }
        $response = $this->responseFactory
            ->createResponse(‪$statusCode, $statusMessage)
            ->withBody($this->streamFactory->createStream((string)$content));
        throw new PropagateResponseException($response, 1476045871);
    }
 
    protected function ‪mapRequestArgumentsToControllerArguments(): void
    {
        foreach ($this->arguments as $argument) {
            $argumentName = $argument->getName();
            if ($this->request->hasArgument($argumentName)) {
                $this->‪setArgumentValue($argument, $this->request->getArgument($argumentName));
            } elseif ($argument->isRequired()) {
                throw new RequiredArgumentMissingException('Required argument "' . $argumentName . '" is not set for ' . $this->request->getControllerObjectName() . '->' . $this->request->getControllerActionName() . '.', 1298012500);
            }
        }
    }
 
    private function ‪setArgumentValue(‪Argument $argument, mixed $rawValue): void
    {
        if ($rawValue === null) {
            $argument->‪setValue(null);
            return;
        }
        $dataType = $argument->‪getDataType();
        if ($rawValue instanceof $dataType) {
            $argument->‪setValue($rawValue);
            return;
        }
        $this->propertyMapper->resetMessages();
        try {
            $argument->‪setValue(
                $this->propertyMapper->convert(
                    $rawValue,
                    $dataType,
                    $argument->‪getPropertyMappingConfiguration()
                )
            );
        } catch (‪TargetNotFoundException $e) {
            // for optional arguments no exception is thrown.
            if ($argument->‪isRequired()) {
                throw $e;
            }
        }
        $argument->‪getValidationResults()->merge($this->propertyMapper->getMessages());
    }
 
    protected function ‪htmlResponse(string $html = null): ResponseInterface
    {
        return $this->responseFactory->createResponse()
            ->withHeader('Content-Type', 'text/html; charset=utf-8')
            ->withBody($this->streamFactory->createStream(($html ?? $this->view->render())));
    }
 
    protected function ‪jsonResponse(string $json = null): ResponseInterface
    {
        return $this->responseFactory->createResponse()
            ->withHeader('Content-Type', 'application/json; charset=utf-8')
            ->withBody($this->streamFactory->createStream(($json ?? $this->view->render())));
    }
}