UriBuilder.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Mvc\Web\Routing;

/*
 * 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!
 */

use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Mvc\Request;
use TYPO3\CMS\Extbase\Mvc\Web\Request as WebRequest;

class UriBuilder
{
    protected $configurationManager;

    protected $extensionService;

    protected $contentObject;

    protected $request;

    protected $arguments = [];

    protected $lastArguments = [];

    protected $section = '';

    protected $createAbsoluteUri = false;

    protected $absoluteUriScheme = null;

    protected $addQueryString = false;

    protected $addQueryStringMethod = null;

    protected $argumentsToBeExcludedFromQueryString = [];

    protected $linkAccessRestrictedPages = false;

    protected $targetPageUid = null;

    protected $targetPageType = 0;

    protected $noCache = false;

    protected $useCacheHash = true;

    protected $format = '';

    protected $argumentPrefix = null;

    protected $environmentService;

    public function injectConfigurationManager(\TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface $configurationManager)
    {
        $this->configurationManager = $configurationManager;
    }

    public function injectExtensionService(\TYPO3\CMS\Extbase\Service\ExtensionService $extensionService)
    {
        $this->extensionService = $extensionService;
    }

    public function injectEnvironmentService(\TYPO3\CMS\Extbase\Service\EnvironmentService $environmentService)
    {
        $this->environmentService = $environmentService;
    }

    public function initializeObject()
    {
        $this->contentObject = $this->configurationManager->getContentObject();
    }

    public function setRequest(Request $request)
    {
        $this->request = $request;
        return $this;
    }

    public function getRequest()
    {
        return $this->request;
    }

    public function setArguments(array $arguments)
    {
        $this->arguments = $arguments;
        return $this;
    }

    public function getArguments()
    {
        return $this->arguments;
    }

    public function setSection($section)
    {
        $this->section = $section;
        return $this;
    }

    public function getSection()
    {
        return $this->section;
    }

    public function setFormat($format)
    {
        $this->format = $format;
        return $this;
    }

    public function getFormat()
    {
        return $this->format;
    }

    public function setCreateAbsoluteUri($createAbsoluteUri)
    {
        $this->createAbsoluteUri = $createAbsoluteUri;
        return $this;
    }

    public function getCreateAbsoluteUri()
    {
        return $this->createAbsoluteUri;
    }

    public function getAbsoluteUriScheme()
    {
        return $this->absoluteUriScheme;
    }

    public function setAbsoluteUriScheme($absoluteUriScheme)
    {
        $this->absoluteUriScheme = $absoluteUriScheme;
        return $this;
    }

    public function setAddQueryString($addQueryString)
    {
        $this->addQueryString = (bool)$addQueryString;
        return $this;
    }

    public function getAddQueryString()
    {
        return $this->addQueryString;
    }

    public function setAddQueryStringMethod($addQueryStringMethod)
    {
        $this->addQueryStringMethod = $addQueryStringMethod;
        return $this;
    }

    public function getAddQueryStringMethod()
    {
        return (string)$this->addQueryStringMethod;
    }

    public function setArgumentsToBeExcludedFromQueryString(array $argumentsToBeExcludedFromQueryString)
    {
        $this->argumentsToBeExcludedFromQueryString = $argumentsToBeExcludedFromQueryString;
        return $this;
    }

    public function getArgumentsToBeExcludedFromQueryString()
    {
        return $this->argumentsToBeExcludedFromQueryString;
    }

    public function setArgumentPrefix($argumentPrefix)
    {
        $this->argumentPrefix = (string)$argumentPrefix;
        return $this;
    }

    public function getArgumentPrefix()
    {
        return $this->argumentPrefix;
    }

    public function setLinkAccessRestrictedPages($linkAccessRestrictedPages)
    {
        $this->linkAccessRestrictedPages = (bool)$linkAccessRestrictedPages;
        return $this;
    }

    public function getLinkAccessRestrictedPages()
    {
        return $this->linkAccessRestrictedPages;
    }

    public function setTargetPageUid($targetPageUid)
    {
        $this->targetPageUid = $targetPageUid;
        return $this;
    }

    public function getTargetPageUid()
    {
        return $this->targetPageUid;
    }

    public function setTargetPageType($targetPageType)
    {
        $this->targetPageType = (int)$targetPageType;
        return $this;
    }

    public function getTargetPageType()
    {
        return $this->targetPageType;
    }

    public function setNoCache($noCache)
    {
        $this->noCache = (bool)$noCache;
        return $this;
    }

    public function getNoCache()
    {
        return $this->noCache;
    }

    public function setUseCacheHash($useCacheHash)
    {
        $this->useCacheHash = (bool)$useCacheHash;
        return $this;
    }

    public function getUseCacheHash()
    {
        return $this->useCacheHash;
    }

    public function getLastArguments()
    {
        return $this->lastArguments;
    }

    public function reset()
    {
        $this->arguments = [];
        $this->section = '';
        $this->format = '';
        $this->createAbsoluteUri = false;
        $this->addQueryString = false;
        $this->addQueryStringMethod = null;
        $this->argumentsToBeExcludedFromQueryString = [];
        $this->linkAccessRestrictedPages = false;
        $this->targetPageUid = null;
        $this->targetPageType = 0;
        $this->noCache = false;
        $this->useCacheHash = true;
        $this->argumentPrefix = null;
        return $this;
    }

