ExtbaseRequestParameters.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;
 
use ‪TYPO3\CMS\Core\Utility\ClassNamingUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Error\Result;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidActionNameException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentNameException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidControllerNameException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchArgumentException;
 
class ‪ExtbaseRequestParameters
{
    protected ‪$pluginName = '';
 
    protected ‪$controllerExtensionName;
 
    protected ‪$controllerObjectName;
 
    protected ‪$controllerName = 'Standard';
 
    protected ‪$controllerActionName = 'index';
 
    protected ‪$arguments = [];
 
    protected array ‪$internalArguments = [];
 
    protected ‪$format = 'html';
 
    protected ‪$dispatched = false;
 
    protected ‪$originalRequest;
 
    protected ‪$originalRequestMappingResults;
 
    public function ‪setDispatched($flag)
    {
        $this->dispatched = (bool)$flag;
    }
 
    public function ‪isDispatched()
    {
        return ‪$this->dispatched;
    }
 
    public function ‪__construct(string $controllerClassName = '')
    {
        $this->controllerObjectName = $controllerClassName;
    }
 
    public function ‪getControllerObjectName(): string
    {
        return ‪$this->controllerObjectName;
    }
 
    public function ‪setControllerObjectName(‪$controllerObjectName)
    {
        $nameParts = ‪ClassNamingUtility::explodeObjectControllerName(‪$controllerObjectName);
        $this->controllerExtensionName = $nameParts['extensionName'];
        $this->controllerName = $nameParts['controllerName'];
        return $this;
    }
 
    public function ‪setPluginName(‪$pluginName = null)
    {
        if (‪$pluginName !== null) {
            $this->pluginName = ‪$pluginName;
        }
        return $this;
    }
 
    public function ‪getPluginName()
    {
        return ‪$this->pluginName;
    }
 
    public function ‪setControllerExtensionName(‪$controllerExtensionName): self
    {
        if (‪$controllerExtensionName !== null) {
            $this->controllerExtensionName = ‪$controllerExtensionName;
        }
        return $this;
    }
 
    public function ‪getControllerExtensionName()
    {
        return ‪$this->controllerExtensionName;
    }
 
    public function ‪getControllerExtensionKey()
    {
        return ‪GeneralUtility::camelCaseToLowerCaseUnderscored($this->controllerExtensionName);
    }
 
    protected ‪$controllerAliasToClassNameMapping = [];
 
    public function ‪setControllerAliasToClassNameMapping(array ‪$controllerAliasToClassNameMapping)
    {
        // this is only needed as long as forwarded requests are altered and unless there
        // is no new request object created by the request builder.
        $this->controllerAliasToClassNameMapping = ‪$controllerAliasToClassNameMapping;
        return $this;
    }
 
    public function ‪setControllerName(‪$controllerName): self
    {
        if (!is_string(‪$controllerName) && ‪$controllerName !== null) {
            throw new ‪InvalidControllerNameException('The controller name must be a valid string, ' . gettype(‪$controllerName) . ' given.', 1187176358);
        }
        if (‪$controllerName !== null) {
            $this->controllerName = ‪$controllerName;
            $this->controllerObjectName = $this->controllerAliasToClassNameMapping[‪$controllerName] ?? '';
            // There might be no Controller Class, for example for Fluid Templates.
        }
        return $this;
    }
 
    public function ‪getControllerName()
    {
        return ‪$this->controllerName;
    }
 
    public function ‪setControllerActionName($actionName): self
    {
        if (!is_string($actionName) && $actionName !== null) {
            throw new ‪InvalidActionNameException('The action name must be a valid string, ' . gettype($actionName) . ' given (' . $actionName . ').', 1187176359);
        }
        if ($actionName[0] !== strtolower($actionName[0]) && $actionName !== null) {
            throw new InvalidActionNameException('The action name must start with a lower case letter, "' . $actionName . '" does not match this criteria.', 1218473352);
        }
        if ($actionName !== null) {
            $this->controllerActionName = $actionName;
        }
        return $this;
    }
 
    public function ‪getControllerActionName(): string
    {
        ‪$controllerObjectName = $this->‪getControllerObjectName();
        if (‪$controllerObjectName !== '' && $this->controllerActionName === strtolower($this->controllerActionName)) {
            // todo: this is nonsense! We can detect a non existing method in
            // todo: \TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin, if necessary.
            // todo: At this point, we want to have a getter for a fixed value.
            $actionMethodName = $this->controllerActionName . 'Action';
            $classMethods = get_class_methods(‪$controllerObjectName);
            if (is_array($classMethods)) {
                foreach ($classMethods as $existingMethodName) {
                    if (strtolower($existingMethodName) === strtolower($actionMethodName)) {
                        $this->controllerActionName = substr($existingMethodName, 0, -6);
                        break;
                    }
                }
            }
        }
        return ‪$this->controllerActionName;
    }
 
    public function ‪setArgument(string $argumentName, $value): self
    {
        if ($argumentName === '') {
            throw new ‪InvalidArgumentNameException('Invalid argument name.', 1210858767);
        }
        if ($argumentName[0] === '_' && $argumentName[1] === '_') {
            $this->internalArguments[$argumentName] = $value;
            return $this;
        }
        if (!in_array($argumentName, ['@extension', '@subpackage', '@controller', '@action', '@format'], true)) {
            $this->arguments[$argumentName] = $value;
        }
        return $this;
    }
 
    public function ‪setArguments(array ‪$arguments): self
    {
        $this->arguments = [];
        foreach (‪$arguments as $argumentName => $argumentValue) {
            $this->‪setArgument($argumentName, $argumentValue);
        }
        return $this;
    }
 
    public function ‪getArguments()
    {
        return ‪$this->arguments;
    }
 
    public function ‪getArgument($argumentName)
    {
        if (!isset($this->arguments[$argumentName])) {
            throw new ‪NoSuchArgumentException('An argument "' . $argumentName . '" does not exist for this request.', 1176558158);
        }
        return $this->arguments[$argumentName];
    }
 
    public function ‪hasArgument($argumentName)
    {
        return isset($this->arguments[$argumentName]);
    }
 
    public function ‪setFormat(string ‪$format): self
    {
        $this->format = ‪$format;
        return $this;
    }
 
    public function ‪getFormat()
    {
        return ‪$this->format;
    }
 
    public function ‪getOriginalRequest(): ?‪Request
    {
        return ‪$this->originalRequest;
    }
 
    public function ‪setOriginalRequest(\‪TYPO3\CMS\‪Extbase\Mvc\‪Request ‪$originalRequest)
    {
        $this->originalRequest = ‪$originalRequest;
    }
 
    public function ‪getOriginalRequestMappingResults(): ‪Result
    {
        if ($this->originalRequestMappingResults === null) {
            return new ‪Result();
        }
        return ‪$this->originalRequestMappingResults;
    }
 
    public function ‪setOriginalRequestMappingResults(‪Result ‪$originalRequestMappingResults)
    {
        $this->originalRequestMappingResults = ‪$originalRequestMappingResults;
    }
 
    public function ‪getInternalArguments(): array
    {
        return ‪$this->internalArguments;
    }
 
    public function ‪getInternalArgument($argumentName)
    {
        if (!isset($this->internalArguments[$argumentName])) {
            return null;
        }
        return $this->internalArguments[$argumentName];
    }
}