9.5/extbase_2_classes_2_mvc_2_controller_2_action_controller_8php_source.html

<?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\Messaging\FlashMessage;

use ‪TYPO3\CMS\Core\Page\PageRenderer;

use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;

use ‪TYPO3\CMS\Extbase\Mvc\Exception\StopActionException;

use ‪TYPO3\CMS\Extbase\Mvc\View\ViewInterface;

use ‪TYPO3\CMS\Extbase\Mvc\Web\Request as WebRequest;

use ‪TYPO3\CMS\Extbase\Validation\Validator\ConjunctionValidator;

use ‪TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;

use TYPO3Fluid\Fluid\View\TemplateView;


class ‪ActionController extends ‪AbstractController

{

    protected ‪$reflectionService;


    protected ‪$cacheService;


    protected ‪$view;


    protected ‪$namespacesViewObjectNamePattern = '@vendor\@extension\View\@controller\@action@format';


    protected ‪$viewFormatToObjectNameMap = [];


    protected ‪$defaultViewObjectName = \TYPO3\CMS\Fluid\View\TemplateView::class;


    protected ‪$actionMethodName = 'indexAction';


    protected ‪$errorMethodName = 'errorAction';


    protected ‪$mvcPropertyMappingConfigurationService;


    protected ‪$request;


    protected ‪$response;


    public function ‪injectReflectionService(\‪TYPO3\CMS\‪Extbase\Reflection\‪ReflectionService ‪$reflectionService)

    {

        $this->reflectionService = ‪$reflectionService;

    }


    public function ‪injectCacheService(\‪TYPO3\CMS\‪Extbase\Service\CacheService ‪$cacheService)

    {

        $this->cacheService = ‪$cacheService;

    }


    public function ‪injectMvcPropertyMappingConfigurationService(\‪TYPO3\CMS\‪Extbase\Mvc\Controller\MvcPropertyMappingConfigurationService ‪$mvcPropertyMappingConfigurationService)

    {

        $this->mvcPropertyMappingConfigurationService = ‪$mvcPropertyMappingConfigurationService;

    }


    public function ‪processRequest(\‪TYPO3\CMS\‪Extbase\Mvc\‪RequestInterface ‪$request, \‪TYPO3\CMS\‪Extbase\Mvc\‪ResponseInterface ‪$response)

    {

        if (!$this->‪canProcessRequest($request)) {

            throw new \TYPO3\CMS\Extbase\Mvc\Exception\UnsupportedRequestTypeException(static::class . ' does not support requests of type "' . get_class(‪$request) . '". Supported types are: ' . implode(' ', $this->supportedRequestTypes), 1187701131);

        }


        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->actionMethodName = $this->‪resolveActionMethodName();

        $this->‪initializeActionMethodArguments();

        $this->‪initializeActionMethodValidators();

        $this->mvcPropertyMappingConfigurationService->initializePropertyMappingConfigurationFromRequest(‪$request, $this->arguments);

        $this->‪initializeAction();

        $actionInitializationMethodName = 'initialize' . ucfirst($this->actionMethodName);

        if (method_exists($this, $actionInitializationMethodName)) {

            call_user_func([$this, $actionInitializationMethodName]);

        }

        $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 = $this->objectManager->get(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 ‪initializeActionMethodArguments()

    {

        $methodParameters = $this->reflectionService

                ->getClassSchema(static::class)

                ->getMethod($this->actionMethodName)['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 \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException('The argument type for parameter $' . $parameterName . ' of method ' . static::class . '->' . $this->actionMethodName . '() could not be detected.', 1253175643);

            }

            $defaultValue = $parameterInfo['hasDefaultValue'] === true ? $parameterInfo['defaultValue'] : null;

            $this->arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === false, $defaultValue);

        }

    }


    protected function ‪initializeActionMethodValidators()