    public function uriFor($actionName = null, $controllerArguments = [], $controllerName = null, $extensionName = null, $pluginName = null)
    {
        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']);
        }
        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, $extensionName, $pluginName)
    {
        $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()
    {
        if ($this->environmentService->isEnvironmentInBackendMode()) {
            return $this->buildBackendUri();
        }
        return $this->buildFrontendUri();
    }

    public function buildBackendUri()
    {
        $arguments = [];
        if ($this->addQueryString === true) {
            if ($this->addQueryStringMethod) {
                switch ($this->addQueryStringMethod) {
                    case 'GET':
                        $arguments = GeneralUtility::_GET();
                        break;
                    case 'POST':
                        $arguments = GeneralUtility::_POST();
                        break;
                    case 'GET,POST':
                        $arguments = array_replace_recursive(GeneralUtility::_GET(), GeneralUtility::_POST());
                        break;
                    case 'POST,GET':
                        $arguments = array_replace_recursive(GeneralUtility::_POST(), GeneralUtility::_GET());
                        break;
                    default:
                        $arguments = GeneralUtility::explodeUrl2Array(GeneralUtility::getIndpEnv('QUERY_STRING'), true);
                }
            } else {
                $arguments = GeneralUtility::_GET();
            }
            foreach ($this->argumentsToBeExcludedFromQueryString as $argumentToBeExcluded) {
                $argumentToBeExcluded = GeneralUtility::explodeUrl2Array($argumentToBeExcluded, true);
                $arguments = ArrayUtility::arrayDiffAssocRecursive($arguments, $argumentToBeExcluded);
            }
        } else {
            $id = GeneralUtility::_GP('id');
            $module = GeneralUtility::_GP('M');
            if ($id !== null) {
                $arguments['id'] = $id;
            }
            if ($module !== null) {
                $arguments['M'] = $module;
            }
        }
        ArrayUtility::mergeRecursiveWithOverrule($arguments, $this->arguments);
        $arguments = $this->convertDomainObjectsToIdentityArrays($arguments);
        $this->lastArguments = $arguments;
        $moduleName = $arguments['M'];
        unset($arguments['M'], $arguments['moduleToken']);
        $backendUriBuilder = GeneralUtility::makeInstance(\TYPO3\CMS\Backend\Routing\UriBuilder::class);
        if ($this->request instanceof WebRequest && $this->createAbsoluteUri) {
            $uri = (string)$backendUriBuilder->buildUriFromModule($moduleName, $arguments, \TYPO3\CMS\Backend\Routing\UriBuilder::ABSOLUTE_URL);
        } else {
            $uri = (string)$backendUriBuilder->buildUriFromModule($moduleName, $arguments);
        }
        if ($this->section !== '') {
            $uri .= '#' . $this->section;
        }
        return $uri;
    }

    public function buildFrontendUri()
    {
        $typolinkConfiguration = $this->buildTypolinkConfiguration();
        if ($this->createAbsoluteUri === true) {
            $typolinkConfiguration['forceAbsoluteUrl'] = true;
            if ($this->absoluteUriScheme !== null) {
                $typolinkConfiguration['forceAbsoluteUrl.']['scheme'] = $this->absoluteUriScheme;
            }
        }
        $uri = $this->contentObject->typoLink_URL($typolinkConfiguration);
        return $uri;
    }

    protected function buildTypolinkConfiguration()
    {
        $typolinkConfiguration = [];
        $typolinkConfiguration['parameter'] = $this->targetPageUid !== null ? $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'] = GeneralUtility::implodeArrayForUrl(null, $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->noCache === true) {
            $typolinkConfiguration['no_cache'] = 1;
        } elseif ($this->useCacheHash) {
            $typolinkConfiguration['useCacheHash'] = 1;
        }
        if ($this->section !== '') {
            $typolinkConfiguration['section'] = $this->section;
        }
        if ($this->linkAccessRestrictedPages === true) {
            $typolinkConfiguration['linkAccessRestrictedPages'] = 1;
        }
        return $typolinkConfiguration;
    }

    protected function convertDomainObjectsToIdentityArrays(array $arguments)
    {
        foreach ($arguments as $argumentKey => $argumentValue) {
            // if we have a LazyLoadingProxy here, make sure to get the real instance for further processing
            if ($argumentValue instanceof \TYPO3\CMS\Extbase\Persistence\Generic\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 \TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject) {
                if ($argumentValue->getUid() !== null) {
                    $arguments[$argumentKey] = $argumentValue->getUid();
                } elseif ($argumentValue instanceof \TYPO3\CMS\Extbase\DomainObject\AbstractValueObject) {
                    $arguments[$argumentKey] = $this->convertTransientObjectToArray($argumentValue);
                } else {
                    throw new \TYPO3\CMS\Extbase\Mvc\Exception\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)
    {
        if (method_exists($iterator, 'toArray')) {
            $array = $iterator->toArray();
        } else {
            $array = iterator_to_array($iterator);
        }
        return $array;
    }

    public function convertTransientObjectToArray(\TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject $object)
    {
        $result = [];
        foreach ($object->_getProperties() as $propertyName => $propertyValue) {
            if ($propertyValue instanceof \Iterator) {
                $propertyValue = $this->convertIteratorToArray($propertyValue);
            }
            if ($propertyValue instanceof \TYPO3\CMS\Extbase\DomainObject\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;
    }
}