9.5/_abstract_configuration_manager_8php_source.html

<?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);

}