ExtensionManagementUtility.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Utility;

class ExtensionManagementUtility {

    static protected $extensionKeyMap;

    static protected $extTablesWasReadFromCacheOnce = FALSE;

    static protected $packageManager;

    static public function setPackageManager(\TYPO3\CMS\Core\Package\PackageManager $packageManager) {
        static::$packageManager = $packageManager;
    }

    static protected $cacheManager;

    static protected function getCacheManager() {
        if (static::$cacheManager === NULL) {
            static::$cacheManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager');
        }
        return static::$cacheManager;
    }

    static protected $signalSlotDispatcher;

    static protected function getSignalSlotDispatcher() {
        if (static::$signalSlotDispatcher === NULL) {
            static::$signalSlotDispatcher = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher');
        }
        return static::$signalSlotDispatcher;
    }

    /**************************************
     *
     * PATHS and other evaluation
     *
     ***************************************/
    static public function isLoaded($key, $exitOnError = FALSE) {
        $isLoaded = static::$packageManager->isPackageActive($key);
        if ($exitOnError && !$isLoaded) {
            throw new \BadFunctionCallException('TYPO3 Fatal Error: Extension "' . $key . '" is not loaded!', 1270853910);
        }
        return $isLoaded;
    }

    static public function extPath($key, $script = '') {
        if (!static::$packageManager->isPackageActive($key)) {
            throw new \BadFunctionCallException('TYPO3 Fatal Error: Extension key "' . $key . '" is NOT loaded!', 1365429656);
        }
        return static::$packageManager->getPackage($key)->getPackagePath() . $script;
    }

    static public function extRelPath($key) {
        if (!static::$packageManager->isPackageActive($key)) {
            throw new \BadFunctionCallException('TYPO3 Fatal Error: Extension key "' . $key . '" is NOT loaded!', 1365429673);
        }
        $relativePathToSiteRoot = self::siteRelPath($key);
        if (substr($relativePathToSiteRoot, 0, $typo3MainDirLength = strlen(TYPO3_mainDir)) === TYPO3_mainDir) {
            $relativePathToSiteRoot = substr($relativePathToSiteRoot, $typo3MainDirLength);
        } else {
            $relativePathToSiteRoot = '../' . $relativePathToSiteRoot;
        }
        return $relativePathToSiteRoot;
    }

    static public function siteRelPath($key) {
        return \TYPO3\CMS\Core\Utility\PathUtility::stripPathSitePrefix(self::extPath($key));
    }

    static public function getCN($key) {
        return strpos($key, 'user_') === 0 ? 'user_' . str_replace('_', '', substr($key, 5)) : 'tx_' . str_replace('_', '', $key);
    }

    static public function getExtensionKeyByPrefix($prefix) {
        $result = FALSE;
        // Build map of short keys referencing to real keys:
        if (!isset(self::$extensionKeyMap)) {
            self::$extensionKeyMap = array();
            foreach (static::$packageManager->getActivePackages() as $package) {
                $shortKey = str_replace('_', '', $package->getPackageKey());
                self::$extensionKeyMap[$shortKey] = $package->getPackageKey();
            }
        }
        // Lookup by the given short key:
        $parts = explode('_', $prefix);
        if (isset(self::$extensionKeyMap[$parts[1]])) {
            $result = self::$extensionKeyMap[$parts[1]];
        }
        return $result;
    }

    static public function clearExtensionKeyMap() {
        self::$extensionKeyMap = NULL;
    }

    static public function getExtensionVersion($key) {
        if (!is_string($key) || empty($key)) {
            throw new \InvalidArgumentException('Extension key must be a non-empty string.', 1294586096);
        }
        if (!static::isLoaded($key)) {
            return '';
        }
        $version = static::$packageManager->getPackage($key)->getPackageMetaData()->getVersion();
        if (empty($version)) {
            throw new \TYPO3\CMS\Core\Package\Exception('Version number in composer manifest of package "' . $key . '" is missing or invalid', 1395614959);
        }
        return $version;
    }

    /**************************************
     *
     *   Adding BACKEND features
     *   (related to core features)
     *
     ***************************************/
    static public function addTCAcolumns($table, $columnArray, $addTofeInterface = FALSE) {
        if (is_array($columnArray) && is_array($GLOBALS['TCA'][$table]) && is_array($GLOBALS['TCA'][$table]['columns'])) {
            // Candidate for array_merge() if integer-keys will some day make trouble...
            $GLOBALS['TCA'][$table]['columns'] = array_merge($GLOBALS['TCA'][$table]['columns'], $columnArray);
            if ($addTofeInterface) {
                GeneralUtility::deprecationLog(
                    'Usage of feInterface is no longer part of the TYPO3 CMS Core. Please check EXT:' . $GLOBALS['_EXTKEY'] . '.'
                );
            }
        }
    }

