ExtensionManagementUtility.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\Core\Utility;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Finder\Finder;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use ‪TYPO3\CMS\Core\Configuration\Event\AfterTcaCompilationEvent;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\DataHandling\PageDoktypeRegistry;
use ‪TYPO3\CMS\Core\Migrations\TcaMigration;
use ‪TYPO3\CMS\Core\Package\Cache\PackageDependentCacheIdentifier;
use ‪TYPO3\CMS\Core\Package\Exception as ‪PackageException;
use TYPO3\CMS\Core\Package\PackageManager;
use ‪TYPO3\CMS\Core\Preparations\TcaPreparation;
 
class ‪ExtensionManagementUtility
{
    protected static bool ‪$extTablesWasReadFromCacheOnce = false;
    protected static PackageManager ‪$packageManager;
    protected static EventDispatcherInterface ‪$eventDispatcher;
    protected static ?‪CacheManager ‪$cacheManager;
 
    public static function ‪setPackageManager(PackageManager ‪$packageManager): void
    {
        static::$packageManager = ‪$packageManager;
    }
 
    public static function ‪setEventDispatcher(EventDispatcherInterface ‪$eventDispatcher): void
    {
        static::$eventDispatcher = ‪$eventDispatcher;
    }
 
    protected static function ‪getCacheManager(): ‪CacheManager
    {
        return static::$cacheManager ??= GeneralUtility::makeInstance(CacheManager::class);
    }
 
    /**************************************
     *
     * PATHS and other evaluation
     *
     ***************************************/
 
    public static function ‪isLoaded(string $key): bool
    {
        return static::$packageManager->isPackageActive($key);
    }
 
    public static function ‪resolvePackagePath(string $path): string
    {
        return static::$packageManager->resolvePackagePath($path);
    }
 
    public static function ‪extPath(string $key, string $script = ''): string
    {
        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;
    }
 
    public static function ‪getCN(string $key): string
    {
        return str_starts_with($key, 'user_')
            ? 'user_' . str_replace('_', '', substr($key, 5))
            : 'tx_' . str_replace('_', '', $key);
    }
 
    public static function ‪getExtensionVersion(string $key): string
    {
        if (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 ‪PackageException('Version number in composer manifest of package "' . $key . '" is missing or invalid', 1395614959);
        }
        return $version;
    }
 
    /**************************************
     *
     *   Adding BACKEND features
     *   (related to core features)
     *
     ***************************************/
 
    public static function ‪addTCAcolumns(string $table, array $columnArray): void
    {
        if (is_array(‪$GLOBALS['TCA'][$table]['columns'] ?? false)) {
            // Candidate for array_merge() if integer-keys will some day make trouble...
            ‪$GLOBALS['TCA'][$table]['columns'] = array_merge(‪$GLOBALS['TCA'][$table]['columns'], $columnArray);
        }
    }
 
