ActionController.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Mvc\Controller;

use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\Mvc\View\ViewInterface;
use TYPO3\CMS\Extbase\Mvc\Web\Request;

class ActionController extends \TYPO3\CMS\Extbase\Mvc\Controller\AbstractController {

    protected $reflectionService;

    protected $cacheService;

    protected $view = NULL;

    protected $viewObjectNamePattern = 'Tx_@extension_View_@controller_@action@format';

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

    protected $viewFormatToObjectNameMap = array();

    protected $defaultViewObjectName = 'TYPO3\\CMS\\Fluid\\View\\TemplateView';

    protected $actionMethodName = 'indexAction';

    protected $errorMethodName = 'errorAction';

    protected $mvcPropertyMappingConfigurationService;

    public function canProcessRequest(\TYPO3\CMS\Extbase\Mvc\RequestInterface $request) {
        return parent::canProcessRequest($request);
    }

    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(get_class($this) . ' 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) {
            $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');
        $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(array($this, $actionInitializationMethodName));
        }
        $this->mapRequestArgumentsToControllerArguments();
        $this->checkRequestHash();
        $this->controllerContext = $this->buildControllerContext();
        $this->view = $this->resolveView();
        if ($this->view !== NULL) {
            $this->initializeView($this->view);
        }
        $this->callActionMethod();
    }

    protected function initializeActionMethodArguments() {
        $methodParameters = $this->reflectionService->getMethodParameters(get_class($this), $this->actionMethodName);
        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 ' . get_class($this) . '->' . $this->actionMethodName . '() could not be detected.', 1253175643);
            }
            $defaultValue = isset($parameterInfo['defaultValue']) ? $parameterInfo['defaultValue'] : NULL;
            $this->arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === FALSE, $defaultValue);
        }
    }

    protected function initializeActionMethodValidators() {

        if (!$this->configurationManager->isFeatureEnabled('rewrittenPropertyMapper')) {
            // @deprecated since Extbase 1.4.0, will be removed two versions after Extbase 6.1

            $parameterValidators = $this->validatorResolver->buildMethodArgumentsValidatorConjunctions(get_class($this), $this->actionMethodName);
            $dontValidateAnnotations = array();

            $methodTagsValues = $this->reflectionService->getMethodTagsValues(get_class($this), $this->actionMethodName);
            if (isset($methodTagsValues['dontvalidate'])) {
                $dontValidateAnnotations = $methodTagsValues['dontvalidate'];
            }

            foreach ($this->arguments as $argument) {
                $validator = $parameterValidators[$argument->getName()];
                if (array_search('$' . $argument->getName(), $dontValidateAnnotations) === FALSE) {
                    $baseValidatorConjunction = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
                    if ($baseValidatorConjunction !== NULL) {
                        $validator->addValidator($baseValidatorConjunction);
                    }
                }
                $argument->setValidator($validator);
            }
        } else {
            $actionMethodParameters = static::getActionMethodParameters($this->objectManager);
            if (isset($actionMethodParameters[$this->actionMethodName])) {
                $methodParameters = $actionMethodParameters[$this->actionMethodName];
            } else {
                $methodParameters = array();
            }

            $parameterValidators = $this->validatorResolver->buildMethodArgumentsValidatorConjunctions(get_class($this), $this->actionMethodName, $methodParameters);

            foreach ($this->arguments as $argument) {
                $validator = $parameterValidators[$argument->getName()];

                $baseValidatorConjunction = $this->validatorResolver->getBaseValidatorConjunction($argument->getDataType());
                if (count($baseValidatorConjunction) > 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 "' . get_class($this) . '".', 1186669086);
        }
        return $actionMethodName;
    }

    protected function callActionMethod() {
        if ($this->configurationManager->isFeatureEnabled('rewrittenPropertyMapper')) {
            // enabled since Extbase 1.4.0.
            $preparedArguments = array();
            foreach ($this->arguments as $argument) {
                $preparedArguments[] = $argument->getValue();
            }
            $validationResult = $this->arguments->getValidationResults();
            if (!$validationResult->hasErrors()) {
                $this->emitBeforeCallActionMethodSignal($preparedArguments);
                $actionResult = call_user_func_array(array($this, $this->actionMethodName), $preparedArguments);
            } else {
                $methodTagsValues = $this->reflectionService->getMethodTagsValues(get_class($this), $this->actionMethodName);
                $ignoreValidationAnnotations = array();
                if (isset($methodTagsValues['ignorevalidation'])) {
                    $ignoreValidationAnnotations = $methodTagsValues['ignorevalidation'];
                }
                // if there exist errors which are not ignored with @ignorevalidation => call error method
                // else => call action method
                $shouldCallActionMethod = TRUE;
                foreach ($validationResult->getSubResults() as $argumentName => $subValidationResult) {
                    if (!$subValidationResult->hasErrors()) {
                        continue;
                    }
                    if (array_search('$' . $argumentName, $ignoreValidationAnnotations) !== FALSE) {
                        continue;
                    }
                    $shouldCallActionMethod = FALSE;
                    break;
                }
                if ($shouldCallActionMethod) {
                    $this->emitBeforeCallActionMethodSignal($preparedArguments);
                    $actionResult = call_user_func_array(array($this, $this->actionMethodName), $preparedArguments);
                } else {
                    $actionResult = call_user_func(array($this, $this->errorMethodName));
                }
            }
        } else {
            // @deprecated since Extbase 1.4.0, will be removed two versions after Extbase 6.1
            $preparedArguments = array();
            foreach ($this->arguments as $argument) {
                $preparedArguments[] = $argument->getValue();
            }
            if ($this->argumentsMappingResults->hasErrors()) {
                $actionResult = call_user_func(array($this, $this->errorMethodName));
            } else {
                $this->emitBeforeCallActionMethodSignal($preparedArguments);
                $actionResult = call_user_func_array(array($this, $this->actionMethodName), $preparedArguments);
            }
        }
        if ($actionResult === NULL && $this->view instanceof ViewInterface) {
            $this->response->appendContent($this->view->render());
        } elseif (is_string($actionResult) && strlen($actionResult) > 0) {
            $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', array(get_class($this), $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');
            $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 FLOW3, solved through Object Lifecycle methods, we need to call it explicitely
        $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)) {
            $deprecatedSetting = 'templateRootPath';
            $setting = 'templateRootPaths';
            $parameter = $this->getViewProperty($extbaseFrameworkConfiguration, $setting, $deprecatedSetting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                $view->$viewFunctionName($parameter);
            }
        }

        // set LayoutRootPaths
        $viewFunctionName = 'setLayoutRootPaths';
        if (method_exists($view, $viewFunctionName)) {
            $deprecatedSetting = 'layoutRootPath';
            $setting = 'layoutRootPaths';
            $parameter = $this->getViewProperty($extbaseFrameworkConfiguration, $setting, $deprecatedSetting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                $view->$viewFunctionName($parameter);
            }
        }

        // set PartialRootPaths
        $viewFunctionName = 'setPartialRootPaths';
        if (method_exists($view, $viewFunctionName)) {
            $deprecatedSetting = 'partialRootPath';
            $setting = 'partialRootPaths';
            $parameter = $this->getViewProperty($extbaseFrameworkConfiguration, $setting, $deprecatedSetting);
            // no need to bother if there is nothing to set
            if ($parameter) {
                $view->$viewFunctionName($parameter);
            }
        }
    }

    protected function getViewProperty($extbaseFrameworkConfiguration, $setting, $deprecatedSetting = '') {

        $values = array();

        if (
            !empty($extbaseFrameworkConfiguration['view'][$setting])
            && is_array($extbaseFrameworkConfiguration['view'][$setting])
        ) {
            $values = \TYPO3\CMS\Extbase\Utility\ArrayUtility::sortArrayWithIntegerKeys($extbaseFrameworkConfiguration['view'][$setting]);
            $values = array_reverse($values, TRUE);
        }

        // @todo remove handling of deprecatedSetting two versions after 6.2
        if (
            isset($extbaseFrameworkConfiguration['view'][$deprecatedSetting])
            && strlen($extbaseFrameworkConfiguration['view'][$deprecatedSetting]) > 0
        ) {
            $values[] = $extbaseFrameworkConfiguration['view'][$deprecatedSetting];
        }

        return $values;
    }

    protected function resolveViewObjectName() {
        $vendorName = $this->request->getControllerVendorName();

        if ($vendorName !== NULL) {
            $possibleViewName = str_replace('@vendor', $vendorName, $this->namespacesViewObjectNamePattern);
        } else {
            $possibleViewName = $this->viewObjectNamePattern;
        }

        $possibleViewName = str_replace(
            array(
                '@extension',
                '@controller',
                '@action'
            ),
            array(
                $this->request->getControllerExtensionName(),
                $this->request->getControllerName(),
                ucfirst($this->request->getControllerActionName())
            ),
            $possibleViewName
        );
        $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();
        if ($this->configurationManager->isFeatureEnabled('rewrittenPropertyMapper')) {
            $errorFlashMessage = $this->getErrorFlashMessage();
            if ($errorFlashMessage !== FALSE) {
                $errorFlashMessageObject = new \TYPO3\CMS\Core\Messaging\FlashMessage(
                    $errorFlashMessage,
                    '',
                    \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
                );
                $this->controllerContext->getFlashMessageQueue()->enqueue($errorFlashMessageObject);
            }
            $referringRequest = $this->request->getReferringRequest();
            if ($referringRequest !== NULL) {
                $originalRequest = clone $this->request;
                $this->request->setOriginalRequest($originalRequest);
                $this->request->setOriginalRequestMappingResults($this->arguments->getValidationResults());
                $this->forward($referringRequest->getControllerActionName(), $referringRequest->getControllerName(), $referringRequest->getControllerExtensionName(), $referringRequest->getArguments());
            }
            $message = 'An error occurred while trying to call ' . get_class($this) . '->' . $this->actionMethodName . '().' . PHP_EOL;
            return $message;
        } else {
            // @deprecated since Extbase 1.4.0, will be removed two versions after Extbase 6.1
            $this->request->setErrors($this->argumentsMappingResults->getErrors());
            $errorFlashMessage = $this->getErrorFlashMessage();
            if ($errorFlashMessage !== FALSE) {
                $errorFlashMessageObject = new \TYPO3\CMS\Core\Messaging\FlashMessage(
                    $errorFlashMessage,
                    '',
                    \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
                );
                $this->controllerContext->getFlashMessageQueue()->enqueue($errorFlashMessageObject);
            }
            $referrer = NULL;
            if ($this->request instanceof Request) {
                $referrer = $this->request->getValidatedReferrerArguments();
            }
            if ($referrer !== NULL) {
                $this->forward($referrer['actionName'], $referrer['controllerName'], $referrer['extensionName'], $this->request->getArguments());
            }
            $message = 'An error occurred while trying to call ' . get_class($this) . '->' . $this->actionMethodName . '().' . PHP_EOL;
            return $message;
        }
    }

    protected function getErrorFlashMessage() {
        return 'An error occurred while trying to call ' . get_class($this) . '->' . $this->actionMethodName . '()';
    }

    protected function checkRequestHash() {
        if ($this->configurationManager->isFeatureEnabled('rewrittenPropertyMapper')) {
            // If the new property mapper is enabled, the request hash is not needed anymore.
            return;
        }
        if (!$this->request instanceof \TYPO3\CMS\Extbase\Mvc\Web\Request) {
            return;
        }
        // We only want to check it for now for web requests.
        if ($this->request->isHmacVerified()) {
            return;
        }
        // all good
        $verificationNeeded = FALSE;
        foreach ($this->arguments as $argument) {
            if ($argument->getOrigin() == \TYPO3\CMS\Extbase\Mvc\Controller\Argument::ORIGIN_NEWLY_CREATED || $argument->getOrigin() == \TYPO3\CMS\Extbase\Mvc\Controller\Argument::ORIGIN_PERSISTENCE_AND_MODIFIED) {
                $verificationNeeded = TRUE;
            }
        }
        if ($verificationNeeded) {
            $methodTagsValues = $this->reflectionService->getMethodTagsValues(get_class($this), $this->actionMethodName);
            if (!isset($methodTagsValues['dontverifyrequesthash'])) {
                throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidOrNoRequestHashException('Request hash (HMAC) checking failed. The parameter __hmac was invalid or not set, and objects were modified.', 1255082824);
            }
        }
    }

    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(array($pageUid));
            }
        }
    }

    static public function getActionMethodParameters($objectManager) {
        $reflectionService = $objectManager->get('TYPO3\CMS\Extbase\Reflection\ReflectionService');

        $result = array();

        $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;
    }
}