UriBuilder.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\Web\Routing;
 
use ‪TYPO3\CMS\Backend\Routing\Exception\ResourceNotFoundException;
use ‪TYPO3\CMS\Backend\Routing\Exception\RouteNotFoundException;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\HttpUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject;
use ‪TYPO3\CMS\Extbase\DomainObject\AbstractValueObject;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentValueException;
use ‪TYPO3\CMS\Extbase\Mvc\Request;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\LazyLoadingProxy;
use ‪TYPO3\CMS\Extbase\Service\EnvironmentService;
use ‪TYPO3\CMS\Extbase\Service\ExtensionService;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
 
class ‪UriBuilder
{
    protected ‪$configurationManager;
 
    protected ‪$extensionService;
 
    protected ‪$contentObject;
 
    protected ‪$request;
 
    protected ‪$arguments = [];
 
    protected ‪$lastArguments = [];
 
    protected ‪$section = '';
 
    protected ‪$createAbsoluteUri = false;
 
    protected ‪$absoluteUriScheme;
 
    protected ‪$addQueryString = false;
 
    protected ‪$addQueryStringMethod = '';
 
    protected ‪$argumentsToBeExcludedFromQueryString = [];
 
    protected ‪$linkAccessRestrictedPages = false;
 
    protected ‪$targetPageUid;
 
    protected ‪$targetPageType = 0;
 
    protected ‪$language;
 
    protected ‪$noCache = false;
 
    protected ‪$format = '';
 
    protected ‪$argumentPrefix;
 
    protected ‪$environmentService;
 
    public function ‪injectConfigurationManager(‪ConfigurationManagerInterface ‪$configurationManager): void
    {
        $this->configurationManager = ‪$configurationManager;
    }
 
    public function ‪injectExtensionService(‪ExtensionService ‪$extensionService): void
    {
        $this->extensionService = ‪$extensionService;
    }
 
    public function ‪injectEnvironmentService(‪EnvironmentService ‪$environmentService): void
    {
        $this->environmentService = ‪$environmentService;
    }
 
    public function ‪initializeObject(): void
    {
        $this->contentObject = $this->configurationManager->getContentObject()
            ?? GeneralUtility::makeInstance(ContentObjectRenderer::class);
    }
 
    public function ‪setRequest(‪Request ‪$request): ‪UriBuilder
    {
        $this->request = ‪$request;
        return $this;
    }
 
    public function ‪getRequest(): ?‪Request
    {
        return ‪$this->request;
    }
 
    public function ‪setArguments(array ‪$arguments): ‪UriBuilder
    {
        $this->arguments = ‪$arguments;
        return $this;
    }
 
    public function ‪getArguments(): array
    {
        return ‪$this->arguments;
    }
 
    public function ‪setSection(string ‪$section): ‪UriBuilder
    {
        $this->section = ‪$section;
        return $this;
    }
 
    public function ‪getSection(): string
    {
        return ‪$this->section;
    }
 
    public function ‪setFormat(string ‪$format): ‪UriBuilder
    {
        $this->format = ‪$format;
        return $this;
    }
 
    public function ‪getFormat(): string
    {
        return ‪$this->format;
    }
 
    public function ‪setCreateAbsoluteUri(bool ‪$createAbsoluteUri): ‪UriBuilder
    {
        $this->createAbsoluteUri = ‪$createAbsoluteUri;
        return $this;
    }
 
    public function ‪getCreateAbsoluteUri(): bool
    {
        return ‪$this->createAbsoluteUri;
    }
 
    public function ‪getAbsoluteUriScheme(): ?string
    {
        return ‪$this->absoluteUriScheme;
    }
 
    public function ‪setAbsoluteUriScheme(string ‪$absoluteUriScheme): ‪UriBuilder
    {
        $this->absoluteUriScheme = ‪$absoluteUriScheme;
        return $this;
    }
 
    public function ‪setLanguage(?string ‪$language): UriBuilder
    {
        $this->language = ‪$language;
        return $this;
    }
 