    static public function addToAllTCAtypes($table, $newFieldsString, $typeList = '', $position = '') {
        $newFieldsString = trim($newFieldsString);
        if ($newFieldsString === '' || !is_array($GLOBALS['TCA'][$table]['types'])) {
            return;
        }
        list($positionIdentifier, $entityName) = GeneralUtility::trimExplode(':', $position);
        $palettesChanged = array();

        foreach ($GLOBALS['TCA'][$table]['types'] as $type => &$typeDetails) {
            // skip if we don't want to add the field for this type
            if ($typeList !== '' && !GeneralUtility::inList($typeList, $type)) {
                continue;
            }
            // skip if fields were already added
            if (!isset($typeDetails['showitem'])) {
                continue;
            }

            $fieldArray = GeneralUtility::trimExplode(',', $typeDetails['showitem'], TRUE);
            if (in_array($newFieldsString, $fieldArray, TRUE)) {
                continue;
            }

            $fieldExists = FALSE;
            $newPosition = '';
            if (is_array($GLOBALS['TCA'][$table]['palettes'])) {
                // Get the palette names used in current showitem
                $paletteCount = preg_match_all('/(?:^|,)                    # Line start or a comma
                    (?:
                        \\s*\\-\\-palette\\-\\-;[^;]*;([^,$]*)|              # --palette--;label;paletteName
                        \\s*\\b[^;,]+\\b(?:;[^;]*;([^;,]+);?[^;,]*;?)?[^,]*  # field;label;paletteName[;options[;colors]]
                    )/x', $typeDetails['showitem'], $paletteMatches);
                if ($paletteCount > 0) {
                    $paletteNames = array_filter(array_merge($paletteMatches[1], $paletteMatches[2]));
                    if (!empty($paletteNames)) {
                        foreach ($paletteNames as $paletteName) {
                            $palette = $GLOBALS['TCA'][$table]['palettes'][$paletteName];
                            switch ($positionIdentifier) {
                                case 'after':
                                case 'before':
                                    if (preg_match('/\\b' . $entityName . '\\b/', $palette['showitem']) > 0) {
                                        $newPosition = $positionIdentifier . ':--palette--;;' . $paletteName;
                                    }
                                    break;
                                case 'replace':
                                    // check if fields have been added to palette before
                                    if (isset($palettesChanged[$paletteName])) {
                                        $fieldExists = TRUE;
                                        continue;
                                    }
                                    if (preg_match('/\\b' . $entityName . '\\b/', $palette['showitem']) > 0) {
                                        self::addFieldsToPalette($table, $paletteName, $newFieldsString, $position);
                                        // Memorize that we already changed this palette, in case other types also use it
                                        $palettesChanged[$paletteName] = TRUE;
                                        $fieldExists = TRUE;
                                        continue;
                                    }
                                    break;
                                default:
                                    // Intentionally left blank
                            }
                        }
                    }
                }
            }
            if ($fieldExists === FALSE) {
                $typeDetails['showitem'] = self::executePositionedStringInsertion(
                    $typeDetails['showitem'],
                    $newFieldsString,
                    $newPosition !== '' ? $newPosition : $position
                );
            }
        }
        unset($typeDetails);
    }

    static public function addFieldsToAllPalettesOfField($table, $field, $addFields, $insertionPosition = '') {
        $generatedPalette = '';
        $processedPalettes = array();
        if (isset($GLOBALS['TCA'][$table]['columns'][$field])) {
            $types = &$GLOBALS['TCA'][$table]['types'];
            if (is_array($types)) {
                // Iterate through all types and search for the field that defines the palette to be extended:
                foreach ($types as $type => $_) {
                    $items = self::explodeItemList($types[$type]['showitem']);
                    if (isset($items[$field])) {
                        // If the field already has a palette, extend it:
                        if ($items[$field]['details']['palette']) {
                            $palette = $items[$field]['details']['palette'];
                            if (!isset($processedPalettes[$palette])) {
                                self::addFieldsToPalette($table, $palette, $addFields, $insertionPosition);
                                $processedPalettes[$palette] = TRUE;
                            }
                        } else {
                            if ($generatedPalette) {
                                $palette = $generatedPalette;
                            } else {
                                $palette = ($generatedPalette = 'generatedFor-' . $field);
                                self::addFieldsToPalette($table, $palette, $addFields, $insertionPosition);
                            }
                            $items[$field]['details']['palette'] = $palette;
                            $types[$type]['showitem'] = self::generateItemList($items);
                        }
                    }
                }
            }
        }
    }

    static public function addFieldsToPalette($table, $palette, $addFields, $insertionPosition = '') {
        if (isset($GLOBALS['TCA'][$table])) {
            $paletteData = &$GLOBALS['TCA'][$table]['palettes'][$palette];
            // If palette already exists, merge the data:
            if (is_array($paletteData)) {
                $paletteData['showitem'] = self::executePositionedStringInsertion($paletteData['showitem'], $addFields, $insertionPosition);
            } else {
                $paletteData['showitem'] = self::removeDuplicatesForInsertion($addFields);
            }
        }
    }

    static public function addTcaSelectItem($table, $field, array $item, $relativeToField = '', $relativePosition = '') {
        if (!is_string($table)) {
            throw new \InvalidArgumentException('Given table is of type "' . gettype($table) . '" but a string is expected.', 1303236963);
        }
        if (!is_string($field)) {
            throw new \InvalidArgumentException('Given field is of type "' . gettype($field) . '" but a string is expected.', 1303236964);
        }
        if (!is_string($relativeToField)) {
            throw new \InvalidArgumentException('Given relative field is of type "' . gettype($relativeToField) . '" but a string is expected.', 1303236965);
        }
        if (!is_string($relativePosition)) {
            throw new \InvalidArgumentException('Given relative position is of type "' . gettype($relativePosition) . '" but a string is expected.', 1303236966);
        }
        if ($relativePosition !== '' && $relativePosition !== 'before' && $relativePosition !== 'after' && $relativePosition !== 'replace') {
            throw new \InvalidArgumentException('Relative position must be either empty or one of "before", "after", "replace".', 1303236967);
        }
        if (!is_array($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'])) {
            throw new \RuntimeException('Given select field item list was not found.', 1303237468);
        }
        // Make sure item keys are integers
        $GLOBALS['TCA'][$table]['columns'][$field]['config']['items'] = array_values($GLOBALS['TCA'][$table]['columns'][$field]['config']['items']);
        if (strlen($relativePosition) > 0) {
            // Insert at specified position
            $matchedPosition = \TYPO3\CMS\Core\Utility\ArrayUtility::filterByValueRecursive($relativeToField, $GLOBALS['TCA'][$table]['columns'][$field]['config']['items']);
            if (count($matchedPosition) > 0) {
                $relativeItemKey = key($matchedPosition);
                if ($relativePosition === 'replace') {
                    $GLOBALS['TCA'][$table]['columns'][$field]['config']['items'][$relativeItemKey] = $item;
                } else {
                    if ($relativePosition === 'before') {
                        $offset = $relativeItemKey;
                    } else {
                        $offset = $relativeItemKey + 1;
                    }
                    array_splice($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'], $offset, 0, array(0 => $item));
                }
            } else {
                // Insert at new item at the end of the array if relative position was not found
                $GLOBALS['TCA'][$table]['columns'][$field]['config']['items'][] = $item;
            }
        } else {
            // Insert at new item at the end of the array
            $GLOBALS['TCA'][$table]['columns'][$field]['config']['items'][] = $item;
        }
    }

    static public function getFileFieldTCAConfig($fieldName, array $customSettingOverride = array(), $allowedFileExtensions = '', $disallowedFileExtensions = '') {
        $fileFieldTCAConfig = array(
            'type' => 'inline',
            'foreign_table' => 'sys_file_reference',
            'foreign_field' => 'uid_foreign',
            'foreign_sortby' => 'sorting_foreign',
            'foreign_table_field' => 'tablenames',
            'foreign_match_fields' => array(
                'fieldname' => $fieldName
            ),
            'foreign_label' => 'uid_local',
            'foreign_selector' => 'uid_local',
            'foreign_selector_fieldTcaOverride' => array(
                'config' => array(
                    'appearance' => array(
                        'elementBrowserType' => 'file',
                        'elementBrowserAllowed' => $allowedFileExtensions
                    )
                )
            ),
            'filter' => array(
                array(
                    'userFunc' => 'TYPO3\\CMS\\Core\\Resource\\Filter\\FileExtensionFilter->filterInlineChildren',
                    'parameters' => array(
                        'allowedFileExtensions' => $allowedFileExtensions,
                        'disallowedFileExtensions' => $disallowedFileExtensions
                    )
                )
            ),
            'appearance' => array(
                'useSortable' => TRUE,
                'headerThumbnail' => array(
                    'field' => 'uid_local',
                    'width' => '45',
                    'height' => '45c',
                ),
                'showPossibleLocalizationRecords' => FALSE,
                'showRemovedLocalizationRecords' => FALSE,
                'showSynchronizationLink' => FALSE,
                'showAllLocalizationLink' => FALSE,

                'enabledControls' => array(
                    'info' => TRUE,
                    'new' => FALSE,
                    'dragdrop' => TRUE,
                    'sort' => FALSE,
                    'hide' => TRUE,
                    'delete' => TRUE,
                    'localize' => TRUE,
                ),
            ),
            'behaviour' => array(
                'localizationMode' => 'select',
                'localizeChildrenAtParentLocalization' => TRUE,
            ),
        );
        \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($fileFieldTCAConfig, $customSettingOverride);
        return $fileFieldTCAConfig;
    }

    static public function addFieldsToUserSettings($addFields, $insertionPosition = '') {
        $GLOBALS['TYPO3_USER_SETTINGS']['showitem'] = self::executePositionedStringInsertion($GLOBALS['TYPO3_USER_SETTINGS']['showitem'], $addFields, $insertionPosition);
    }

    static protected function executePositionedStringInsertion($list, $insertionList, $insertionPosition = '') {
        $list = $newList = trim($list, ", \t\n\r\0\x0B");

        list($location, $positionName) = GeneralUtility::trimExplode(':', $insertionPosition);

        if ($location !== 'replace') {
            $insertionList = self::removeDuplicatesForInsertion($insertionList, $list);
        }

        if ($insertionList === '') {
            return $list;
        }
        if ($list === '') {
            return $insertionList;
        }
        if ($insertionPosition === '') {
            return $list . ', ' . $insertionList;
        }

        // The $insertPosition may be a palette: after:--palette--;;title
        // In the $list the palette may contain a LLL string in between the ;;
        // Adjust the regex to match that
        if (strpos($positionName, ';;') !== FALSE) {
            $positionName = str_replace(';;', ';[^;]*;', $positionName);
        }

        $pattern = ('/(^|,\\s*)(' . $positionName . ')(;[^,$]+)?(,|$)/');
        switch ($location) {
            case 'after':
                $newList = preg_replace($pattern, '$1$2$3, ' . $insertionList . '$4', $list);
                break;
            case 'before':
                $newList = preg_replace($pattern, '$1' . $insertionList . ', $2$3$4', $list);
                break;
            case 'replace':
                $newList = preg_replace($pattern, '$1' . $insertionList . '$4', $list);
                break;
            default:
        }

        // When preg_replace did not replace anything; append the $insertionList.
        if ($list === $newList) {
            return $list . ', ' . $insertionList;
        }
        return $newList;
    }

    static protected function removeDuplicatesForInsertion($insertionList, $list = '') {
        $insertionListParts = preg_split('/\\s*,\\s*/', $insertionList);
        $listMatches = array();
        if ($list !== '') {
            preg_match_all('/(?:^|,)\\s*\\b([^;,]+)\\b[^,]*/', $list, $listMatches);
            $listMatches = $listMatches[1];
        }

        $cleanInsertionListParts = array();
        foreach ($insertionListParts as $fieldName) {
            $fieldNameParts = explode(';', $fieldName, 2);
            $cleanFieldName = $fieldNameParts[0];
            if (
                $cleanFieldName === '--linebreak--'
                || (
                    !in_array($cleanFieldName, $cleanInsertionListParts, TRUE)
                    && !in_array($cleanFieldName, $listMatches, TRUE)
                )
            ) {
                $cleanInsertionListParts[] = $fieldName;
            }
        }
        return implode(', ', $cleanInsertionListParts);
    }

    static protected function getInsertionNeedles($item, array $itemDetails) {
        if (strpos($item, '--') !== FALSE) {
            // If $item is a separator (--div--) or palette (--palette--) then it may have been appended by a unique number. This must be stripped away here.
            $item = str_replace(array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), '', $item);
        }
        $needles = array(
            'before' => array($item, 'before:' . $item),
            'after' => array('after:' . $item),
            'replace' => array('replace:' . $item)
        );
        if ($itemDetails['palette']) {
            $palette = $item . ';;' . $itemDetails['palette'];
            $needles['before'][] = $palette;
            $needles['before'][] = 'before:' . $palette;
            $needles['after'][] = 'after:' . $palette;
            $needles['replace'][] = 'replace:' . $palette;
        }
        return $needles;
    }

    static protected function explodeItemList($itemList) {
        $items = array();
        $itemParts = GeneralUtility::trimExplode(',', $itemList, TRUE);
        foreach ($itemParts as $itemPart) {
            $itemDetails = GeneralUtility::trimExplode(';', $itemPart, FALSE, 5);
            $key = $itemDetails[0];
            if (strpos($key, '--') !== FALSE) {
                // If $key is a separator (--div--) or palette (--palette--) then it will be appended by a unique number. This must be removed again when using this value!
                $key .= count($items);
            }
            if (!isset($items[$key])) {
                $items[$key] = array(
                    'rawData' => $itemPart,
                    'details' => array(
                        'field' => $itemDetails[0],
                        'label' => $itemDetails[1],
                        'palette' => $itemDetails[2],
                        'special' => $itemDetails[3],
                        'styles' => $itemDetails[4]
                    )
                );
            }
        }
        return $items;
    }

    static protected function generateItemList(array $items, $useRawData = FALSE) {
        $itemParts = array();
        foreach ($items as $item => $itemDetails) {
            if (strpos($item, '--') !== FALSE) {
                // If $item is a separator (--div--) or palette (--palette--) then it may have been appended by a unique number. This must be stripped away here.
                $item = str_replace(array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), '', $item);
            }
            if ($useRawData) {
                $itemParts[] = $itemDetails['rawData'];
            } else {
                $itemParts[] = count($itemDetails['details']) > 1 ? implode(';', $itemDetails['details']) : $item;
            }
        }
        return implode(', ', $itemParts);
    }

    static public function allowTableOnStandardPages($table) {
        $GLOBALS['PAGES_TYPES']['default']['allowedTables'] .= ',' . $table;
    }

    static public function addExtJSModule($extensionName, $mainModuleName, $subModuleName = '', $position = '', array $moduleConfiguration = array()) {
        if (empty($extensionName)) {
            throw new \InvalidArgumentException('The extension name must not be empty', 1325938973);
        }
        $extensionKey = GeneralUtility::camelCaseToLowerCaseUnderscored($extensionName);
        $extensionName = str_replace(' ', '', ucwords(str_replace('_', ' ', $extensionName)));
        $defaultModuleConfiguration = array(
            'access' => 'admin',
            'icon' => 'gfx/typo3.png',
            'labels' => '',
            'extRelPath' => self::extRelPath($extensionKey) . 'Classes/'
        );
        // Add mandatory parameter to use new pagetree
        if ($mainModuleName === 'web') {
            $defaultModuleConfiguration['navigationComponentId'] = 'typo3-pagetree';
        }
        \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($defaultModuleConfiguration, $moduleConfiguration);
        $moduleConfiguration = $defaultModuleConfiguration;
        if (strlen($subModuleName) > 0) {
            $moduleSignature = $mainModuleName . '_' . $subModuleName;
        } else {
            $moduleSignature = $mainModuleName;
        }
        $moduleConfiguration['name'] = $moduleSignature;
        $moduleConfiguration['script'] = 'extjspaneldummy.html';
        $moduleConfiguration['extensionName'] = $extensionName;
        $moduleConfiguration['configureModuleFunction'] = array('TYPO3\\CMS\\Core\\Utility\\ExtensionManagementUtility', 'configureModule');
        $GLOBALS['TBE_MODULES']['_configuration'][$moduleSignature] = $moduleConfiguration;
        self::addModule($mainModuleName, $subModuleName, $position);
    }

    static public function configureModule($moduleSignature, $modulePath) {
        $moduleConfiguration = $GLOBALS['TBE_MODULES']['_configuration'][$moduleSignature];
        $iconPathAndFilename = $moduleConfiguration['icon'];
        if (substr($iconPathAndFilename, 0, 4) === 'EXT:') {
            list($extensionKey, $relativePath) = explode('/', substr($iconPathAndFilename, 4), 2);
            $iconPathAndFilename = self::extPath($extensionKey) . $relativePath;
        }
        // TODO: skin support
        $moduleLabels = array(
            'tabs_images' => array(
                'tab' => $iconPathAndFilename
            ),
            'labels' => array(
                'tablabel' => $GLOBALS['LANG']->sL($moduleConfiguration['labels'] . ':mlang_labels_tablabel'),
                'tabdescr' => $GLOBALS['LANG']->sL($moduleConfiguration['labels'] . ':mlang_labels_tabdescr')
            ),
            'tabs' => array(
                'tab' => $GLOBALS['LANG']->sL($moduleConfiguration['labels'] . ':mlang_tabs_tab')
            )
        );
        $GLOBALS['LANG']->addModuleLabels($moduleLabels, $moduleSignature . '_');
        return $moduleConfiguration;
    }

    static public function addModule($main, $sub = '', $position = '', $path = '', $moduleConfiguration = array()) {
        // If there is already a main module by this name:
        // Adding the submodule to the correct position:
        if (isset($GLOBALS['TBE_MODULES'][$main]) && $sub) {
            list($place, $modRef) = GeneralUtility::trimExplode(':', $position, TRUE);
            $modules = ',' . $GLOBALS['TBE_MODULES'][$main] . ',';
            if ($place === NULL || ($modRef !== NULL && !GeneralUtility::inList($modules, $modRef))) {
                $place = 'bottom';
            }
            $modRef = ',' . $modRef . ',';
            if (!GeneralUtility::inList($modules, $sub)) {
                switch (strtolower($place)) {
                    case 'after':
                        $modules = str_replace($modRef, $modRef . $sub . ',', $modules);
                        break;
                    case 'before':
                        $modules = str_replace($modRef, ',' . $sub . $modRef, $modules);
                        break;
                    case 'top':
                        $modules = $sub . $modules;
                        break;
                    case 'bottom':
                    default:
                        $modules = $modules . $sub;
                }
            }
            // Re-inserting the submodule list:
            $GLOBALS['TBE_MODULES'][$main] = trim($modules, ',');
        } else {
            // Create new main modules with only one submodule, $sub (or none if $sub is blank)
            $GLOBALS['TBE_MODULES'][$main] = $sub;
        }
        $fullModuleSignature = $main . ($sub ? '_' . $sub : '');
        // Adding path:
        if ($path) {
            if (substr($path, 0, 4) === 'EXT:') {
                list($extensionKey, $relativePath) = explode('/', substr($path, 4), 2);
                $path = self::extPath($extensionKey) . $relativePath;
            }

            $GLOBALS['TBE_MODULES']['_PATHS'][$fullModuleSignature] = $path;
        }

        // add additional configuration
        if (is_array($moduleConfiguration) && count($moduleConfiguration) > 0) {
            $GLOBALS['TBE_MODULES']['_configuration'][$fullModuleSignature] = $moduleConfiguration;
        }
    }

    static public function registerExtDirectComponent($endpointName, $callbackClass, $moduleName = NULL, $accessLevel = NULL) {
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ExtDirect'][$endpointName] = array(
            'callbackClass' => $callbackClass,
            'moduleName' => $moduleName,
            'accessLevel' => $accessLevel
        );
    }