    public static function ‪addToAllTCAtypes(string $table, string $newFieldsString, string $typeList = '', string $position = ''): void
    {
        $newFieldsString = trim($newFieldsString);
        if ($newFieldsString === '' || !is_array(‪$GLOBALS['TCA'][$table]['types'] ?? false)) {
            return;
        }
        if ($position !== '') {
            [$positionIdentifier, $entityName] = ‪GeneralUtility::trimExplode(':', $position, false, 2);
        } else {
            $positionIdentifier = '';
            $entityName = '';
        }
        $palettesChanged = [];
 
        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'] ?? false)) {
                // 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
                    )/x', $typeDetails['showitem'], $paletteMatches);
                if ($paletteCount > 0) {
                    $paletteNames = array_filter(array_merge($paletteMatches[1], $paletteMatches[2]));
                    if (!empty($paletteNames)) {
                        foreach ($paletteNames as $paletteName) {
                            if (!isset(‪$GLOBALS['TCA'][$table]['palettes'][$paletteName])) {
                                continue;
                            }
                            $palette = ‪$GLOBALS['TCA'][$table]['palettes'][$paletteName];
                            switch ($positionIdentifier) {
                                case 'after':
                                case 'before':
                                    if (preg_match('/\\b' . preg_quote($entityName, '/') . '\\b/', $palette['showitem']) > 0 || $entityName === 'palette:' . $paletteName) {
                                        $newPosition = $positionIdentifier . ':--palette--;;' . $paletteName;
                                    }
                                    break;
                                case 'replace':
                                    // check if fields have been added to palette before
                                    if (isset($palettesChanged[$paletteName])) {
                                        $fieldExists = true;
                                        continue 2;
                                    }
                                    if (preg_match('/\\b' . preg_quote($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 2;
                                    }
                                    break;
                                default:
                                    // Intentionally left blank
                            }
                        }
                    }
                }
            }
            if ($fieldExists === false) {
                $typeDetails['showitem'] = ‪self::executePositionedStringInsertion(
                    $typeDetails['showitem'],
                    $newFieldsString,
                    $newPosition !== '' ? $newPosition : $position
                );
            }
        }
        unset($typeDetails);
    }
 
    public static function ‪addFieldsToAllPalettesOfField(string $table, string $field, string $addFields, string $insertionPosition = ''): void
    {
        if (!isset(‪$GLOBALS['TCA'][$table]['columns'][$field])) {
            return;
        }
        if (!is_array(‪$GLOBALS['TCA'][$table]['types'])) {
            return;
        }
 
        // Iterate through all types and search for the field that defines the palette to be extended
        foreach (‪$GLOBALS['TCA'][$table]['types'] as $typeName => $typeArray) {
            // Continue if types has no showitem at all or if requested field is not in it
            if (!isset($typeArray['showitem']) || !str_contains($typeArray['showitem'], $field)) {
                continue;
            }
            $fieldArrayWithOptions = ‪GeneralUtility::trimExplode(',', $typeArray['showitem']);
            // Find the field we're handling
            $newFieldStringArray = [];
            foreach ($fieldArrayWithOptions as $fieldNumber => $fieldString) {
                $newFieldStringArray[] = $fieldString;
                $fieldArray = ‪GeneralUtility::trimExplode(';', $fieldString);
                if ($fieldArray[0] !== $field) {
                    continue;
                }
                if (
                    isset($fieldArrayWithOptions[$fieldNumber + 1])
                    && str_starts_with($fieldArrayWithOptions[$fieldNumber + 1], '--palette--')
                ) {
                    // Match for $field and next field is a palette - add fields to this one
                    $paletteName = ‪GeneralUtility::trimExplode(';', $fieldArrayWithOptions[$fieldNumber + 1]);
                    $paletteName = $paletteName[2];
                    ‪self::addFieldsToPalette($table, $paletteName, $addFields, $insertionPosition);
                } else {
                    // Match for $field but next field is no palette - create a new one
                    $newPaletteName = 'generatedFor-' . $field;
                    ‪self::addFieldsToPalette($table, 'generatedFor-' . $field, $addFields, $insertionPosition);
                    $newFieldStringArray[] = '--palette--;;' . $newPaletteName;
                }
            }
            ‪$GLOBALS['TCA'][$table]['types'][$typeName]['showitem'] = implode(', ', $newFieldStringArray);
        }
    }
 
    public static function ‪addFieldsToPalette(string $table, string $palette, string $addFields, string $insertionPosition = ''): void
    {
        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);
            }
        }
    }
 
    public static function ‪addTcaSelectItem(string $table, string $field, array $item, string $relativeToField = '', string $relativePosition = ''): void
    {
        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 (!isset(‪$GLOBALS['TCA'][$table]['columns'][$field]['config']['items'])
            || !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 ($relativePosition !== '') {
            // Insert at specified position
            $matchedPosition = ‪ArrayUtility::filterByValueRecursive($relativeToField, ‪$GLOBALS['TCA'][$table]['columns'][$field]['config']['items']);
            if (!empty($matchedPosition)) {
                $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, [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;
        }
    }
 
    public static function ‪addTcaSelectItemGroup(string $table, string $field, string $groupId, string $groupLabel, ?string $position = 'bottom'): void
    {
        if (!is_array(‪$GLOBALS['TCA'][$table]['columns'][$field]['config'] ?? null)) {
            throw new \RuntimeException('Given select field item list was not found.', 1586728563);
        }
        $itemGroups = ‪$GLOBALS['TCA'][$table]['columns'][$field]['config']['itemGroups'] ?? [];
        // Group has been defined already, nothing to do
        if (isset($itemGroups[$groupId])) {
            return;
        }
        $position = (string)$position;
        $positionGroupId = '';
        if (str_contains($position, ':')) {
            [$position, $positionGroupId] = explode(':', $position, 2);
        }
        // Referenced group was not not found, just append to the bottom
        if (!isset($itemGroups[$positionGroupId])) {
            $position = 'bottom';
        }
        switch ($position) {
            case 'after':
                $newItemGroups = [];
                foreach ($itemGroups as $existingGroupId => $existingGroupLabel) {
                    $newItemGroups[$existingGroupId] = $existingGroupLabel;
                    if ($positionGroupId === $existingGroupId) {
                        $newItemGroups[$groupId] = $groupLabel;
                    }
                }
                $itemGroups = $newItemGroups;
                break;
            case 'before':
                $newItemGroups = [];
                foreach ($itemGroups as $existingGroupId => $existingGroupLabel) {
                    if ($positionGroupId === $existingGroupId) {
                        $newItemGroups[$groupId] = $groupLabel;
                    }
                    $newItemGroups[$existingGroupId] = $existingGroupLabel;
                }
                $itemGroups = $newItemGroups;
                break;
            case 'top':
                $itemGroups = array_merge([$groupId => $groupLabel], $itemGroups);
                break;
            case 'bottom':
            default:
                $itemGroups[$groupId] = $groupLabel;
        }
        ‪$GLOBALS['TCA'][$table]['columns'][$field]['config']['itemGroups'] = $itemGroups;
    }
 
    public static function ‪getFileFieldTCAConfig(string $fieldName, array $customSettingOverride = [], string $allowedFileExtensions = '', string $disallowedFileExtensions = ''): array
    {
        trigger_error(
            'ExtensionManagementUtility::getFileFieldTCAConfig() will be removed in TYPO3 v13.0. Use TCA type "file" directly instead.',
            E_USER_DEPRECATED
        );
 
        $fileFieldTCAConfig = [
            'type' => 'file',
            'allowed' => $allowedFileExtensions,
            'disallowed'=> $disallowedFileExtensions,
        ];
        ArrayUtility::mergeRecursiveWithOverrule($fileFieldTCAConfig, $customSettingOverride);
        return $fileFieldTCAConfig;
    }
 
    public static function ‪addFieldsToUserSettings(string $addFields, string $insertionPosition = ''): void
    {
        ‪$GLOBALS['TYPO3_USER_SETTINGS']['showitem'] = ‪self::executePositionedStringInsertion(‪$GLOBALS['TYPO3_USER_SETTINGS']['showitem'] ?? '', $addFields, $insertionPosition);
    }
 
    protected static function ‪executePositionedStringInsertion(string $list, string $insertionList, string $insertionPosition = ''): string
    {
        $list = trim($list, ", \t\n\r\0\x0B");
 
        if ($insertionPosition !== '') {
            [$location, $positionName] = ‪GeneralUtility::trimExplode(':', $insertionPosition, false, 2);
        } else {
            $location = '';
            $positionName = '';
        }
 
        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
        $positionName = preg_quote($positionName, '/');
        if (str_contains($positionName, ';;')) {
            $positionName = str_replace(';;', ';[^;]*;', $positionName);
        }
 
        $pattern = ('/(^|,\\s*)(' . $positionName . ')(;[^,$]+)?(,|$)/');
        $newList = match ($location) {
            'after' => preg_replace($pattern, '$1$2$3, ' . $insertionList . '$4', $list),
            'before' => preg_replace($pattern, '$1' . $insertionList . ', $2$3$4', $list),
            'replace' => preg_replace($pattern, '$1' . $insertionList . '$4', $list),
            default => $list,
        };
 
        // When preg_replace did not replace anything; append the $insertionList.
        if ($newList === $list) {
            return $list . ', ' . $insertionList;
        }
        return $newList;
    }
 
    protected static function ‪removeDuplicatesForInsertion(string $insertionList, string $list = ''): string
    {
        $insertionListParts = preg_split('/\\s*,\\s*/', $insertionList);
        $listMatches = [];
        if ($list !== '') {
            preg_match_all('/(?:^|,)\\s*\\b([^;,]+)\\b[^,]*/', $list, $listMatches);
            $listMatches = $listMatches[1];
        }
 
        $cleanInsertionListParts = [];
        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);
    }
 
    public static function ‪allowTableOnStandardPages(string $table): void
    {
        if ($table === '') {
            return;
        }
        $registry = GeneralUtility::makeInstance(PageDoktypeRegistry::class);
        $tables = explode(',', $table);
        foreach ($tables as $singleTable) {
            if (!$registry->isRecordTypeAllowedForDoktype($singleTable, null)) {
                $registry->addAllowedRecordTypes(explode(',', $singleTable));
            }
        }
    }
 
    public static function ‪addModule($main, $sub = '', $position = '', $path = null, $moduleConfiguration = [])
    {
    }
 
    public static function ‪insertModuleFunction($modname, $className, $_unused, $title, $MM_key = 'function', $WS = '')
    {
        // no-op: This is not in use anymore, use Modules.php instead
        // This does not trigger a deprecation message as everything continues to work
    }
 
    public static function ‪addPageTSConfig(string $content): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'] .= chr(10) . $content;
    }
 
    public static function ‪addUserTSConfig(string $content): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultUserTSconfig'] .= chr(10) . $content;
    }
 
    public static function ‪addLLrefForTCAdescr($key, $file)
    {
    }
 
    public static function ‪addNavigationComponent($module, $componentId, $extensionKey)
    {
        trigger_error('ExtensionManagementUtility::addNavigationComponent() will be removed in TYPO3 v13.0. Is not needed anymore. Remove any calls to this method.', E_USER_DEPRECATED);
    }
 
    public static function ‪addCoreNavigationComponent($module, $componentId)
    {
        trigger_error('ExtensionManagementUtility::addCoreNavigationComponent() will be removed in TYPO3 v13.0. Is not needed anymore. Remove any calls to this method.', E_USER_DEPRECATED);
    }
 
    /**************************************
     *
     *   Adding SERVICES features
     *
     ***************************************/
    public static function ‪addService(string $extKey, string $serviceType, string $serviceKey, array $info): void
    {
        if (!$serviceType) {
            throw new \InvalidArgumentException('No serviceType given.', 1507321535);
        }
        $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] ?? false)) {
            // 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 (!empty(‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['available']) && (‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['os'] ?? '') != '') {
            $os_type = ‪Environment::isWindows() ? 'WIN' : 'UNIX';
            $os = ‪GeneralUtility::trimExplode(',', strtoupper(‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['os']));
            if (!in_array($os_type, $os, true)) {
                ‪self::deactivateService($serviceType, $serviceKey);
            }
        }
        // Convert subtype list to array for quicker access
        ‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceSubTypes'] = [];
        $serviceSubTypes = ‪GeneralUtility::trimExplode(',', $info['subtype']);
        foreach ($serviceSubTypes as $subtype) {
            ‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['serviceSubTypes'][$subtype] = $subtype;
        }
    }
 
    public static function ‪findService(string $serviceType, string $serviceSubType = '', array $excludeServiceKeys = []): array|false
    {
        $serviceKey = false;
        $serviceInfo = false;
        $priority = 0;
        $quality = 0;
        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'] ?? false)
                    && (($info['subtype'] ?? null) == $serviceSubType || ($info['serviceSubTypes'][$serviceSubType] ?? false))
                    && ($info['priority'] ?? 0) >= $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;
    }
 
    public static function ‪findServiceByKey(string $serviceKey): array
    {
        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);
    }
 
    public static function ‪isServiceAvailable(string $serviceType, string $serviceKey, array $serviceDetails): bool
    {
        // 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 (!‪CommandUtility::checkCommand($executable)) {
                    ‪self::deactivateService($serviceType, $serviceKey);
                    return false;
                }
            }
        }
        // The service is available
        return true;
    }
 
    public static function ‪deactivateService(string $serviceType, string $serviceKey): void
    {
        // ... maybe it's better to move non-available services to a different array??
        ‪$GLOBALS['T3_SERVICES'][$serviceType][$serviceKey]['available'] = false;
    }
 
    /**************************************
     *
     *   Adding FRONTEND features
     *
     ***************************************/
    public static function ‪addPlugin(array $itemArray, string $type = 'list_type', ?string $extensionKey = null): void
    {
        // $extensionKey is required, but presumably for BC reasons it still lives after $type in the
        // parameter list, and $type is nominally optional.
        if (!isset($extensionKey)) {
            throw new \InvalidArgumentException(
                'No extension key could be determined when calling addPlugin()!'
                . LF
                . 'This method is meant to be called from Configuration/TCA/Overrides files. '
                . '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 (!isset($itemArray[2]) || !$itemArray[2]) {
            // @todo do we really set $itemArray[2], even if we cannot find an icon? (as that means it's set to 'EXT:foobar/')
            $itemArray[2] = 'EXT:' . $extensionKey . '/' . static::getExtensionIcon(static::$packageManager->getPackage($extensionKey)->getPackagePath());
        } elseif ($type === 'CType' && !isset(‪$GLOBALS['TCA']['tt_content']['ctrl']['typeicon_classes'][$itemArray[1]])) {
            // Set the type icon as well
            ‪$GLOBALS['TCA']['tt_content']['ctrl']['typeicon_classes'][$itemArray[1]] = $itemArray[2];
        }
        if (!isset($itemArray[3])) {
            $itemArray[3] = 'default';
        }
        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['value'] ?? '') === (string)$itemArray[1]) {
                    ‪$GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'][$k] = [
                        'label' => $itemArray[0] ?? '',
                        'value' => $itemArray[1] ?? '',
                        'icon' => $itemArray[2],
                        'group' => $itemArray[3],
                    ];
                    return;
                }
            }
            ‪$GLOBALS['TCA']['tt_content']['columns'][$type]['config']['items'][] = [
                'label' => $itemArray[0] ?? '',
                'value' => $itemArray[1] ?? '',
                'icon' => $itemArray[2],
                'group' => $itemArray[3],
            ];
        }
        // Ensure to have at least some basic information available when editing the new type in FormEngine
        if ($type === 'CType' && !isset(‪$GLOBALS['TCA']['tt_content']['types'][$itemArray[1]]) && isset(‪$GLOBALS['TCA']['tt_content']['types']['header'])) {
            ‪$GLOBALS['TCA']['tt_content']['types'][$itemArray[1]] = ‪$GLOBALS['TCA']['tt_content']['types']['header'];
        }
    }
 
    public static function ‪addPiFlexFormValue(string $piKeyToMatch, string $value, string $CTypeToMatch = 'list'): void
    {
        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;
        }
    }
 
    public static function ‪addToInsertRecords(string $table, string $content_table = 'tt_content', string $content_field = 'records'): void
    {
        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;
        }
    }
 
    public static function ‪addPItoST43(string $key, string $_ = '', string $suffix = '', string $type = 'list_type', bool $cacheable = false): void
    {
        $cN = ‪self::getCN($key);
        // General plugin
        $pluginContent = trim('
plugin.' . $cN . $suffix . ' = USER' . ($cacheable ? '' : '_INT') . '
plugin.' . $cN . $suffix . '.userFunc = ' . $cN . $suffix . '->main
');
        ‪self::addTypoScript($key, 'setup', '
# Setting ' . $key . ' plugin TypoScript
' . $pluginContent);
        // Add after defaultContentRendering
        switch ($type) {
            case 'list_type':
                $addLine = 'tt_content.list.20.' . $key . $suffix . ' = < plugin.' . $cN . $suffix;
                break;
            case 'CType':
                $addLine = trim('
tt_content.' . $key . $suffix . ' =< lib.contentElement
tt_content.' . $key . $suffix . ' {
    templateName = Generic
    20 =< plugin.' . $cN . $suffix . '
}
');
                break;
            case 'includeLib':
                $addLine = 'page.1000 = < plugin.' . $cN . $suffix;
                break;
            default:
                $addLine = '';
        }
        if ($addLine) {
            ‪self::addTypoScript($key, 'setup', '
# Setting ' . $key . ' plugin TypoScript
' . $addLine . '
', 'defaultContentRendering');
        }
    }
 
    public static function ‪addStaticFile(string $extKey, string $path, string $title): void
    {
        if (!$extKey) {
            throw new \InvalidArgumentException('No extension key given.', 1507321291);
        }
        if (!$path) {
            throw new \InvalidArgumentException('No file path given.', 1507321297);
        }
        if (is_array(‪$GLOBALS['TCA']['sys_template']['columns'])) {
            $value = str_replace(',', '', 'EXT:' . $extKey . '/' . $path);
            $itemArray = ['label' => trim($title . ' (' . $extKey . ')'), 'value' => $value];
            ‪$GLOBALS['TCA']['sys_template']['columns']['include_static_file']['config']['items'][] = $itemArray;
        }
    }
 
    public static function ‪registerPageTSConfigFile(string $extKey, string $filePath, string $title): void
    {
        if (!$extKey) {
            throw new \InvalidArgumentException('No extension key given.', 1447789490);
        }
        if (!$filePath) {
            throw new \InvalidArgumentException('No file path given.', 1447789491);
        }
        if (!is_array(‪$GLOBALS['TCA']['pages']['columns'] ?? null)) {
            throw new \InvalidArgumentException('No TCA definition for table "pages".', 1447789492);
        }
 
        $value = str_replace(',', '', 'EXT:' . $extKey . '/' . $filePath);
        $itemArray = ['label' => trim($title . ' (' . $extKey . ')'), 'value' => $value];
        ‪$GLOBALS['TCA']['pages']['columns']['tsconfig_includes']['config']['items'][] = $itemArray;
    }
 
    public static function ‪addTypoScriptSetup(string $content): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'] ??= '';
        if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'])) {
            ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'] .= LF;
        }
        ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'] .= $content;
    }
 
    public static function ‪addTypoScriptConstants(string $content): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants'] ??= '';
        if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants'])) {
            ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants'] .= LF;
        }
        ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants'] .= $content;
    }
 
    public static function ‪addTypoScript(string $key, string $type, string $content, int|string $afterStaticUid = 0): void
    {
        if ($type !== 'setup' && $type !== 'constants') {
            throw new \InvalidArgumentException('Argument $type must be set to either "setup" or "constants" when calling addTypoScript from extension "' . $key . '"', 1507321200);
        }
        $content = '
 
[GLOBAL]
#############################################
## TypoScript added by extension "' . $key . '"
#############################################
 
' . $content;
        if ($afterStaticUid) {
            // If 'defaultContentRendering' is targeted (formerly static uid 43),
            // the content is added after TypoScript of type contentRendering, e.g. fluid_styled_content, see
            // EXT:core/Classes/TypoScript/IncludeTree/SysTemplateTreeBuilder.php for more information on how the code is parsed.
            if ($afterStaticUid === 'defaultContentRendering' || $afterStaticUid == 43) {
                ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.']['defaultContentRendering'] ??= '';
                ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.']['defaultContentRendering'] .= $content;
            } else {
                ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.'][$afterStaticUid] ??= '';
                ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type . '.'][$afterStaticUid] .= $content;
            }
        } else {
            ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type] ??= '';
            ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_' . $type] .= $content;
        }
    }
 
    /***************************************
     *
     * Internal extension management methods
     *
     ***************************************/
    public static function ‪getExtensionIcon(string $extensionPath, bool $returnFullPath = false): string
    {
        $icon = '';
        $locationsToCheckFor = [
            'Resources/Public/Icons/Extension.svg',
            'Resources/Public/Icons/Extension.png',
            'Resources/Public/Icons/Extension.gif',
            'ext_icon.svg',
            'ext_icon.png',
            'ext_icon.gif',
        ];
        foreach ($locationsToCheckFor as $fileLocation) {
            if (file_exists($extensionPath . $fileLocation)) {
                $icon = $fileLocation;
                break;
            }
        }
        return $returnFullPath ? $extensionPath . $icon : $icon;
    }
 
    public static function ‪loadExtLocalconf(bool $allowCaching = true, ‪FrontendInterface $codeCache = null): void
    {
        if ($allowCaching) {
            $codeCache = $codeCache ?? ‪self::getCacheManager()->getCache('core');
            $cacheIdentifier = ‪self::getExtLocalconfCacheIdentifier();
            $hasCache = $codeCache->require($cacheIdentifier) !== false;
            if (!$hasCache) {
                ‪self::loadSingleExtLocalconfFiles();
                ‪self::createExtLocalconfCacheEntry($codeCache);
            }
        } else {
            ‪self::loadSingleExtLocalconfFiles();
        }
    }
 
    protected static function ‪loadSingleExtLocalconfFiles(): void
    {
        foreach (static::$packageManager->getActivePackages() as $package) {
            $extLocalconfPath = $package->getPackagePath() . 'ext_localconf.php';
            if (file_exists($extLocalconfPath)) {
                require $extLocalconfPath;
            }
        }
    }
 
    public static function ‪createExtLocalconfCacheEntry(‪FrontendInterface $codeCache): void
    {
        $phpCodeToCache = [];
        // Set same globals as in loadSingleExtLocalconfFiles()
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = '';
        // Iterate through loaded extensions and add ext_localconf content
        foreach (static::$packageManager->getActivePackages() as $package) {
            $extensionKey = $package->getPackageKey();
            $extLocalconfPath = $package->getPackagePath() . 'ext_localconf.php';
            if (@file_exists($extLocalconfPath)) {
                // Include a header per extension to make the cache file more readable
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
                // Add ext_localconf.php content of extension
                $phpCodeToCache[] = 'namespace {';
                $phpCodeToCache[] = trim((string)file_get_contents($extLocalconfPath));
                $phpCodeToCache[] = '}';
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
            }
        }
        $phpCodeToCache = implode(LF, $phpCodeToCache);
        // Remove all start and ending php tags from content
        $phpCodeToCache = preg_replace('/<\\?php|\\?>/is', '', $phpCodeToCache);
        $phpCodeToCache = preg_replace('/declare\\s?+\\(\\s?+strict_types\\s?+=\\s?+1\\s?+\\);/is', '', (string)$phpCodeToCache);
        $codeCache->‪set(self::getExtLocalconfCacheIdentifier(), $phpCodeToCache);
    }
 
    protected static function ‪getExtLocalconfCacheIdentifier(): string
    {
        return (new ‪PackageDependentCacheIdentifier(self::$packageManager))->withPrefix('ext_localconf')->toString();
    }
 
    public static function ‪loadBaseTca(bool $allowCaching = true, ‪FrontendInterface $codeCache = null): void
    {
        if ($allowCaching) {
            $codeCache = $codeCache ?? ‪self::getCacheManager()->getCache('core');
            $cacheIdentifier = static::getBaseTcaCacheIdentifier();
            $cacheData = $codeCache->require($cacheIdentifier);
            if ($cacheData) {
                ‪$GLOBALS['TCA'] = $cacheData['tca'];
            } else {
                static::buildBaseTcaFromSingleFiles();
                static::createBaseTcaCacheFile($codeCache);
            }
        } else {
            static::buildBaseTcaFromSingleFiles();
        }
 
        $allowedRecordTypesForDefault = [];
        foreach (‪$GLOBALS['TCA'] as $table => $tableConfiguration) {
            if ($tableConfiguration['ctrl']['security']['ignorePageTypeRestriction'] ?? false) {
                $allowedRecordTypesForDefault[] = $table;
            }
        }
        GeneralUtility::makeInstance(PageDoktypeRegistry::class)->addAllowedRecordTypes($allowedRecordTypesForDefault);
    }
 
    public static function ‪buildBaseTcaFromSingleFiles(): void
    {
        ‪$GLOBALS['TCA'] = [];
 
        $activePackages = static::$packageManager->getActivePackages();
 
        // To require TCA in a safe scoped environment avoiding local variable clashes.
        // @see TYPO3\CMS\Core\Tests\Functional\Utility\ExtensionManagementUtility\ExtensionManagementUtilityTcaRequireTest
        // Note: Return type 'mixed' is intended, otherwise broken TCA files with missing "return [];" statement would
        //       emit a "return value must be of type array, int returned" PHP TypeError. This is mitigated by an array
        //       check below.
        $scopedReturnRequire = static function (string $filename): mixed {
            return require $filename;
        };
        // First load "full table" files from Configuration/TCA
        foreach ($activePackages as $package) {
            try {
                ‪$finder = Finder::create()->files()->sortByName()->depth(0)->name('*.php')->in($package->getPackagePath() . 'Configuration/TCA');
            } catch (\InvalidArgumentException $e) {
                // No such directory in this package
                continue;
            }
            foreach (‪$finder as $fileInfo) {
                $tcaOfTable = $scopedReturnRequire($fileInfo->getPathname());
                if (is_array($tcaOfTable)) {
                    $tcaTableName = substr($fileInfo->getBasename(), 0, -4);
                    ‪$GLOBALS['TCA'][$tcaTableName] = $tcaOfTable;
                }
            }
        }
 
        // To require TCA Overrides in a safe scoped environment avoiding local variable clashes.
        // @see TYPO3\CMS\Core\Tests\Functional\Utility\ExtensionManagementUtility\ExtensionManagementUtilityTcaOverrideRequireTest
        $scopedRequire = static function (string $filename): void {
            require $filename;
        };
        // Execute override files from Configuration/TCA/Overrides
        foreach ($activePackages as $package) {
            try {
                ‪$finder = Finder::create()->files()->sortByName()->depth(0)->name('*.php')->in($package->getPackagePath() . 'Configuration/TCA/Overrides');
            } catch (\InvalidArgumentException $e) {
                // No such directory in this package
                continue;
            }
            foreach (‪$finder as $fileInfo) {
                $scopedRequire($fileInfo->getPathname());
            }
        }
 
        // Call the TcaMigration and log any deprecations.
        $tcaMigration = GeneralUtility::makeInstance(TcaMigration::class);
        ‪$GLOBALS['TCA'] = $tcaMigration->migrate(‪$GLOBALS['TCA']);
        $messages = $tcaMigration->getMessages();
        if (!empty($messages)) {
            $context = 'Automatic TCA migration done during bootstrap. Please adapt TCA accordingly, these migrations'
                . ' will be removed. The backend module "Configuration -> TCA" shows the modified values.'
                . ' Please adapt these areas:';
            array_unshift($messages, $context);
            trigger_error(implode(LF, $messages), E_USER_DEPRECATED);
        }
 
        // TCA preparation
        $tcaPreparation = GeneralUtility::makeInstance(TcaPreparation::class);
        ‪$GLOBALS['TCA'] = $tcaPreparation->prepare(‪$GLOBALS['TCA']);
 
        static::dispatchTcaIsBeingBuiltEvent(‪$GLOBALS['TCA']);
    }
 
    protected static function ‪dispatchTcaIsBeingBuiltEvent(array ‪$tca): void
    {
        ‪$GLOBALS['TCA'] = static::$eventDispatcher->dispatch(new ‪AfterTcaCompilationEvent(‪$tca))->getTca();
    }
 
    public static function ‪createBaseTcaCacheFile(‪FrontendInterface $codeCache): void
    {
        $codeCache->‪set(
            static::getBaseTcaCacheIdentifier(),
            'return '
                . var_export(['tca' => ‪$GLOBALS['TCA']], true)
                . ';'
        );
    }
 
    protected static function ‪getBaseTcaCacheIdentifier(): string
    {
        return (new ‪PackageDependentCacheIdentifier(self::$packageManager))->withPrefix('tca_base')->toString();
    }
 
    public static function ‪loadExtTables(bool $allowCaching = true, ‪FrontendInterface $codeCache = null): void
    {
        if ($allowCaching && !self::$extTablesWasReadFromCacheOnce) {
            self::$extTablesWasReadFromCacheOnce = true;
            $cacheIdentifier = ‪self::getExtTablesCacheIdentifier();
            $codeCache = $codeCache ?? ‪self::getCacheManager()->getCache('core');
            $hasCache = $codeCache->require($cacheIdentifier) !== false;
            if (!$hasCache) {
                ‪self::loadSingleExtTablesFiles();
                ‪self::createExtTablesCacheEntry($codeCache);
            }
        } else {
            ‪self::loadSingleExtTablesFiles();
        }
    }
 
    protected static function ‪loadSingleExtTablesFiles(): void
    {
        // Load each ext_tables.php file of loaded extensions
        foreach (static::$packageManager->getActivePackages() as $package) {
            $extTablesPath = $package->getPackagePath() . 'ext_tables.php';
            if (@file_exists($extTablesPath)) {
                require $extTablesPath;
            }
        }
    }
 
    public static function ‪createExtTablesCacheEntry(‪FrontendInterface $codeCache): void
    {
        $phpCodeToCache = [];
        // Set same globals as in loadSingleExtTablesFiles()
        $phpCodeToCache[] = '';
        $phpCodeToCache[] = '';
        // Iterate through loaded extensions and add ext_tables content
        foreach (static::$packageManager->getActivePackages() as $package) {
            $extensionKey = $package->getPackageKey();
            $extTablesPath = $package->getPackagePath() . 'ext_tables.php';
            if (@file_exists($extTablesPath)) {
                // Include a header per extension to make the cache file more readable
                $phpCodeToCache[] = '';
                $phpCodeToCache[] = '';
                // Add ext_tables.php content of extension
                $phpCodeToCache[] = 'namespace {';
                $phpCodeToCache[] = trim((string)file_get_contents($extTablesPath));
                $phpCodeToCache[] = '}';
                $phpCodeToCache[] = '';
            }
        }
        $phpCodeToCache = implode(LF, $phpCodeToCache);
        // Remove all start and ending php tags from content
        $phpCodeToCache = preg_replace('/<\\?php|\\?>/is', '', $phpCodeToCache);
        $phpCodeToCache = preg_replace('/declare\\s?+\\(\\s?+strict_types\\s?+=\\s?+1\\s?+\\);/is', '', (string)$phpCodeToCache);
        $codeCache->‪set(self::getExtTablesCacheIdentifier(), $phpCodeToCache);
    }
 
    protected static function ‪getExtTablesCacheIdentifier(): string
    {
        return (new ‪PackageDependentCacheIdentifier(self::$packageManager))->withPrefix('ext_tables')->toString();
    }
 
    public static function ‪getLoadedExtensionListArray(): array
    {
        return array_keys(static::$packageManager->getActivePackages());
    }
 
    public static function ‪loadExtension(string $extensionKey): void
    {
        if (static::$packageManager->isPackageActive($extensionKey)) {
            throw new \RuntimeException('Extension already loaded', 1342345486);
        }
        static::$packageManager->activatePackage($extensionKey);
    }
 
    public static function ‪unloadExtension(string $extensionKey): void
    {
        if (!static::$packageManager->isPackageActive($extensionKey)) {
            throw new \RuntimeException('Extension not loaded', 1342345487);
        }
        static::$packageManager->deactivatePackage($extensionKey);
    }
}