AbstractConfigurationManager.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\Configuration;
 
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\TypoScript\TypoScriptService;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Service\EnvironmentService;
use ‪TYPO3\CMS\Extbase\Utility\FrontendSimulatorUtility;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
 
abstract class ‪AbstractConfigurationManager implements ‪SingletonInterface
{
    const ‪DEFAULT_BACKEND_STORAGE_PID = 0;
 
    protected ‪$configuration = [];
 
    protected ‪$contentObject;
 
    protected ‪$objectManager;
 
    protected ‪$typoScriptService;
 
    protected ‪$extensionName;
 
    protected ‪$pluginName;
 
    protected ‪$configurationCache = [];
 
    protected ‪$environmentService;
 
    public function ‪__construct(
        ‪ObjectManagerInterface ‪$objectManager,
        ‪TypoScriptService ‪$typoScriptService,
        ‪EnvironmentService ‪$environmentService
    ) {
        $this->objectManager = ‪$objectManager;
        $this->typoScriptService = ‪$typoScriptService;
        $this->environmentService = ‪$environmentService;
    }
 
    public function ‪setContentObject(‪ContentObjectRenderer ‪$contentObject): void
    {
        $this->contentObject = ‪$contentObject;
    }
 
    public function ‪getContentObject(): ?‪ContentObjectRenderer
    {
        return ‪$this->contentObject;
    }
 
    public function ‪setConfiguration(array ‪$configuration = []): void
    {
        // reset 1st level cache
        $this->configurationCache = [];
        $this->extensionName = ‪$configuration['extensionName'] ?? null;
        $this->pluginName = ‪$configuration['pluginName'] ?? null;
        $this->configuration = $this->typoScriptService->convertTypoScriptArrayToPlainArray(‪$configuration);
    }
 
    public function ‪getConfiguration(?string ‪$extensionName = null, ?string ‪$pluginName = null): array
    {
        // 1st level cache
        $configurationCacheKey = strtolower((‪$extensionName ?: $this->extensionName) . '_' . (‪$pluginName ?: $this->pluginName));
        if (isset($this->configurationCache[$configurationCacheKey])) {
            return $this->configurationCache[$configurationCacheKey];
        }
        $frameworkConfiguration = $this->‪getExtbaseConfiguration();
        if (!isset($frameworkConfiguration['persistence']['storagePid'])) {
            $frameworkConfiguration['persistence']['storagePid'] = $this->‪getDefaultBackendStoragePid();
        }
        // only merge $this->configuration and override controller configuration when retrieving configuration of the current plugin
        if ($extensionName === null || ‪$extensionName === $this->extensionName && ‪$pluginName === $this->pluginName) {
            $pluginConfiguration = $this->‪getPluginConfiguration((string)$this->extensionName, (string)$this->pluginName);
            ‪ArrayUtility::mergeRecursiveWithOverrule($pluginConfiguration, $this->configuration);
            $pluginConfiguration['controllerConfiguration'] = $this->‪getControllerConfiguration((string)$this->extensionName, (string)$this->pluginName);
            if (isset($this->configuration['switchableControllerActions'])) {
                $this->‪overrideControllerConfigurationWithSwitchableControllerActions($pluginConfiguration, $this->configuration['switchableControllerActions']);
            }
        } else {
            $pluginConfiguration = $this->‪getPluginConfiguration((string)$extensionName, (string)‪$pluginName);
            $pluginConfiguration['controllerConfiguration'] = $this->‪getControllerConfiguration((string)$extensionName, (string)‪$pluginName);
        }
        ‪ArrayUtility::mergeRecursiveWithOverrule($frameworkConfiguration, $pluginConfiguration);
        // only load context specific configuration when retrieving configuration of the current plugin
        if (‪$extensionName === null || ‪$extensionName === $this->extensionName && ‪$pluginName === $this->pluginName) {
            $frameworkConfiguration = $this->‪getContextSpecificFrameworkConfiguration($frameworkConfiguration);
        }
 
        if (!empty($frameworkConfiguration['persistence']['storagePid'])) {
            if (is_array($frameworkConfiguration['persistence']['storagePid'])) {
                // We simulate the frontend to enable the use of cObjects in
                // stdWrap. Than we convert the configuration to normal TypoScript
                // and apply the stdWrap to the storagePid
                if (!$this->environmentService->isEnvironmentInFrontendMode()) {
                    ‪FrontendSimulatorUtility::simulateFrontendEnvironment($this->‪getContentObject());
                }
                $conf = $this->typoScriptService->convertPlainArrayToTypoScriptArray($frameworkConfiguration['persistence']);
                $frameworkConfiguration['persistence']['storagePid'] = ‪$GLOBALS['TSFE']->cObj->stdWrap($conf['storagePid'], $conf['storagePid.']);
                if (!$this->environmentService->isEnvironmentInFrontendMode()) {
                    ‪FrontendSimulatorUtility::resetFrontendEnvironment();
                }
            }
 
            if (!empty($frameworkConfiguration['persistence']['recursive'])) {
                // All implementations of getTreeList allow to pass the ids negative to include them into the result
                // otherwise only childpages are returned
                $storagePids = ‪GeneralUtility::intExplode(',', $frameworkConfiguration['persistence']['storagePid']);
                array_walk($storagePids, function (&$storagePid) {
                    if ($storagePid > 0) {
                        $storagePid = -$storagePid;
                    }
                });
                $storagePids = $this->‪getRecursiveStoragePids(
                    $storagePids,
                    (int)$frameworkConfiguration['persistence']['recursive']
                );
 
                $frameworkConfiguration['persistence']['storagePid'] = implode(',', $storagePids);
            }
        }
        // 1st level cache
        $this->configurationCache[$configurationCacheKey] = $frameworkConfiguration;
        return $frameworkConfiguration;
    }
 