    static public function registerAjaxHandler($ajaxId, $callbackMethod, $csrfTokenCheck = TRUE) {
        $GLOBALS['TYPO3_CONF_VARS']['BE']['AJAX'][$ajaxId] = array(
            'callbackMethod' => $callbackMethod,
            'csrfTokenCheck' => $csrfTokenCheck
        );
    }

    static public function addModulePath($name, $path) {
        if (substr($path, 0, 4) === 'EXT:') {
            list($extensionKey, $relativePath) = explode('/', substr($path, 4), 2);
            $path = ExtensionManagementUtility::extPath($extensionKey) . $relativePath;
        }
        $GLOBALS['TBE_MODULES']['_PATHS'][$name] = $path;
    }

    static public function insertModuleFunction($modname, $className, $classPath, $title, $MM_key = 'function', $WS = '') {
        if (!empty($classPath)) {
            GeneralUtility::deprecationLog(
                sprintf('insertModuleFunction(%s, %s, ...): Use auto-loading for the class and pass NULL as $classPath since 6.2.',
                    $modname,
                    $className
                )
            );
        }
        $GLOBALS['TBE_MODULES_EXT'][$modname]['MOD_MENU'][$MM_key][$className] = array(
            'name' => $className,
            'path' => $classPath,
            'title' => $title,
            'ws' => $WS
        );
    }

