AbstractConfigurationManager.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Extbase\Configuration;
 
/*
 * 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!
 */
 
abstract class ‪AbstractConfigurationManager implements ‪\TYPO3\CMS\Core\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 ‪injectObjectManager(\‪TYPO3\CMS\‪Extbase\Object\ObjectManagerInterface ‪$objectManager)
    {
        $this->objectManager = ‪$objectManager;
    }
 
    public function ‪injectTypoScriptService(\‪TYPO3\CMS\Core\TypoScript\TypoScriptService ‪$typoScriptService)
    {
        $this->typoScriptService = ‪$typoScriptService;
    }
 
    public function ‪injectEnvironmentService(\‪TYPO3\CMS\‪Extbase\Service\EnvironmentService ‪$environmentService)
    {
        $this->environmentService = ‪$environmentService;
    }
 
    public function ‪setContentObject(\‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer ‪$contentObject = null)
    {
        $this->contentObject = ‪$contentObject;
    }
 
    public function ‪getContentObject()
    {
        if ($this->contentObject !== null) {
            return ‪$this->contentObject;
        }
        return null;
    }
 
    public function ‪setConfiguration(array ‪$configuration = [])
    {
        // 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(‪$extensionName = null, ‪$pluginName = null)
    {
        // 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 switchableControllerActions when retrieving configuration of the current plugin
        if (‪$extensionName === null || ‪$extensionName === $this->extensionName && ‪$pluginName === $this->pluginName) {
            $pluginConfiguration = $this->‪getPluginConfiguration($this->extensionName, $this->pluginName);
            ‪\TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($pluginConfiguration, $this->configuration);
            $pluginConfiguration['controllerConfiguration'] = $this->‪getSwitchableControllerActions($this->extensionName, $this->pluginName);
            if (isset($this->configuration['switchableControllerActions'])) {
                $this->‪overrideSwitchableControllerActions($pluginConfiguration, $this->configuration['switchableControllerActions']);
            }
        } else {
            $pluginConfiguration = $this->‪getPluginConfiguration(‪$extensionName, ‪$pluginName);
            $pluginConfiguration['controllerConfiguration'] = $this->‪getSwitchableControllerActions(‪$extensionName, ‪$pluginName);
        }
        ‪\TYPO3\CMS\Core\Utility\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()) {
                    ‪\TYPO3\CMS\Extbase\Utility\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()) {
                    ‪\TYPO3\CMS\Extbase\Utility\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 = \TYPO3\CMS\Core\Utility\GeneralUtility::intExplode(',', $frameworkConfiguration['persistence']['storagePid']);
                array_walk($storagePids, function (&$storagePid) {
                    if ($storagePid > 0) {
                        $storagePid = -$storagePid;
                    }
                });
                $frameworkConfiguration['persistence']['storagePid'] = $this->‪getRecursiveStoragePids(
                    implode(',', $storagePids),
                    (int)$frameworkConfiguration['persistence']['recursive']
                );
            }
        }
        // 1st level cache
        $this->configurationCache[$configurationCacheKey] = $frameworkConfiguration;
        return $frameworkConfiguration;
    }
 
    protected function ‪getExtbaseConfiguration()
    {
        $setup = $this->‪getTypoScriptSetup();
        $extbaseConfiguration = [];
        if (isset($setup['config.']['tx_extbase.'])) {
            $extbaseConfiguration = $this->typoScriptService->convertTypoScriptArrayToPlainArray($setup['config.']['tx_extbase.']);
        }
        return $extbaseConfiguration;
    }
 
    public function ‪getDefaultBackendStoragePid()
    {
        return ‪self::DEFAULT_BACKEND_STORAGE_PID;
    }
 
    protected function ‪overrideSwitchableControllerActions(array &$frameworkConfiguration, array $switchableControllerActions)
    {
        $overriddenSwitchableControllerActions = [];
        foreach ($switchableControllerActions as $controllerName => $actions) {
            if (!isset($frameworkConfiguration['controllerConfiguration'][$controllerName])) {
                continue;
            }
            $overriddenSwitchableControllerActions[$controllerName] = ['actions' => $actions];
            $nonCacheableActions = $frameworkConfiguration['controllerConfiguration'][$controllerName]['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)) {
                $overriddenSwitchableControllerActions[$controllerName]['nonCacheableActions'] = $overriddenNonCacheableActions;
            }
        }
        $frameworkConfiguration['controllerConfiguration'] = $overriddenSwitchableControllerActions;
    }
 
    abstract protected function ‪getContextSpecificFrameworkConfiguration(array $frameworkConfiguration);
 
    abstract public function ‪getTypoScriptSetup();
 
    abstract protected function ‪getPluginConfiguration(‪$extensionName, ‪$pluginName = null);
 
    abstract protected function ‪getSwitchableControllerActions(‪$extensionName, ‪$pluginName);
 
    abstract protected function ‪getRecursiveStoragePids($storagePid, $recursionDepth = 0);
}