Request.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\InvalidRequestMethodException;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchArgumentException;
 
class ‪Request implements ‪RequestInterface
{
    const ‪PATTERN_MATCH_FORMAT = '/^[a-z0-9]{1,5}$/';
 
    protected ‪$pluginName = '';
 
    protected ‪$controllerExtensionName;
 
    protected ‪$controllerSubpackageKey;
 
    protected ‪$controllerObjectName;
 
    protected ‪$controllerName = 'Standard';
 
    protected ‪$controllerActionName = 'index';
 
    protected ‪$arguments = [];
 
    protected ‪$internalArguments = [];
 
    protected ‪$format = 'txt';
 
    protected ‪$dispatched = false;
 
    protected ‪$originalRequest;
 
    protected ‪$originalRequestMappingResults;
 
    protected ‪$method = 'GET';
 
    protected ‪$requestUri;
 
    protected ‪$baseUri;
 
    protected ‪$isCached = false;
 
    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->controllerSubpackageKey = $nameParts['subpackageKey'] ?? null;
        $this->controllerName = $nameParts['controllerName'];
    }
 
    public function ‪setPluginName(‪$pluginName = null)
    {
        if (‪$pluginName !== null) {
            $this->pluginName = ‪$pluginName;
        }
    }
 
    public function ‪getPluginName()
    {
        return ‪$this->pluginName;
    }
 
    public function ‪setControllerExtensionName(‪$controllerExtensionName)
    {
        if (‪$controllerExtensionName !== null) {
            $this->controllerExtensionName = ‪$controllerExtensionName;
        }
    }
 
    public function ‪getControllerExtensionName()
    {
        return ‪$this->controllerExtensionName;
    }
 
    public function ‪getControllerExtensionKey()
    {
        return ‪GeneralUtility::camelCaseToLowerCaseUnderscored($this->controllerExtensionName);
    }
 
    public function ‪setControllerSubpackageKey($subpackageKey)
    {
        $this->controllerSubpackageKey = $subpackageKey;
    }
 
    public function ‪getControllerSubpackageKey()
    {
        return ‪$this->controllerSubpackageKey;
    }
 
    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;
    }
 
    public function ‪setControllerName(‪$controllerName)
    {
        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.
        }
    }
 
    public function ‪getControllerName()
    {
        return ‪$this->controllerName;
    }
 
    public function ‪setControllerActionName($actionName)
    {
        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;
        }
    }
 
    public function ‪getControllerActionName()
    {
        ‪$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($argumentName, $value)
    {
        if (!is_string($argumentName) || $argumentName === '') {
            throw new InvalidArgumentNameException('Invalid argument name.', 1210858767);
        }
        if ($argumentName[0] === '_' && $argumentName[1] === '_') {
            $this->internalArguments[$argumentName] = $value;
            return;
        }
        if (!in_array($argumentName, ['@extension', '@subpackage', '@controller', '@action', '@format'], true)) {
            $this->arguments[$argumentName] = $value;
        }
    }
 
    public function ‪setArguments(array ‪$arguments)
    {
        $this->arguments = [];
        foreach (‪$arguments as $argumentName => $argumentValue) {
            $this->‪setArgument($argumentName, $argumentValue);
        }
    }
 
    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(‪$format)
    {
        $this->format = ‪$format;
    }
 
    public function ‪getFormat()
    {
        return ‪$this->format;
    }
 
    public function ‪getOriginalRequest()
    {
        return ‪$this->originalRequest;
    }
 
    public function ‪setOriginalRequest(\‪TYPO3\CMS\‪Extbase\Mvc\‪Request ‪$originalRequest)
    {
        $this->originalRequest = ‪$originalRequest;
    }
 
    public function ‪getOriginalRequestMappingResults()
    {
        if ($this->originalRequestMappingResults === null) {
            return new Result();
        }
        return ‪$this->originalRequestMappingResults;
    }
 
    public function ‪setOriginalRequestMappingResults(‪Result ‪$originalRequestMappingResults)
    {
        $this->originalRequestMappingResults = ‪$originalRequestMappingResults;
    }
 
    public function ‪getInternalArguments()
    {
        return ‪$this->internalArguments;
    }
 
    public function ‪getInternalArgument($argumentName)
    {
        if (!isset($this->internalArguments[$argumentName])) {
            return null;
        }
        return $this->internalArguments[$argumentName];
    }
 
    public function ‪setMethod(‪$method)
    {
        if (‪$method === '' || strtoupper(‪$method) !== ‪$method) {
            throw new InvalidRequestMethodException('The request method "' . ‪$method . '" is not supported.', 1217778382);
        }
        $this->method = ‪$method;
    }
 
    public function ‪getMethod()
    {
        return ‪$this->method;
    }
 
    public function ‪setRequestUri(‪$requestUri)
    {
        $this->requestUri = ‪$requestUri;
    }
 
    public function ‪getRequestUri()
    {
        return ‪$this->requestUri;
    }
 
    public function ‪setBaseUri(‪$baseUri)
    {
        $this->baseUri = ‪$baseUri;
    }
 
    public function ‪getBaseUri()
    {
        return ‪$this->baseUri;
    }
 
    public function ‪setIsCached(‪$isCached)
    {
        $this->‪isCached = (bool)‪$isCached;
    }
 
    public function ‪isCached()
    {
        return ‪$this->isCached;
    }
}