    static public function appendToTypoConfVars($group, $key, $content) {
        $GLOBALS['TYPO3_CONF_VARS_extensionAdded'][$group][$key] .= $content;
        $GLOBALS['TYPO3_CONF_VARS'][$group][$key] .= $content;
    }

    static public function addPageTSConfig($content) {
        self::appendToTypoConfVars('BE', 'defaultPageTSconfig', '
[GLOBAL]
' . $content);
    }

    static public function addUserTSConfig($content) {
        self::appendToTypoConfVars('BE', 'defaultUserTSconfig', '
[GLOBAL]
' . $content);
    }

    static public function addLLrefForTCAdescr($tca_descr_key, $file_ref) {
        if ($tca_descr_key) {
            if (!is_array($GLOBALS['TCA_DESCR'][$tca_descr_key])) {
                $GLOBALS['TCA_DESCR'][$tca_descr_key] = array();
            }
            if (!is_array($GLOBALS['TCA_DESCR'][$tca_descr_key]['refs'])) {
                $GLOBALS['TCA_DESCR'][$tca_descr_key]['refs'] = array();
            }
            $GLOBALS['TCA_DESCR'][$tca_descr_key]['refs'][] = $file_ref;
        }
    }

    static public function addNavigationComponent($module, $componentId, $extensionKey = NULL) {
        $extensionKey = $extensionKey ?: $GLOBALS['_EXTKEY'];
        if (!isset($extensionKey)) {
            throw new \RuntimeException('No extensionKey set in addNavigationComponent(). Provide it as third Parameter', 1404068039);
        }
        $GLOBALS['TBE_MODULES']['_navigationComponents'][$module] = array(
            'componentId' => $componentId,
            'extKey' => $extensionKey,
            'isCoreComponent' => FALSE
        );
    }

    static public function addCoreNavigationComponent($module, $componentId) {
        self::addNavigationComponent($module, $componentId);
        $GLOBALS['TBE_MODULES']['_navigationComponents'][$module]['isCoreComponent'] = TRUE;
    }

    /**************************************
     *
     *   Adding SERVICES features
     *
     ***************************************/
    static public function addService($extKey, $serviceType, $serviceKey, $info) {
        if ($serviceType && is_array($info)) {
            $info['priority'] = max(0, min(100, $info['priority']));
            $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey] = $info;
            $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['extKey'] = $extKey;
            $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceKey'] = $serviceKey;
            $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceType'] = $serviceType;
            // Change the priority (and other values) from $GLOBALS['TYPO3_CONF_VARS']
            // $GLOBALS['TYPO3_CONF_VARS']['T3_SERVICES'][$serviceType][$serviceKey]['priority']
            // even the activation is possible (a unix service might be possible on windows for some reasons)
            if (is_array($GLOBALS['TYPO3_CONF_VARS']['T3_SERVICES'][$serviceType][$serviceKey])) {
                // No check is done here - there might be configuration values only the service type knows about, so
                // we pass everything
                $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey] = array_merge($GLOBALS['T3_SERVICES'][$serviceType][$serviceKey], $GLOBALS['TYPO3_CONF_VARS']['T3_SERVICES'][$serviceType][$serviceKey]);
            }
            // OS check
            // Empty $os means 'not limited to one OS', therefore a check is not needed
            if ($GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['available'] && $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['os'] != '') {
                // TYPO3_OS is not yet defined
                $os_type = stripos(PHP_OS, 'win') !== FALSE && !stripos(PHP_OS, 'darwin') !== FALSE ? 'WIN' : 'UNIX';
                $os = GeneralUtility::trimExplode(',', strtoupper($GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['os']));
                if (!in_array($os_type, $os)) {
                    self::deactivateService($serviceType, $serviceKey);
                }
            }
            // Convert subtype list to array for quicker access
            $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceSubTypes'] = array();
            $serviceSubTypes = GeneralUtility::trimExplode(',', $info['subtype']);
            foreach ($serviceSubTypes as $subtype) {
                $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceSubTypes'][$subtype] = $subtype;
            }
        }
    }