    public function ‪getLanguage(): ?string
    {
        return ‪$this->language;
    }
 
    public function ‪setAddQueryString(bool ‪$addQueryString): ‪UriBuilder
    {
        $this->addQueryString = ‪$addQueryString;
        return $this;
    }
 
    public function ‪getAddQueryString(): bool
    {
        return ‪$this->addQueryString;
    }
 
    public function ‪setAddQueryStringMethod(string ‪$addQueryStringMethod): UriBuilder
    {
        if (‪$addQueryStringMethod === 'POST') {
            trigger_error('Assigning addQueryStringMethod = POST is not supported anymore since TYPO3 v10.0.', E_USER_WARNING);
            ‪$addQueryStringMethod = null;
        } elseif (‪$addQueryStringMethod === 'GET,POST' || ‪$addQueryStringMethod === 'POST,GET') {
            trigger_error('Assigning addQueryStringMethod = GET,POST or POST,GET is not supported anymore since TYPO3 v10.0 - falling back to GET.', E_USER_WARNING);
            ‪$addQueryStringMethod = 'GET';
        }
        $this->addQueryStringMethod = ‪$addQueryStringMethod;
        return $this;
    }
 
    public function ‪getAddQueryStringMethod(): string
    {
        return ‪$this->addQueryStringMethod;
    }
 
    public function ‪setArgumentsToBeExcludedFromQueryString(array ‪$argumentsToBeExcludedFromQueryString): ‪UriBuilder
    {
        $this->argumentsToBeExcludedFromQueryString = ‪$argumentsToBeExcludedFromQueryString;
        return $this;
    }
 
    public function ‪getArgumentsToBeExcludedFromQueryString(): array
    {
        return ‪$this->argumentsToBeExcludedFromQueryString;
    }
 
    public function ‪setArgumentPrefix(string ‪$argumentPrefix): ‪UriBuilder
    {
        $this->argumentPrefix = ‪$argumentPrefix;
        return $this;
    }
 
    public function ‪getArgumentPrefix(): ?string
    {
        return ‪$this->argumentPrefix;
    }
 
    public function ‪setLinkAccessRestrictedPages(bool ‪$linkAccessRestrictedPages): ‪UriBuilder
    {
        $this->linkAccessRestrictedPages = ‪$linkAccessRestrictedPages;
        return $this;
    }
 
    public function ‪getLinkAccessRestrictedPages(): bool
    {
        return ‪$this->linkAccessRestrictedPages;
    }
 
    public function ‪setTargetPageUid(int ‪$targetPageUid): ‪UriBuilder
    {
        $this->targetPageUid = ‪$targetPageUid;
        return $this;
    }
 
    public function ‪getTargetPageUid(): ?int
    {
        return ‪$this->targetPageUid;
    }
 
    public function ‪setTargetPageType(int ‪$targetPageType): ‪UriBuilder
    {
        $this->targetPageType = ‪$targetPageType;
        return $this;
    }
 
    public function ‪getTargetPageType(): int
    {
        return ‪$this->targetPageType;
    }
 
    public function ‪setNoCache(bool ‪$noCache): ‪UriBuilder
    {
        $this->noCache = ‪$noCache;
        return $this;
    }
 
    public function ‪getNoCache(): bool
    {
        return ‪$this->noCache;
    }
 
    public function ‪setUseCacheHash(): ‪UriBuilder
    {
        trigger_error('Calling UriBuilder->setUseCacheHash() will be removed in TYPO3 v11.0. TYPO3 Core routing is taking care of handling this argument. Simply remove the line to avoid the notice.', E_USER_DEPRECATED);
        return $this;
    }
 
    public function ‪getUseCacheHash(): bool
    {
        trigger_error('Calling UriBuilder->getUseCacheHash() will be removed in TYPO3 v11.0. TYPO3 Core routing is taking care of handling this argument. Simply remove the line to avoid the notice.', E_USER_DEPRECATED);
        return true;
    }
 