    {

        if ($this->arguments->count() === 0) {

            return;

        }


        $classSchema = $this->reflectionService->getClassSchema(static::class);


        $ignoreValidationAnnotations = array_unique(array_flip(

            $classSchema->getMethod($this->actionMethodName)['tags']['ignorevalidation'] ?? []

        ));


        foreach ($this->arguments as $argument) {

            if (isset($ignoreValidationAnnotations[$argument->getName()])) {

                continue;

            }


            ‪$validator = $this->objectManager->get(ConjunctionValidator::class);

            $validatorDefinitions = $classSchema->getMethod($this->actionMethodName)['params'][$argument->getName()]['validators'] ?? [];


            foreach ($validatorDefinitions 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);

        }

    }


    protected function ‪resolveActionMethodName()

    {

        ‪$actionMethodName = $this->request->getControllerActionName() . 'Action';

        if (!method_exists($this, ‪$actionMethodName)) {

            throw new \TYPO3\CMS\Extbase\Mvc\Exception\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->‪emitBeforeCallActionMethodSignal($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)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'beforeCallActionMethod', [static::class, $this->actionMethodName, $preparedArguments]);

    }


    protected function ‪resolveView()

    {

        $viewObjectName = $this->‪resolveViewObjectName();

        if ($viewObjectName !== false) {

            ‪$view = $this->objectManager->get($viewObjectName);

            $this->‪setViewConfiguration(‪$view);

            if (‪$view->‪canRender($this->controllerContext) === false) {

                unset(‪$view);

            }

        }

        if (!isset(‪$view) && $this->defaultViewObjectName != '') {

            ‪$view = $this->objectManager->get($this->defaultViewObjectName);

            $this->‪setViewConfiguration(‪$view);

            if (‪$view->‪canRender($this->controllerContext) === false) {

                unset(‪$view);

            }

        }

        if (!isset(‪$view)) {

            ‪$view = $this->objectManager->get(\‪TYPO3\CMS\‪Extbase\Mvc\View\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 ‪resolveViewObjectName()

    {

        $vendorName = $this->request->getControllerVendorName();

        if ($vendorName === null) {

            return false;

        }


        $possibleViewName = str_replace(

            [

                '@vendor',

                '@extension',

                '@controller',

                '@action'

            ],

            [

                $vendorName,

                $this->request->getControllerExtensionName(),

                $this->request->getControllerName(),

                ucfirst($this->request->getControllerActionName())

            ],

            $this->namespacesViewObjectNamePattern

        );

        $format = $this->request->getFormat();

        $viewObjectName = str_replace('@format', ucfirst($format), $possibleViewName);

        if (class_exists($viewObjectName) === false) {

            $viewObjectName = str_replace('@format', '', $possibleViewName);

        }

        if (isset($this->viewFormatToObjectNameMap[$format]) && class_exists($viewObjectName) === false) {

            $viewObjectName = $this->viewFormatToObjectNameMap[$format];

        }

        return class_exists($viewObjectName) ? $viewObjectName : false;

    }


    protected function ‪initializeView(‪ViewInterface ‪$view)

    {

    }


    protected function ‪initializeAction()

    {

    }


    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 = $this->request->getReferringRequest();

        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 static function ‪getActionMethodParameters(‪$objectManager)

    {

        trigger_error(

            'Method ' . __METHOD__ . ' is deprecated and will be removed in TYPO3 v10.0.',

            E_USER_DEPRECATED

        );


        ‪$reflectionService = ‪$objectManager->‪get(\‪TYPO3\CMS\‪Extbase\Reflection\ReflectionService::class);


        $result = [];


        $className = get_called_class();

        $methodNames = get_class_methods($className);

        foreach ($methodNames as $methodName) {

            if (strlen($methodName) > 6 && strpos($methodName, 'Action', strlen($methodName) - 6) !== false) {

                $result[$methodName] = ‪$reflectionService->‪getMethodParameters($className, $methodName);

            }

        }


        return $result;

    }

}