AbstractController.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\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\StopActionException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\UnsupportedRequestTypeException;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Request as WebRequest;
 
abstract class ‪AbstractController implements ‪ControllerInterface
{
    protected ‪$signalSlotDispatcher;
 
    protected ‪$objectManager;
 
    protected ‪$uriBuilder;
 
    protected ‪$extensionName;
 
    protected ‪$settings;
 
    protected ‪$request;
 
    protected ‪$response;
 
    protected ‪$validatorResolver;
 
    protected ‪$arguments;
 
    public function ‪injectSignalSlotDispatcher(\‪TYPO3\CMS\‪Extbase\SignalSlot\‪Dispatcher ‪$signalSlotDispatcher)
    {
        $this->signalSlotDispatcher = ‪$signalSlotDispatcher;
    }
 
    public function ‪injectValidatorResolver(\‪TYPO3\CMS\‪Extbase\Validation\ValidatorResolver ‪$validatorResolver)
    {
        $this->validatorResolver = ‪$validatorResolver;
    }
 
    protected ‪$supportedRequestTypes = [\TYPO3\CMS\Extbase\Mvc\Request::class];
 
    protected ‪$controllerContext;
 
    public function ‪getControllerContext()
    {
        return ‪$this->controllerContext;
    }
 
    protected ‪$configurationManager;
 
    public function ‪__construct()
    {
        $className = static::class;
        $classNameParts = explode('\\', $className, 4);
        // Skip vendor and product name for core classes
        if (strpos($className, 'TYPO3\\CMS\\') === 0) {
            $this->extensionName = $classNameParts[2];
        } else {
            $this->extensionName = $classNameParts[1];
        }
    }
 
    public function ‪injectConfigurationManager(ConfigurationManagerInterface ‪$configurationManager)
    {
        $this->configurationManager = ‪$configurationManager;
        $this->settings = $this->configurationManager->‪getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_SETTINGS);
    }
 
    public function ‪injectObjectManager(\‪TYPO3\CMS\‪Extbase\Object\ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
        $this->arguments = $this->objectManager->‪get(\‪TYPO3\CMS\‪Extbase\Mvc\Controller\Arguments::class);
    }
 
    public function ‪addFlashMessage($messageBody, $messageTitle = '', $severity = \‪TYPO3\CMS\Core\Messaging\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 = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(
            \‪TYPO3\CMS\Core\Messaging\FlashMessage::class,
            (string)$messageBody,
            (string)$messageTitle,
            $severity,
            $storeInSession
        );
        $this->controllerContext->getFlashMessageQueue()->enqueue($flashMessage);
    }
 
    public function ‪canProcessRequest(\‪TYPO3\CMS\‪Extbase\Mvc\‪RequestInterface ‪$request)
    {
        foreach ($this->supportedRequestTypes as $supportedRequestType) {
            if (‪$request instanceof $supportedRequestType) {
                return true;
            }
        }
        return false;
    }
 
    public function ‪processRequest(\‪TYPO3\CMS\‪Extbase\Mvc\RequestInterface ‪$request, \‪TYPO3\CMS\‪Extbase\Mvc\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), 1187701132);
        }
        if (‪$response instanceof \‪TYPO3\CMS\‪Extbase\Mvc\Web\Response && ‪$request instanceof WebRequest) {
            ‪$response->setRequest(‪$request);
        }
        $this->request = ‪$request;
        $this->request->‪setDispatched(true);
        $this->response = ‪$response;
        $this->uriBuilder = $this->objectManager->get(\‪TYPO3\CMS\‪Extbase\Mvc\Web\Routing\UriBuilder::class);
        $this->uriBuilder->setRequest(‪$request);
        $this->‪initializeControllerArgumentsBaseValidators();
        $this->‪mapRequestArgumentsToControllerArguments();
        $this->controllerContext = $this->‪buildControllerContext();
    }
 
    protected function ‪buildControllerContext()
    {
        ‪$controllerContext = $this->objectManager->get(\‪TYPO3\CMS\‪Extbase\Mvc\Controller\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);
        if ($this->request instanceof WebRequest) {
            $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 (!$this->request instanceof WebRequest) {
            throw new UnsupportedRequestTypeException('redirect() only supports web requests.', 1220539734);
        }
        if ($controllerName === null) {
            $controllerName = $this->request->getControllerName();
        }
        $this->uriBuilder->reset()->setTargetPageUid($pageUid)->setCreateAbsoluteUri(true);
        if (\‪TYPO3\CMS\Core\Utility\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)
    {
        if (!$this->request instanceof WebRequest) {
            throw new ‪UnsupportedRequestTypeException('redirect() only supports web requests.', 1220539735);
        }
 
        $this->objectManager->get(\‪TYPO3\CMS\‪Extbase\Service\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>');
        if ($this->response instanceof \‪TYPO3\CMS\‪Extbase\Mvc\Web\‪Response) {
            $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() === \‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::OBJECTTYPE_USER) {
            $contentObject->convertToUserIntObject();
        }
 
        throw new ‪StopActionException('redirectToUri', 1476045828);
    }
 
    protected function ‪addBaseUriIfNecessary($uri)
    {
        return \TYPO3\CMS\Core\Utility\GeneralUtility::locationHeaderUrl((string)$uri);
    }
 
    public function ‪throwStatus($statusCode, $statusMessage = null, $content = null)
    {
        if (!$this->request instanceof WebRequest) {
            throw new ‪UnsupportedRequestTypeException('throwStatus() only supports web requests.', 1220539739);
        }
        if ($this->response instanceof \‪TYPO3\CMS\‪Extbase\Mvc\Web\‪Response) {
            $this->response->setStatus($statusCode, $statusMessage);
            if ($content === null) {
                $content = $this->response->getStatus();
            }
        }
        $this->response->setContent($content);
        throw new StopActionException('throwStatus', 1476045871);
    }
 
    public function ‪initializeControllerArgumentsBaseValidators()
    {
        foreach ($this->arguments as $argument) {
            ‪$validator = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
            if (‪$validator !== null) {
                $argument->setValidator(‪$validator);
            }
        }
    }
 
    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 \TYPO3\CMS\Extbase\Mvc\Controller\Exception\RequiredArgumentMissingException('Required argument "' . $argumentName . '" is not set for ' . $this->request->getControllerObjectName() . '->' . $this->request->getControllerActionName() . '.', 1298012500);
            }
        }
    }
}