    public function ‪getLastArguments(): array
    {
        return ‪$this->lastArguments;
    }
 
    public function ‪reset(): UriBuilder
    {
        $this->arguments = [];
        $this->section = '';
        $this->format = '';
        $this->language = null;
        $this->createAbsoluteUri = false;
        $this->addQueryString = false;
        $this->addQueryStringMethod = '';
        $this->argumentsToBeExcludedFromQueryString = [];
        $this->linkAccessRestrictedPages = false;
        $this->targetPageUid = null;
        $this->targetPageType = 0;
        $this->noCache = false;
        $this->argumentPrefix = null;
        $this->absoluteUriScheme = null;
        /*
         * $this->request MUST NOT be reset here because the request is actually a hard dependency and not part
         * of the internal state of this object.
         * todo: consider making the request a constructor dependency or get rid of it's usage
         */
        return $this;
    }
 
    public function ‪uriFor(
        ?string $actionName = null,
        ?array $controllerArguments = null,
        ?string $controllerName = null,
        ?string $extensionName = null,
        ?string $pluginName = null
    ): string {
        $controllerArguments = $controllerArguments ?? [];
 
        if ($actionName !== null) {
            $controllerArguments['action'] = $actionName;
        }
        if ($controllerName !== null) {
            $controllerArguments['controller'] = $controllerName;
        } else {
            $controllerArguments['controller'] = $this->request->getControllerName();
        }
        if ($extensionName === null) {
            $extensionName = $this->request->getControllerExtensionName();
        }
        if ($pluginName === null && $this->environmentService->isEnvironmentInFrontendMode()) {
            $pluginName = $this->extensionService->getPluginNameByAction($extensionName, $controllerArguments['controller'], $controllerArguments['action'] ?? null);
        }
        if ($pluginName === null) {
            $pluginName = $this->request->getPluginName();
        }
        if ($this->environmentService->isEnvironmentInFrontendMode() && $this->configurationManager->isFeatureEnabled('skipDefaultArguments')) {
            $controllerArguments = $this->‪removeDefaultControllerAndAction($controllerArguments, $extensionName, $pluginName);
        }
        if ($this->targetPageUid === null && $this->environmentService->isEnvironmentInFrontendMode()) {
            $this->targetPageUid = $this->extensionService->getTargetPidByPlugin($extensionName, $pluginName);
        }
        if ($this->format !== '') {
            $controllerArguments['format'] = ‪$this->format;
        }
        if ($this->argumentPrefix !== null) {
            $prefixedControllerArguments = [$this->argumentPrefix => $controllerArguments];
        } else {
            $pluginNamespace = $this->extensionService->getPluginNamespace($extensionName, $pluginName);
            $prefixedControllerArguments = [$pluginNamespace => $controllerArguments];
        }
        ‪ArrayUtility::mergeRecursiveWithOverrule($this->arguments, $prefixedControllerArguments);
        return $this->‪build();
    }
 
    protected function ‪removeDefaultControllerAndAction(array $controllerArguments, string $extensionName, string $pluginName): array
    {
        $defaultControllerName = $this->extensionService->getDefaultControllerNameByPlugin($extensionName, $pluginName);
        if (isset($controllerArguments['action'])) {
            $defaultActionName = $this->extensionService->getDefaultActionNameByPluginAndController($extensionName, $pluginName, $controllerArguments['controller']);
            if ($controllerArguments['action'] === $defaultActionName) {
                unset($controllerArguments['action']);
            }
        }
        if ($controllerArguments['controller'] === $defaultControllerName) {
            unset($controllerArguments['controller']);
        }
        return $controllerArguments;
    }
 
    public function ‪build(): string
    {
        if ($this->environmentService->isEnvironmentInBackendMode()) {
            return $this->‪buildBackendUri();
        }
        return $this->‪buildFrontendUri();
    }
 
