AbstractController.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 ‪TYPO3\CMS\Core\Compatibility\PublicPropertyDeprecationTrait;
use ‪TYPO3\CMS\Core\Messaging\AbstractMessage;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\Exception\RequiredArgumentMissingException;
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\Mvc\Web\Request as WebRequest;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Response;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Service\CacheService;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
use ‪TYPO3\CMS\Extbase\Validation\ValidatorResolver;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
 
abstract class ‪AbstractController implements ‪ControllerInterface
{
    use ‪PublicPropertyDeprecationTrait;
 
    private ‪$deprecatedPublicProperties = [
        'signalSlotDispatcher' => 'Property ' . self::class . '::$signalSlotDispatcher is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'objectManager' => 'Property ' . self::class . '::$objectManager is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'uriBuilder' => 'Property ' . self::class . '::$uriBuilder is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'settings' => 'Property ' . self::class . '::$settings is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'request' => 'Property ' . self::class . '::$request is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'response' => 'Property ' . self::class . '::$response is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'arguments' => 'Property ' . self::class . '::$arguments is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'validatorResolver' => 'Property ' . self::class . '::$validatorResolver is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'supportedRequestTypes' => 'Property ' . self::class . '::$supportedRequestTypes is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'controllerContext' => 'Property ' . self::class . '::$controllerContext is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
        'configurationManager' => 'Property ' . self::class . '::$configurationManager is deprecated since TYPO3 10.2 and will be removed in TYPO3 11.0',
    ];
 
    private ‪$signalSlotDispatcher;
 
    private ‪$objectManager;
 
    private ‪$uriBuilder;
 
    private ‪$settings;
 
    private ‪$request;
 
    private ‪$response;
 
    private ‪$validatorResolver;
 
    private ‪$arguments;
 
    public function ‪injectSignalSlotDispatcher(‪Dispatcher ‪$signalSlotDispatcher)
    {
        $this->signalSlotDispatcher = ‪$signalSlotDispatcher;
    }
 
    public function ‪injectValidatorResolver(‪ValidatorResolver ‪$validatorResolver)
    {
        $this->validatorResolver = ‪$validatorResolver;
    }
 
    private ‪$supportedRequestTypes = [\TYPO3\CMS\Extbase\Mvc\Request::class];
 
    private ‪$controllerContext;
 
    public function ‪getControllerContext()
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        return ‪$this->controllerContext;
    }
 
    private ‪$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 ‪addFlashMessage($messageBody, $messageTitle = '', $severity = ‪AbstractMessage::OK, $storeInSession = true)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        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)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        foreach ($this->supportedRequestTypes as $supportedRequestType) {
            if (‪$request instanceof $supportedRequestType) {
                return true;
            }
        }
        return false;
    }
 
    public function ‪processRequest(‪RequestInterface ‪$request, ‪ResponseInterface ‪$response)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        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 Response && ‪$request instanceof WebRequest) {
            ‪$response->setRequest(‪$request);
        }
        $this->request = ‪$request;
        $this->request->‪setDispatched(true);
        $this->response = ‪$response;
        $this->uriBuilder = $this->objectManager->get(UriBuilder::class);
        $this->uriBuilder->setRequest(‪$request);
        $this->‪initializeControllerArgumentsBaseValidators();
        $this->‪mapRequestArgumentsToControllerArguments();
        $this->controllerContext = $this->‪buildControllerContext();
    }
 
    protected function ‪buildControllerContext()
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        ‪$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)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        $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)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        if (!$this->request instanceof WebRequest) {
            throw new UnsupportedRequestTypeException('redirect() only supports web requests.', 1220539734);
        }
        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)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        if (!$this->request instanceof WebRequest) {
            throw new UnsupportedRequestTypeException('redirect() only supports web requests.', 1220539735);
        }
 
        $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>');
        if ($this->response instanceof 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() === ‪ContentObjectRenderer::OBJECTTYPE_USER) {
            $contentObject->convertToUserIntObject();
        }
 
        throw new ‪StopActionException('redirectToUri', 1476045828);
    }
 
    protected function ‪addBaseUriIfNecessary($uri)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        return GeneralUtility::locationHeaderUrl((string)$uri);
    }
 
    public function ‪throwStatus($statusCode, $statusMessage = null, $content = null)
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        if (!$this->request instanceof WebRequest) {
            throw new UnsupportedRequestTypeException('throwStatus() only supports web requests.', 1220539739);
        }
        if ($this->response instanceof 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()
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        foreach ($this->arguments as $argument) {
            ‪$validator = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
            if (‪$validator !== null) {
                $argument->setValidator(‪$validator);
            }
        }
    }
 
    protected function ‪mapRequestArgumentsToControllerArguments()
    {
        trigger_error(
            __METHOD__ . ' is deprecated since TYPO3 10.2 and will be removed in version 11.0',
            E_USER_DEPRECATED
        );
 
        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);
            }
        }
    }
}