ExtbaseRequestParameters.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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 Psr\Http\Message\UploadedFileInterface;
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\NoSuchArgumentException;
 
class ‪ExtbaseRequestParameters
{
    protected string ‪$pluginName = '';
 
    protected string ‪$controllerExtensionName = '';
 
    protected string ‪$controllerObjectName = '';
 
    protected string ‪$controllerName = 'Standard';
 
    protected array ‪$controllerAliasToClassNameMapping = [];
 
    protected string ‪$controllerActionName = 'index';
 
    protected array ‪$arguments = [];
 
    protected array ‪$internalArguments = [];
 
    protected string ‪$format = 'html';
 
    protected ?‪RequestInterface ‪$originalRequest = null;
 
    protected ?‪Result ‪$originalRequestMappingResults = null;
 
    protected array ‪$uploadedFiles = [];
 
    public function ‪__construct(string $controllerClassName = '')
    {
        $this->controllerObjectName = $controllerClassName;
    }
 
    public function ‪getControllerObjectName(): string
    {
        return ‪$this->controllerObjectName;
    }
 
    public function ‪setControllerObjectName(string ‪$controllerObjectName): self
    {
        $nameParts = ‪ClassNamingUtility::explodeObjectControllerName(‪$controllerObjectName);
        $this->controllerExtensionName = $nameParts['extensionName'];
        $this->controllerName = $nameParts['controllerName'];
        return $this;
    }
 
    public function ‪setPluginName(string ‪$pluginName): self
    {
        $this->pluginName = ‪$pluginName;
        return $this;
    }
 
    public function ‪getPluginName(): string
    {
        return ‪$this->pluginName;
    }
 
    public function ‪setControllerExtensionName(string ‪$controllerExtensionName): self
    {
        $this->controllerExtensionName = ‪$controllerExtensionName;
        return $this;
    }
 
    public function ‪getControllerExtensionName(): string
    {
        return ‪$this->controllerExtensionName;
    }
 
    public function ‪getControllerExtensionKey(): string
    {
        return ‪GeneralUtility::camelCaseToLowerCaseUnderscored($this->controllerExtensionName);
    }
 
    public function ‪setControllerAliasToClassNameMapping(array ‪$controllerAliasToClassNameMapping): self
    {
        // 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(string ‪$controllerName): self
    {
        $this->controllerName = ‪$controllerName;
        // There might be no Controller Class, for example for Fluid Templates.
        $this->controllerObjectName = $this->controllerAliasToClassNameMapping[‪$controllerName] ?? '';
        return $this;
    }
 
    public function ‪getControllerName(): string
    {
        return ‪$this->controllerName;
    }
 
    public function ‪setControllerActionName(string $actionName): self
    {
        if ($actionName[0] !== strtolower($actionName[0])) {
            throw new ‪InvalidActionNameException('The action name must start with a lower case letter, "' . $actionName . '" does not match this criteria.', 1218473352);
        }
        $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, mixed $value): self
    {
        if ($argumentName === '') {
            throw new ‪InvalidArgumentNameException('Invalid argument name.', 1210858767);
        }
        if (str_starts_with($argumentName, '__')) {
            $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(): array
    {
        return ‪$this->arguments;
    }
 
    public function ‪getArgument(string $argumentName): mixed
    {
        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(string $argumentName = ''): bool
    {
        return isset($this->arguments[$argumentName]);
    }
 
    public function ‪setFormat(string ‪$format): self
    {
        $this->format = ‪$format;
        return $this;
    }
 
    public function ‪getFormat(): string
    {
        return ‪$this->format;
    }
 
    public function ‪getOriginalRequest(): ?‪RequestInterface
    {
        return ‪$this->originalRequest;
    }
 
    public function ‪setOriginalRequest(‪RequestInterface ‪$originalRequest): self
    {
        $this->originalRequest = ‪$originalRequest;
        return $this;
    }
 
    public function ‪getOriginalRequestMappingResults(): ‪Result
    {
        if ($this->originalRequestMappingResults === null) {
            return new ‪Result();
        }
        return ‪$this->originalRequestMappingResults;
    }
 
    public function ‪setOriginalRequestMappingResults(‪Result ‪$originalRequestMappingResults): self
    {
        $this->originalRequestMappingResults = ‪$originalRequestMappingResults;
        return $this;
    }
 
    public function ‪getInternalArgument($argumentName): mixed
    {
        if (!isset($this->internalArguments[$argumentName])) {
            return null;
        }
        return $this->internalArguments[$argumentName];
    }
 
    public function ‪getUploadedFiles(): array
    {
        return ‪$this->uploadedFiles;
    }
 
    public function ‪setUploadedFiles(array $files): self
    {
        $this->‪validateUploadedFiles($files);
        $this->uploadedFiles = $files;
        return $this;
    }
 
    protected function ‪validateUploadedFiles(array ‪$uploadedFiles): void
    {
        foreach (‪$uploadedFiles as $file) {
            if (is_array($file)) {
                $this->‪validateUploadedFiles($file);
                continue;
            }
            if (!$file instanceof UploadedFileInterface) {
                throw new \InvalidArgumentException('Invalid file in uploaded files structure.', 1647338470);
            }
        }
    }
}