    protected function ‪getExtbaseConfiguration(): array
    {
        $setup = $this->‪getTypoScriptSetup();
        $extbaseConfiguration = [];
        if (isset($setup['config.']['tx_extbase.'])) {
            $extbaseConfiguration = $this->typoScriptService->convertTypoScriptArrayToPlainArray($setup['config.']['tx_extbase.']);
        }
        return $extbaseConfiguration;
    }
 
    public function ‪getDefaultBackendStoragePid(): int
    {
        return ‪self::DEFAULT_BACKEND_STORAGE_PID;
    }
 
    protected function ‪overrideControllerConfigurationWithSwitchableControllerActions(array &$frameworkConfiguration, array $switchableControllerActions): void
    {
        trigger_error(
            sprintf(
                'Plugin "%s" of extension "%s" uses switchable controller actions which has been marked as deprecated as of version TYPO3 10 and will be removed in one of the next major versions of TYPO3, probably version 11.0 or 12.0',
                $frameworkConfiguration['pluginName'],
                $frameworkConfiguration['extensionName']
            ),
            E_USER_DEPRECATED
        );
 
        $controllerAliasToClass = [];
        foreach ($frameworkConfiguration['controllerConfiguration'] as $controllerClass => $controllerConfiguration) {
            $controllerAliasToClass[$controllerConfiguration['alias']] = $controllerClass;
        }
 
        $overriddenControllerConfiguration = [];
        foreach ($switchableControllerActions as $controllerName => $actions) {
            // Trim leading backslashes if a fully qualified controller class name with leading slashes is used.
            $controllerName = ltrim($controllerName, '\\');
 
            $controllerIsConfigured = false;
            if (array_key_exists($controllerName, $controllerAliasToClass)) {
                /*
                 * If $controllerName can be found in the keys of $controllerAliasToClass, $controllerName is a
                 * controller alias and not a FQCN. In this case switchable controller actions have been defined with
                 * controller aliases as such:
                 *
                 * tt_content.list.20.indexedsearch_pi2.switchableControllerActions {
                 *     Search {
                 *         0 = search
                 *     }
                 * }
                 */
                $controllerIsConfigured = true;
                $controllerClassName = $controllerAliasToClass[$controllerName];
                $controllerAlias = $controllerName;
            }
 
            if (in_array($controllerName, $controllerAliasToClass, true)) {
                /*
                 * If $controllerName can be found in the values of $controllerAliasToClass, $controllerName is a
                 * FQCN. In this case switchable controller actions have been defined with fully qualified controller
                 * class names as such:
                 *
                 * tt_content.list.20.indexedsearch_pi2.switchableControllerActions {
                 *     TYPO3\CMS\IndexedSearch\Controller\SearchController {
                 *         0 = search
                 *     }
                 * }
                 */
                $controllerIsConfigured = true;
                $controllerClassName = $controllerName;
                $controllerAlias = $frameworkConfiguration['controllerConfiguration'][$controllerName]['alias'];
            }
 
            if (!$controllerIsConfigured) {
                continue;
            }
 
            if (!isset($overriddenControllerConfiguration[$controllerClassName])) {
                $overriddenControllerConfiguration[$controllerClassName] = [
                    'alias' => $controllerAlias,
                    'className' => $controllerClassName,
                    'actions' => []
                ];
            }
            $overriddenControllerConfiguration[$controllerClassName]['actions'] = array_merge(
                $overriddenControllerConfiguration[$controllerClassName]['actions'],
                $actions
            );
            $nonCacheableActions = $frameworkConfiguration['controllerConfiguration'][$controllerClassName]['nonCacheableActions'] ?? null;
            if (!is_array($nonCacheableActions)) {
                // There are no non-cacheable actions, thus we can directly continue
                // with the next controller name.
                continue;
            }
            $overriddenNonCacheableActions = array_intersect($nonCacheableActions, $actions);
            if (!empty($overriddenNonCacheableActions)) {
                $overriddenControllerConfiguration[$controllerClassName]['nonCacheableActions'] = $overriddenNonCacheableActions;
            }
        }
        $frameworkConfiguration['controllerConfiguration'] = $overriddenControllerConfiguration;
    }
 
    abstract protected function ‪getContextSpecificFrameworkConfiguration(array $frameworkConfiguration): array;
 
    abstract public function ‪getTypoScriptSetup(): array;
 
    abstract protected function ‪getPluginConfiguration(string ‪$extensionName, string ‪$pluginName = null): array;
 
    abstract protected function ‪getControllerConfiguration(string ‪$extensionName, string ‪$pluginName): array;
 
    abstract protected function ‪getRecursiveStoragePids(array $storagePids, int $recursionDepth = 0): array;
}