    public function ‪buildBackendUri(): string
    {
        ‪$arguments = [];
        if ($this->addQueryString === true) {
            if ($this->addQueryStringMethod === '' || $this->addQueryStringMethod === '0' || $this->addQueryStringMethod === 'GET') {
                ‪$arguments = GeneralUtility::_GET();
            } else {
                // Explode GET vars recursively
                parse_str(GeneralUtility::getIndpEnv('QUERY_STRING'), ‪$arguments);
            }
            foreach ($this->argumentsToBeExcludedFromQueryString as $argumentToBeExcluded) {
                $argumentArrayToBeExcluded = [];
                parse_str($argumentToBeExcluded, $argumentArrayToBeExcluded);
                ‪$arguments = ‪ArrayUtility::arrayDiffKeyRecursive(‪$arguments, $argumentArrayToBeExcluded);
            }
        } else {
            $id = GeneralUtility::_GP('id');
            $route = GeneralUtility::_GP('route');
            if ($id !== null) {
                ‪$arguments['id'] = $id;
            }
            if ($route !== null) {
                ‪$arguments['route'] = $route;
            }
        }
        ‪ArrayUtility::mergeRecursiveWithOverrule(‪$arguments, $this->arguments);
        ‪$arguments = $this->‪convertDomainObjectsToIdentityArrays(‪$arguments);
        $this->lastArguments = ‪$arguments;
        $routeName = ‪$arguments['route'] ?? null;
        unset(‪$arguments['route'], ‪$arguments['token']);
        $backendUriBuilder = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\UriBuilder::class);
        try {
            if ($this->createAbsoluteUri) {
                $uri = (string)$backendUriBuilder->buildUriFromRoutePath($routeName, ‪$arguments, \‪TYPO3\CMS\Backend\Routing\UriBuilder::ABSOLUTE_URL);
            } else {
                $uri = (string)$backendUriBuilder->buildUriFromRoutePath($routeName, ‪$arguments, \‪TYPO3\CMS\Backend\Routing\UriBuilder::ABSOLUTE_PATH);
            }
        } catch (ResourceNotFoundException $e) {
            try {
                if ($this->createAbsoluteUri) {
                    $uri = (string)$backendUriBuilder->buildUriFromRoute($routeName, ‪$arguments, \‪TYPO3\CMS\Backend\Routing\UriBuilder::ABSOLUTE_URL);
                } else {
                    $uri = (string)$backendUriBuilder->buildUriFromRoute($routeName, ‪$arguments, \‪TYPO3\CMS\Backend\Routing\UriBuilder::ABSOLUTE_PATH);
                }
            } catch (RouteNotFoundException $e) {
                $uri = '';
            }
        }
        if ($this->section !== '') {
            $uri .= '#' . ‪$this->section;
        }
        return $uri;
    }
 
    public function ‪buildFrontendUri(): string
    {
        $typolinkConfiguration = $this->‪buildTypolinkConfiguration();
        if ($this->createAbsoluteUri === true) {
            $typolinkConfiguration['forceAbsoluteUrl'] = true;
            if ($this->absoluteUriScheme !== null) {
                $typolinkConfiguration['forceAbsoluteUrl.']['scheme'] = ‪$this->absoluteUriScheme;
            }
        }
        // Other than stated in the doc block, typoLink_URL does not always return a string
        // Thus, we explicitly cast to string here.
        $uri = (string)$this->contentObject->typoLink_URL($typolinkConfiguration);
        return $uri;
    }
 
    protected function ‪buildTypolinkConfiguration(): array
    {
        $typolinkConfiguration = [];
        $typolinkConfiguration['parameter'] = $this->targetPageUid ?? ‪$GLOBALS['TSFE']->id;
        if ($this->targetPageType !== 0) {
            $typolinkConfiguration['parameter'] .= ',' . ‪$this->targetPageType;
        } elseif ($this->format !== '') {
            ‪$targetPageType = $this->extensionService->getTargetPageTypeByFormat($this->request->getControllerExtensionName(), $this->format);
            $typolinkConfiguration['parameter'] .= ',' . ‪$targetPageType;
        }
        if (!empty($this->arguments)) {
            ‪$arguments = $this->‪convertDomainObjectsToIdentityArrays($this->arguments);
            $this->lastArguments = ‪$arguments;
            $typolinkConfiguration['additionalParams'] = ‪HttpUtility::buildQueryString(‪$arguments, '&');
        }
        if ($this->addQueryString === true) {
            $typolinkConfiguration['addQueryString'] = 1;
            if (!empty($this->argumentsToBeExcludedFromQueryString)) {
                $typolinkConfiguration['addQueryString.'] = [
                    'exclude' => implode(',', $this->argumentsToBeExcludedFromQueryString)
                ];
            }
            if ($this->addQueryStringMethod !== '') {
                $typolinkConfiguration['addQueryString.']['method'] = ‪$this->addQueryStringMethod;
            }
        }
        if ($this->language !== null) {
            $typolinkConfiguration['language'] = ‪$this->language;
        }
 
        if ($this->noCache === true) {
            $typolinkConfiguration['no_cache'] = 1;
        }
        if ($this->section !== '') {
            $typolinkConfiguration['section'] = ‪$this->section;
        }
        if ($this->linkAccessRestrictedPages === true) {
            $typolinkConfiguration['linkAccessRestrictedPages'] = 1;
        }
        return $typolinkConfiguration;
    }
 
    protected function ‪convertDomainObjectsToIdentityArrays(array ‪$arguments): array
    {
        foreach (‪$arguments as $argumentKey => $argumentValue) {
            // if we have a LazyLoadingProxy here, make sure to get the real instance for further processing
            if ($argumentValue instanceof LazyLoadingProxy) {
                $argumentValue = $argumentValue->_loadRealInstance();
                // also update the value in the arguments array, because the lazyLoaded object could be
                // hidden and thus the $argumentValue would be NULL.
                ‪$arguments[$argumentKey] = $argumentValue;
            }
            if ($argumentValue instanceof \Iterator) {
                $argumentValue = $this->‪convertIteratorToArray($argumentValue);
            }
            if ($argumentValue instanceof ‪AbstractDomainObject) {
                if ($argumentValue->getUid() !== null) {
                    ‪$arguments[$argumentKey] = $argumentValue->getUid();
                } elseif ($argumentValue instanceof AbstractValueObject) {
                    ‪$arguments[$argumentKey] = $this->‪convertTransientObjectToArray($argumentValue);
                } else {
                    throw new InvalidArgumentValueException('Could not serialize Domain Object ' . get_class($argumentValue) . '. It is neither an Entity with identity properties set, nor a Value Object.', 1260881688);
                }
            } elseif (is_array($argumentValue)) {
                ‪$arguments[$argumentKey] = $this->‪convertDomainObjectsToIdentityArrays($argumentValue);
            }
        }
        return ‪$arguments;
    }
 
    protected function ‪convertIteratorToArray(\Iterator $iterator): array
    {
        if (method_exists($iterator, 'toArray')) {
            $array = $iterator->toArray();
        } else {
            $array = iterator_to_array($iterator);
        }
        return $array;
    }
 
    public function ‪convertTransientObjectToArray(AbstractDomainObject $object): array
    {
        $result = [];
        foreach ($object->_getProperties() as $propertyName => $propertyValue) {
            if ($propertyValue instanceof \Iterator) {
                $propertyValue = $this->‪convertIteratorToArray($propertyValue);
            }
            if ($propertyValue instanceof AbstractDomainObject) {
                if ($propertyValue->getUid() !== null) {
                    $result[$propertyName] = $propertyValue->getUid();
                } else {
                    $result[$propertyName] = $this->‪convertTransientObjectToArray($propertyValue);
                }
            } elseif (is_array($propertyValue)) {
                $result[$propertyName] = $this->‪convertDomainObjectsToIdentityArrays($propertyValue);
            } else {
                $result[$propertyName] = $propertyValue;
            }
        }
        return $result;
    }
}