    static public function findService($serviceType, $serviceSubType = '', $excludeServiceKeys = array()) {
        $serviceKey = FALSE;
        $serviceInfo = FALSE;
        $priority = 0;
        $quality = 0;
        if (!is_array($excludeServiceKeys)) {
            $excludeServiceKeys = GeneralUtility::trimExplode(',', $excludeServiceKeys, TRUE);
        }
        if (is_array($GLOBALS['T3_SERVICES'][$serviceType])) {
            foreach ($GLOBALS['T3_SERVICES'][$serviceType] as $key => $info) {
                if (in_array($key, $excludeServiceKeys)) {
                    continue;
                }
                // Select a subtype randomly
                // Useful to start a service by service key without knowing his subtypes - for testing purposes
                if ($serviceSubType == '*') {
                    $serviceSubType = key($info['serviceSubTypes']);
                }
                // This matches empty subtype too
                if ($info['available'] && ($info['subtype'] == $serviceSubType || $info['serviceSubTypes'][$serviceSubType]) && $info['priority'] >= $priority) {
                    // Has a lower quality than the already found, therefore we skip this service
                    if ($info['priority'] == $priority && $info['quality'] < $quality) {
                        continue;
                    }
                    // Check if the service is available
                    $info['available'] = self::isServiceAvailable($serviceType, $key, $info);
                    // Still available after exec check?
                    if ($info['available']) {
                        $serviceKey = $key;
                        $priority = $info['priority'];
                        $quality = $info['quality'];
                    }
                }
            }
        }
        if ($serviceKey) {
            $serviceInfo = $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey];
        }
        return $serviceInfo;
    }

    static public function findServiceByKey($serviceKey) {
        if (is_array($GLOBALS['T3_SERVICES'])) {
            // Loop on all service types
            // NOTE: we don't care about the actual type, we are looking for a specific key
            foreach ($GLOBALS['T3_SERVICES'] as $serviceType => $servicesPerType) {
                if (isset($servicesPerType[$serviceKey])) {
                    $serviceDetails = $servicesPerType[$serviceKey];
                    // Test if service is available
                    if (self::isServiceAvailable($serviceType, $serviceKey, $serviceDetails)) {
                        // We have found the right service, return its information
                        return $serviceDetails;
                    }
                }
            }
        }
        throw new \TYPO3\CMS\Core\Exception('Service not found for key: ' . $serviceKey, 1319217244);
    }

    static public function isServiceAvailable($serviceType, $serviceKey, $serviceDetails) {
        // If the service depends on external programs - check if they exists
        if (trim($serviceDetails['exec'])) {
            $executables = GeneralUtility::trimExplode(',', $serviceDetails['exec'], TRUE);
            foreach ($executables as $executable) {
                // If at least one executable file is not available, exit early returning FALSE
                if (!\TYPO3\CMS\Core\Utility\CommandUtility::checkCommand($executable)) {
                    self::deactivateService($serviceType, $serviceKey);
                    return FALSE;
                }
            }
        }
        // The service is available
        return TRUE;
    }

    static public function deactivateService($serviceType, $serviceKey) {
        // ... maybe it's better to move non-available services to a different array??
        $GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['available'] = FALSE;
    }

    /**************************************
     *
     *   Adding FRONTEND features
     *   (related specifically to "cms" extension)
     *
     ***************************************/
    static public function addPlugin($itemArray, $type = 'list_type', $extensionKey = NULL) {
        $extensionKey = $extensionKey ?: $GLOBALS['_EXTKEY'];
        if (!isset($extensionKey)) {
            throw new \RuntimeException(
                'No extension key could be determined when calling addPlugin()!'
                . LF
                . 'This method is meant to be called from an ext_tables.php or Configuration/TCA/Overrides file. '
                . 'If you call it from Configuration/TCA/Overrides, the extension key needs to be specified as third parameter. '
                . 'Calling it from any other place e.g. ext_localconf.php does not work and is not supported.',
                1404068038
            );
        }
        if ($extensionKey && !$itemArray[2] && isset($GLOBALS['TYPO3_LOADED_EXT'][$extensionKey]['ext_icon'])) {
            $itemArray[2] = self::extRelPath($extensionKey) . $GLOBALS['TYPO3_LOADED_EXT'][$extensionKey]['ext_icon'];
        }
        if (is_array($GLOBALS['TCA']['tt_content']['columns']) && is_array($GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'])) {
            foreach ($GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'] as $k => $v) {
                if ((string)$v[1] === (string)$itemArray[1]) {
                    $GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'][$k] = $itemArray;
                    return;
                }
            }
            $GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'][] = $itemArray;
        }
    }

    static public function addPiFlexFormValue($piKeyToMatch, $value, $CTypeToMatch = 'list') {
        if (is_array($GLOBALS['TCA']['tt_content']['columns']) && is_array($GLOBALS['TCA']['tt_content']['columns']['pi_flexform']['config']['ds'])) {
            $GLOBALS['TCA']['tt_content']['columns']['pi_flexform']['config']['ds'][$piKeyToMatch . ',' . $CTypeToMatch] = $value;
        }
    }

    static public function addToInsertRecords($table, $content_table = 'tt_content', $content_field = 'records') {
        if (is_array($GLOBALS['TCA'][$content_table]['columns']) && isset($GLOBALS['TCA'][$content_table]['columns'][$content_field]['config']['allowed'])) {
            $GLOBALS['TCA'][$content_table]['columns'][$content_field]['config']['allowed'] .= ',' . $table;
        }
    }

    static public function addPItoST43($key, $classFile = '', $prefix = '', $type = 'list_type', $cached = 0) {
        $classFile = $classFile ? $classFile : 'pi/class.tx_' . str_replace('_', '', $key) . $prefix . '.php';
        $cN = self::getCN($key);
        // General plugin
        $pluginContent = trim('
plugin.' . $cN . $prefix . ' = USER' . ($cached ? '' : '_INT') . '
plugin.' . $cN . $prefix . ' {
    includeLibs = ' . $GLOBALS['TYPO3_LOADED_EXT'][$key]['siteRelPath'] . $classFile . '
    userFunc = ' . $cN . $prefix . '->main
}');
        self::addTypoScript($key, 'setup', '
# Setting ' . $key . ' plugin TypoScript
' . $pluginContent);
        // Add after defaultContentRendering
        switch ($type) {
            case 'list_type':
                $addLine = 'tt_content.list.20.' . $key . $prefix . ' = < plugin.' . $cN . $prefix;
                break;
            case 'menu_type':
                $addLine = 'tt_content.menu.20.' . $key . $prefix . ' = < plugin.' . $cN . $prefix;
                break;
            case 'CType':
                $addLine = trim('
tt_content.' . $key . $prefix . ' = COA
tt_content.' . $key . $prefix . ' {
    10 = < lib.stdheader
    20 = < plugin.' . $cN . $prefix . '
}
');
                break;
            case 'header_layout':
                $addLine = 'lib.stdheader.10.' . $key . $prefix . ' = < plugin.' . $cN . $prefix;
                break;
            case 'includeLib':
                $addLine = 'page.1000 = < plugin.' . $cN . $prefix;
                break;
            default:
                $addLine = '';
        }
        if ($addLine) {
            self::addTypoScript($key, 'setup', '
# Setting ' . $key . ' plugin TypoScript
' . $addLine . '
', 'defaultContentRendering');
        }
    }

    static public function addStaticFile($extKey, $path, $title) {
        if ($extKey && $path && is_array($GLOBALS['TCA']['sys_template']['columns'])) {
            $value = str_replace(',', '', 'EXT:' . $extKey . '/' . $path);
            $itemArray = array(trim($title . ' (' . $extKey . ')'), $value);
            $GLOBALS['TCA']['sys_template']['columns']['include_static_file']['config']['items'][] = $itemArray;
        }
    }

    static public function addTypoScriptSetup($content) {
        self::appendToTypoConfVars('FE', 'defaultTypoScript_setup', '
[GLOBAL]
' . $content);
    }

    static public function addTypoScriptConstants($content) {
        self::appendToTypoConfVars('FE', 'defaultTypoScript_constants', '
[GLOBAL]
' . $content);
    }

    static public function addTypoScript($key, $type, $content, $afterStaticUid = 0) {
        if ($type === 'setup' || $type === 'constants') {
            $content = '

[GLOBAL]
#############################################
## TypoScript added by extension "' . $key . '"
#############################################

' . $content;
            if ($afterStaticUid) {
                // If 'content (default)' is targeted (static uid 43),
                // the content is added after typoscript of type contentRendering, eg. css_styled_content, see EXT:frontend/TemplateService for more information on how the code is parsed
                if ($afterStaticUid === 'defaultContentRendering' || $afterStaticUid == 43) {
                    $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.']['defaultContentRendering'] .= $content;
                } else {
                    $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.'][$afterStaticUid] .= $content;
                }
            } else {
                $GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type] .= $content;
            }
        }
    }

    /***************************************
     *
     * Internal extension management methods
     *
     ***************************************/
    static public function getExtensionIcon($extensionPath, $returnFullPath = FALSE) {
        $icon = '';
        $iconFileTypesToCheckFor = array('png', 'gif');
        foreach ($iconFileTypesToCheckFor as $fileType) {
            if (file_exists($extensionPath . 'ext_icon.' . $fileType)) {
                $icon = 'ext_icon.' . $fileType;
                break;
            }
        }
        return $returnFullPath ? $extensionPath . $icon : $icon;
    }

    static public function loadExtLocalconf($allowCaching = TRUE) {
        if ($allowCaching) {
            $cacheIdentifier = self::getExtLocalconfCacheIdentifier();
            $codeCache = self::getCacheManager()->getCache('cache_core');
            if ($codeCache->has($cacheIdentifier)) {
                $codeCache->requireOnce($cacheIdentifier);
            } else {
                self::loadSingleExtLocalconfFiles();
                self::createExtLocalconfCacheEntry();
            }
        } else {
            self::loadSingleExtLocalconfFiles();
        }
    }

    static protected function loadSingleExtLocalconfFiles() {
        // This is the main array meant to be manipulated in the ext_localconf.php files
        // In general it is recommended to not rely on it to be globally defined in that
        // scope but to use $GLOBALS['TYPO3_CONF_VARS'] instead.
        // Nevertheless we define it here as global for backwards compatibility.
        global $TYPO3_CONF_VARS;
        foreach ($GLOBALS['TYPO3_LOADED_EXT'] as $_EXTKEY => $extensionInformation) {
            if ((is_array($extensionInformation) || $extensionInformation instanceof \ArrayAccess) && isset($extensionInformation['ext_localconf.php'])) {
                // $_EXTKEY and $_EXTCONF are available in ext_localconf.php
                // and are explicitly set in cached file as well
                $_EXTCONF = isset($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$_EXTKEY]) ? $GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$_EXTKEY] : NULL;
                require $extensionInformation['ext_localconf.php'];
            }
        }
    }

    static protected function createExtLocalconfCacheEntry() {
        $extensionInformation = $GLOBALS['TYPO3_LOADED_EXT'];
        $phpCodeToCache = array();
        // Set same globals as in loadSingleExtLocalconfFiles()
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = 'global $TYPO3_CONF_VARS, $T3_SERVICES, $T3_VAR;';
        $phpCodeToCache[] = '';
        // Iterate through loaded extensions and add ext_localconf content
        foreach ($extensionInformation as $extensionKey => $extensionDetails) {
            if (isset($extensionDetails['ext_localconf.php']) && $extensionDetails['ext_localconf.php']) {
                // Include a header per extension to make the cache file more readable
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
                // Set $_EXTKEY and $_EXTCONF for this extension
                $phpCodeToCache[] = '$_EXTKEY = \'' . $extensionKey . '\';';
                $phpCodeToCache[] = '$_EXTCONF = $GLOBALS[\'TYPO3_CONF_VARS\'][\'EXT\'][\'extConf\'][$_EXTKEY];';
                $phpCodeToCache[] = '';
                // Add ext_localconf.php content of extension
                $phpCodeToCache[] = trim(GeneralUtility::getUrl($extensionDetails['ext_localconf.php']));
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
            }
        }
        $phpCodeToCache = implode(LF, $phpCodeToCache);
        // Remove all start and ending php tags from content
        $phpCodeToCache = preg_replace('/<\\?php|\\?>/is', '', $phpCodeToCache);
        self::getCacheManager()->getCache('cache_core')->set(self::getExtLocalconfCacheIdentifier(), $phpCodeToCache);
    }

    static protected function getExtLocalconfCacheIdentifier() {
        return 'ext_localconf_' . sha1(TYPO3_version . PATH_site . 'extLocalconf' . serialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages']));
    }

    static public function loadBaseTca($allowCaching = TRUE) {
        if ($allowCaching) {
            $cacheIdentifier = static::getBaseTcaCacheIdentifier();
            $codeCache = static::getCacheManager()->getCache('cache_core');
            if ($codeCache->has($cacheIdentifier)) {
                // substr is necessary, because the php frontend wraps php code around the cache value
                $cacheData = unserialize(substr($codeCache->get($cacheIdentifier), 6, -2));
                $GLOBALS['TCA'] = $cacheData['tca'];
                GeneralUtility::setSingletonInstance('TYPO3\\CMS\\Core\\Category\\CategoryRegistry', $cacheData['categoryRegistry']);
            } else {
                static::buildBaseTcaFromSingleFiles();
                static::createBaseTcaCacheFile();
            }
        } else {
            static::buildBaseTcaFromSingleFiles();
        }
    }

    static protected function buildBaseTcaFromSingleFiles() {
        $GLOBALS['TCA'] = array();

        $activePackages = static::$packageManager->getActivePackages();

        // First load "full table" files from Configuration/TCA
        foreach ($activePackages as $package) {
            $tcaConfigurationDirectory = $package->getPackagePath() . 'Configuration/TCA';
            if (is_dir($tcaConfigurationDirectory)) {
                $files = scandir($tcaConfigurationDirectory);
                foreach ($files as $file) {
                    if (
                        is_file($tcaConfigurationDirectory . '/' . $file)
                        && ($file !== '.')
                        && ($file !== '..')
                        && (substr($file, -4, 4) === '.php')
                    ) {
                        $tcaOfTable = require($tcaConfigurationDirectory . '/' . $file);
                        if (is_array($tcaOfTable)) {
                            // TCA table name is filename without .php suffix, eg 'sys_notes', not 'sys_notes.php'
                            $tcaTableName = substr($file, 0, -4);
                            $GLOBALS['TCA'][$tcaTableName] = $tcaOfTable;
                        }
                    }
                }
            }
        }

        // Apply category stuff
        \TYPO3\CMS\Core\Category\CategoryRegistry::getInstance()->applyTcaForPreRegisteredTables();

        // Execute override files from Configuration/TCA/Overrides
        foreach ($activePackages as $package) {
            $tcaOverridesPathForPackage = $package->getPackagePath() . 'Configuration/TCA/Overrides';
            if (is_dir($tcaOverridesPathForPackage)) {
                $files = scandir($tcaOverridesPathForPackage);
                foreach ($files as $file) {
                    if (
                        is_file($tcaOverridesPathForPackage . '/' . $file)
                        && ($file !== '.')
                        && ($file !== '..')
                        && (substr($file, -4, 4) === '.php')
                    ) {
                        require($tcaOverridesPathForPackage . '/' . $file);
                    }
                }
            }
        }

        static::emitTcaIsBeingBuiltSignal($GLOBALS['TCA']);
    }

    static protected function emitTcaIsBeingBuiltSignal(array $tca) {
        list($tca) = static::getSignalSlotDispatcher()->dispatch(__CLASS__, 'tcaIsBeingBuilt', array($tca));
        $GLOBALS['TCA'] = $tca;
    }

    static protected function createBaseTcaCacheFile() {
        $codeCache = self::getCacheManager()->getCache('cache_core');
        $codeCache->set(static::getBaseTcaCacheIdentifier(), serialize(array('tca' => $GLOBALS['TCA'], 'categoryRegistry' => \TYPO3\CMS\Core\Category\CategoryRegistry::getInstance())));
    }

    static protected function getBaseTcaCacheIdentifier() {
        return 'tca_base_' . sha1(TYPO3_version . PATH_site . 'tca_with_category_registry' . serialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages']));
    }

    static public function loadExtTables($allowCaching = TRUE) {
        if ($allowCaching && !self::$extTablesWasReadFromCacheOnce) {
            self::$extTablesWasReadFromCacheOnce = TRUE;
            $cacheIdentifier = self::getExtTablesCacheIdentifier();
            $codeCache = self::getCacheManager()->getCache('cache_core');
            if ($codeCache->has($cacheIdentifier)) {
                $codeCache->requireOnce($cacheIdentifier);
            } else {
                self::loadSingleExtTablesFiles();
                self::createExtTablesCacheEntry();
            }
        } else {
            self::loadSingleExtTablesFiles();
        }
    }

    static protected function loadSingleExtTablesFiles() {
        // In general it is recommended to not rely on it to be globally defined in that
        // scope, but we can not prohibit this without breaking backwards compatibility
        global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;
        global $TBE_MODULES, $TBE_MODULES_EXT, $TCA;
        global $PAGES_TYPES, $TBE_STYLES, $FILEICONS;
        global $_EXTKEY;
        // Load each ext_tables.php file of loaded extensions
        foreach ($GLOBALS['TYPO3_LOADED_EXT'] as $_EXTKEY => $extensionInformation) {
            if ((is_array($extensionInformation) || $extensionInformation instanceof \ArrayAccess) && $extensionInformation['ext_tables.php']) {
                // $_EXTKEY and $_EXTCONF are available in ext_tables.php
                // and are explicitly set in cached file as well
                $_EXTCONF = $GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$_EXTKEY];
                require $extensionInformation['ext_tables.php'];
                static::loadNewTcaColumnsConfigFiles();
            }
        }
    }

    static protected function createExtTablesCacheEntry() {
        $extensionInformation = $GLOBALS['TYPO3_LOADED_EXT'];
        $phpCodeToCache = array();
        // Set same globals as in loadSingleExtTablesFiles()
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = 'global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;';
        $phpCodeToCache[] = 'global $TBE_MODULES, $TBE_MODULES_EXT, $TCA;';
        $phpCodeToCache[] = 'global $PAGES_TYPES, $TBE_STYLES, $FILEICONS;';
        $phpCodeToCache[] = 'global $_EXTKEY;';
        $phpCodeToCache[] = '';
        // Iterate through loaded extensions and add ext_tables content
        foreach ($extensionInformation as $extensionKey => $extensionDetails) {
            if (isset($extensionDetails['ext_tables.php']) && $extensionDetails['ext_tables.php']) {
                // Include a header per extension to make the cache file more readable
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
                // Set $_EXTKEY and $_EXTCONF for this extension
                $phpCodeToCache[] = '$_EXTKEY = \'' . $extensionKey . '\';';
                $phpCodeToCache[] = '$_EXTCONF = $GLOBALS[\'TYPO3_CONF_VARS\'][\'EXT\'][\'extConf\'][$_EXTKEY];';
                $phpCodeToCache[] = '';
                // Add ext_tables.php content of extension
                $phpCodeToCache[] = trim(GeneralUtility::getUrl($extensionDetails['ext_tables.php']));
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::loadNewTcaColumnsConfigFiles();';
                $phpCodeToCache[] = '';
            }
        }
        $phpCodeToCache = implode(LF, $phpCodeToCache);
        // Remove all start and ending php tags from content
        $phpCodeToCache = preg_replace('/<\\?php|\\?>/is', '', $phpCodeToCache);
        self::getCacheManager()->getCache('cache_core')->set(self::getExtTablesCacheIdentifier(), $phpCodeToCache);
    }

    static public function loadNewTcaColumnsConfigFiles() {
        global $TCA;

        foreach ($TCA as $tableName => $_) {
            if (!isset($TCA[$tableName]['columns'])) {
                $columnsConfigFile = $TCA[$tableName]['ctrl']['dynamicConfigFile'];
                if ($columnsConfigFile) {
                    if (GeneralUtility::isAbsPath($columnsConfigFile)) {
                        include($columnsConfigFile);
                    } else {
                        throw new \RuntimeException(
                            'Columns configuration file not found',
                            1341151261
                        );
                    }
                }
            }
        }
    }

    static protected function getExtTablesCacheIdentifier() {
        return 'ext_tables_' . sha1(TYPO3_version . PATH_site . 'extTables' . serialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages']));
    }

    static public function isLocalconfWritable() {
        GeneralUtility::logDeprecatedFunction();
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Configuration\\ConfigurationManager')
            ->canWriteConfiguration();
    }

    static public function removeCacheFiles() {
        self::getCacheManager()->flushCachesInGroup('system');
    }

    static public function getLoadedExtensionListArray() {
        return array_keys(static::$packageManager->getActivePackages());
    }

    static public function getRequiredExtensionListArray() {
        GeneralUtility::logDeprecatedFunction();
        return GeneralUtility::trimExplode(',', REQUIRED_EXTENSIONS);
    }

    static public function loadExtension($extensionKey) {
        if (static::$packageManager->isPackageActive($extensionKey)) {
            throw new \RuntimeException('Extension already loaded', 1342345486);
        }
        static::$packageManager->activatePackage($extensionKey);
    }

    static public function unloadExtension($extensionKey) {
        if (!static::$packageManager->isPackageActive($extensionKey)) {
            throw new \RuntimeException('Extension not loaded', 1342345487);
        }
        static::$packageManager->deactivatePackage($extensionKey);
    }

    static public function writeNewExtensionList(array $newExtensionList) {
        GeneralUtility::logDeprecatedFunction();
    }

    static public function makeCategorizable($extensionKey, $tableName, $fieldName = 'categories', array $options = array()) {
        // Update the category registry
        $result = \TYPO3\CMS\Core\Category\CategoryRegistry::getInstance()->add($extensionKey, $tableName, $fieldName, $options);
        if ($result === FALSE) {
            $message = '\TYPO3\CMS\Core\Category\CategoryRegistry: no category registered for table "%s". Key was already registered.';
            $logger = GeneralUtility::makeInstance('TYPO3\CMS\Core\Log\LogManager')->getLogger(__CLASS__);
            $logger->warning(
                sprintf($message, $tableName)
            );
        }
    }
}