9.5/_install_utility_8php_source.html

<?php

namespace ‪TYPO3\CMS\Extensionmanager\Utility;


/*

 * 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!

 */


use ‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration;

use ‪TYPO3\CMS\Core\Core\Environment;

use ‪TYPO3\CMS\Core\Database\Schema\SchemaMigrator;

use ‪TYPO3\CMS\Core\Database\Schema\SqlReader;

use ‪TYPO3\CMS\Core\Service\OpcodeCacheService;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Extensionmanager\Domain\Model\Extension;

use ‪TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;

use ‪TYPO3\CMS\Impexp\Utility\ImportExportUtility;


class ‪InstallUtility implements ‪\TYPO3\CMS\Core\SingletonInterface

{

    public ‪$objectManager;


    protected ‪$dependencyUtility;


    protected ‪$fileHandlingUtility;


    protected ‪$listUtility;


    public ‪$extensionRepository;


    protected ‪$packageManager;


    protected ‪$cacheManager;


    protected ‪$signalSlotDispatcher;


    protected ‪$registry;


    public function ‪injectObjectManager(\‪TYPO3\CMS\‪Extbase\Object\ObjectManager ‪$objectManager)

    {

        $this->objectManager = ‪$objectManager;

    }


    public function ‪injectDependencyUtility(\‪TYPO3\CMS\Extensionmanager\Utility\‪DependencyUtility ‪$dependencyUtility)

    {

        $this->dependencyUtility = ‪$dependencyUtility;

    }


    public function ‪injectFileHandlingUtility(\‪TYPO3\CMS\Extensionmanager\Utility\FileHandlingUtility ‪$fileHandlingUtility)

    {

        $this->fileHandlingUtility = ‪$fileHandlingUtility;

    }


    public function ‪injectListUtility(\‪TYPO3\CMS\Extensionmanager\Utility\ListUtility ‪$listUtility)

    {

        $this->listUtility = ‪$listUtility;

    }


    public function ‪injectExtensionRepository(\‪TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository ‪$extensionRepository)

    {

        $this->extensionRepository = ‪$extensionRepository;

    }


    public function ‪injectPackageManager(\‪TYPO3\CMS\Core\Package\PackageManager ‪$packageManager)

    {

        $this->packageManager = ‪$packageManager;

    }


    public function ‪injectCacheManager(\‪TYPO3\CMS\Core\Cache\CacheManager ‪$cacheManager)

    {

        $this->cacheManager = ‪$cacheManager;

    }


    public function ‪injectSignalSlotDispatcher(\‪TYPO3\CMS\‪Extbase\SignalSlot\Dispatcher ‪$signalSlotDispatcher)

    {

        $this->signalSlotDispatcher = ‪$signalSlotDispatcher;

    }


    public function ‪injectRegistry(\‪TYPO3\CMS\Core\Registry ‪$registry)

    {

        $this->registry = ‪$registry;

    }


    public function ‪install(...$extensionKeys)

    {

        $flushCaches = false;

        foreach ($extensionKeys as $extensionKey) {

            $this->‪loadExtension($extensionKey);

            $extension = $this->‪enrichExtensionWithDetails($extensionKey, false);

            $this->‪saveDefaultConfiguration($extensionKey);

            if (!empty($extension['clearcacheonload']) || !empty($extension['clearCacheOnLoad'])) {

                $flushCaches = true;

            }

        }


        if ($flushCaches) {

            $this->cacheManager->flushCaches();

        } else {

            $this->cacheManager->flushCachesInGroup('system');

        }

        $this->‪reloadCaches();

        $this->‪updateDatabase($extensionKeys);


        foreach ($extensionKeys as $extensionKey) {

            $this->‪processExtensionSetup($extensionKey);

            $this->‪emitAfterExtensionInstallSignal($extensionKey);

        }

    }


    public function ‪processExtensionSetup($extensionKey)

    {

        $extension = $this->‪enrichExtensionWithDetails($extensionKey, false);

        $this->‪ensureConfiguredDirectoriesExist($extension);

        $this->‪importInitialFiles($extension['siteRelPath'] ?? '', $extensionKey);

        $this->‪importStaticSqlFile($extension['siteRelPath']);

        $this->‪importT3DFile($extension['siteRelPath']);

    }


    public function ‪uninstall($extensionKey)

    {

        $dependentExtensions = $this->dependencyUtility->findInstalledExtensionsThatDependOnMe($extensionKey);

        if (is_array($dependentExtensions) && !empty($dependentExtensions)) {

            throw new ‪ExtensionManagerException(

                \‪TYPO3\CMS\‪Extbase\Utility\LocalizationUtility::translate(

                    'extensionList.uninstall.dependencyError',

                    'extensionmanager',

                    [$extensionKey, implode(',', $dependentExtensions)]

                ),

                1342554622

            );

        }

        $this->‪unloadExtension($extensionKey);

    }


    public function ‪isLoaded($extensionKey)

    {

        return $this->packageManager->isPackageActive($extensionKey);

    }


    public function ‪reloadAvailableExtensions()

    {

        $this->listUtility->reloadAvailableExtensions();

    }


    protected function ‪loadExtension($extensionKey)

    {

        $this->packageManager->activatePackage($extensionKey);

    }


    protected function ‪unloadExtension($extensionKey)

    {

        $this->packageManager->deactivatePackage($extensionKey);

        $this->‪emitAfterExtensionUninstallSignal($extensionKey);

        $this->cacheManager->flushCachesInGroup('system');

    }


    protected function ‪emitAfterExtensionInstallSignal($extensionKey)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionInstall', [$extensionKey, $this]);

    }


    protected function ‪emitAfterExtensionUninstallSignal($extensionKey)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionUninstall', [$extensionKey, $this]);

    }


    public function ‪isAvailable($extensionKey)

    {

        return $this->packageManager->isPackageAvailable($extensionKey);

    }


    public function ‪reloadPackageInformation($extensionKey)

    {

        if ($this->packageManager->isPackageAvailable($extensionKey)) {

            $this->‪reloadOpcache();

            $this->packageManager->reloadPackageInformation($extensionKey);

        }

    }


    public function ‪enrichExtensionWithDetails($extensionKey, $loadTerInformation = true)

    {

        $extension = $this->‪getExtensionArray($extensionKey);

        if (!$loadTerInformation) {

            $availableAndInstalledExtensions = $this->listUtility->enrichExtensionsWithEmConfInformation([$extensionKey => $extension]);

        } else {

            $availableAndInstalledExtensions = $this->listUtility->enrichExtensionsWithEmConfAndTerInformation([$extensionKey => $extension]);

        }


        if (!isset($availableAndInstalledExtensions[$extensionKey])) {

            throw new ExtensionManagerException(

                'Please check your uploaded extension "' . $extensionKey . '". The configuration file "ext_emconf.php" seems to be invalid.',

                1391432222

            );

        }


        return $availableAndInstalledExtensions[$extensionKey];

    }


    protected function ‪getExtensionArray($extensionKey)

    {

        $availableExtensions = $this->listUtility->getAvailableExtensions();

        if (isset($availableExtensions[$extensionKey])) {

            return $availableExtensions[$extensionKey];

        }

        throw new ‪ExtensionManagerException('Extension ' . $extensionKey . ' is not available', 1342864081);

    }


    protected function ‪ensureConfiguredDirectoriesExist(array $extension)

    {

        $this->fileHandlingUtility->ensureConfiguredDirectoriesExist($extension);

    }


    public function ‪processDatabaseUpdates(array $extension)

    {

        trigger_error('This method will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);

        $extTablesSqlFile = ‪Environment::getPublicPath() . '/' . $extension['siteRelPath'] . 'ext_tables.sql';

        $extTablesSqlContent = '';

        if (file_exists($extTablesSqlFile)) {

            $extTablesSqlContent .= file_get_contents($extTablesSqlFile);

        }

        if ($extTablesSqlContent !== '') {

            try {

                $this->‪updateDbWithExtTablesSql($extTablesSqlContent);

            } catch (\‪TYPO3\CMS\Core\Database\Schema\Exception\StatementException $e) {

                throw new ExtensionManagerException(

                    $e->getMessage(),

                    1476340371

                );

            }

        }


        $this->‪importStaticSqlFile($extension['siteRelPath']);

        $this->‪importT3DFile($extension['siteRelPath']);

    }


    protected function ‪emitTablesDefinitionIsBeingBuiltSignal($extensionKey)

    {

        $signalReturn = $this->signalSlotDispatcher->dispatch(__CLASS__, 'tablesDefinitionIsBeingBuilt', [[], $extensionKey]);

        // This is important to support old associated returns

        $signalReturn = array_values($signalReturn);

        $sqlString = $signalReturn[0];

        if (!is_array($sqlString)) {

            throw new ExtensionManagerException(

                sprintf(

                    'The signal %s of class %s returned a value of type %s, but array was expected.',

                    'tablesDefinitionIsBeingBuilt',

                    __CLASS__,

                    gettype($sqlString)

                ),

                1382360258

            );

        }

        if (!empty($sqlString)) {

            trigger_error(

                sprintf(

                    'The signal %s of class %s is deprecated and will be removed in TYPO3 v10.0.',

                    'tablesDefinitionIsBeingBuilt',

                    __CLASS__

                ),

                E_USER_DEPRECATED

            );

        }

        return $sqlString;

    }


    public function ‪reloadCaches()

    {

        $this->‪reloadOpcache();

        ‪\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::loadExtLocalconf(false);

        ‪\TYPO3\CMS\Core\Core\Bootstrap::loadBaseTca(false);

        ‪\TYPO3\CMS\Core\Core\Bootstrap::loadExtTables(false);

    }


    protected function ‪reloadOpcache()

    {

        GeneralUtility::makeInstance(OpcodeCacheService::class)->clearAllActive();

    }


    protected function ‪updateDatabase(array $extensionKeys)

    {

        $sqlReader = GeneralUtility::makeInstance(SqlReader::class);

        $schemaMigrator = GeneralUtility::makeInstance(SchemaMigrator::class);

        $sqlStatements = [];

        $sqlStatements[] = $sqlReader->getTablesDefinitionString();

        foreach ($extensionKeys as $extensionKey) {

            $sqlStatements += $this->‪emitTablesDefinitionIsBeingBuiltSignal($extensionKey);

        }

        $sqlStatements = $sqlReader->getCreateTableStatementArray(implode(LF . LF, array_filter($sqlStatements)));

        $updateStatements = $schemaMigrator->getUpdateSuggestions($sqlStatements);


        $updateStatements = array_merge_recursive(...array_values($updateStatements));

        $selectedStatements = [];

        foreach (['add', 'change', 'create_table', 'change_table'] as $action) {

            if (empty($updateStatements[$action])) {

                continue;

            }

            $selectedStatements = array_merge(

                $selectedStatements,

                array_combine(array_keys($updateStatements[$action]), array_fill(0, count($updateStatements[$action]), true))

            );

        }


        $schemaMigrator->migrate($sqlStatements, $selectedStatements);

    }


    protected function ‪saveDefaultConfiguration($extensionKey)

    {

        $extensionConfiguration = $this->objectManager->get(ExtensionConfiguration::class);

        $extensionConfiguration->synchronizeExtConfTemplateWithLocalConfiguration($extensionKey);

    }


    public function ‪updateDbWithExtTablesSql($rawDefinitions)

    {

        trigger_error('This method will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);

        $sqlReader = GeneralUtility::makeInstance(SqlReader::class);

        $statements = $sqlReader->getCreateTableStatementArray($rawDefinitions);

        if (count($statements) !== 0) {

            $schemaMigrationService = GeneralUtility::makeInstance(SchemaMigrator::class);

            $schemaMigrationService->install($statements);

        }

    }


    public function ‪importStaticSql($rawDefinitions)

    {

        $sqlReader = GeneralUtility::makeInstance(SqlReader::class);

        $statements = $sqlReader->getStatementArray($rawDefinitions);


        $schemaMigrationService = GeneralUtility::makeInstance(SchemaMigrator::class);

        $schemaMigrationService->importStaticData($statements, true);

    }


    public function ‪removeExtension($extension)

    {

        $absolutePath = $this->fileHandlingUtility->getAbsoluteExtensionPath($extension);

        if ($this->fileHandlingUtility->isValidExtensionPath($absolutePath)) {

            if ($this->packageManager->isPackageAvailable($extension)) {

                // Package manager deletes the extension and removes the entry from PackageStates.php

                $this->packageManager->deletePackage($extension);

            } else {

                // The extension is not listed in PackageStates.php, we can safely remove it

                $this->fileHandlingUtility->removeDirectory($absolutePath);

            }

        } else {

            throw new ExtensionManagerException('No valid extension path given.', 1342875724);

        }

    }


    public function ‪isUpdateAvailable(‪Extension $extensionData)

    {

        return (bool)$this->‪getUpdateableVersion($extensionData);

    }


    public function ‪getUpdateableVersion(‪Extension $extensionData)

    {

        // Only check for update for TER extensions

        $version = $extensionData->‪getIntegerVersion();


        $extensionUpdates = $this->extensionRepository->findByVersionRangeAndExtensionKeyOrderedByVersion(

            $extensionData->‪getExtensionKey(),

            $version,

            0,

            false

        );

        if ($extensionUpdates->count() > 0) {

            foreach ($extensionUpdates as $extensionUpdate) {

                try {

                    $this->dependencyUtility->checkDependencies($extensionUpdate);

                    if (!$this->dependencyUtility->hasDependencyErrors()) {

                        return $extensionUpdate;

                    }

                } catch (‪ExtensionManagerException $e) {

                }

            }

        }

        return false;

    }


    protected function ‪importT3DFile($extensionSiteRelPath)

    {

        $registryKeysToCheck = [

            $extensionSiteRelPath . 'Initialisation/data.t3d',

            $extensionSiteRelPath . 'Initialisation/dataImported',

        ];

        foreach ($registryKeysToCheck as $registryKeyToCheck) {

            if ($this->registry->get('extensionDataImport', $registryKeyToCheck)) {

                // Data was imported before => early return

                return;

            }

        }

        $importFileToUse = null;

        $possibleImportFiles = [

            $extensionSiteRelPath . 'Initialisation/data.t3d',

            $extensionSiteRelPath . 'Initialisation/data.xml'

        ];

        foreach ($possibleImportFiles as $possibleImportFile) {

            if (!file_exists(‪Environment::getPublicPath() . '/' . $possibleImportFile)) {

                continue;

            }

            $importFileToUse = $possibleImportFile;

        }

        if ($importFileToUse !== null) {

            $importExportUtility = $this->objectManager->get(ImportExportUtility::class);

            try {

                $importResult = $importExportUtility->importT3DFile(‪Environment::getPublicPath() . '/' . $importFileToUse, 0);

                $this->registry->set('extensionDataImport', $extensionSiteRelPath . 'Initialisation/dataImported', 1);

                $this->‪emitAfterExtensionT3DImportSignal($importFileToUse, $importResult);

            } catch (\ErrorException $e) {

                $logger = $this->objectManager->get(\‪TYPO3\CMS\Core\Log\LogManager::class)->getLogger(__CLASS__);

                $logger->log(\‪TYPO3\CMS\Core\Log\LogLevel::WARNING, $e->getMessage());

            }

        }

    }


    protected function ‪emitAfterExtensionT3DImportSignal($importFileToUse, $importResult)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionT3DImport', [$importFileToUse, $importResult, $this]);

    }


    protected function ‪importStaticSqlFile($extensionSiteRelPath)

    {

        $extTablesStaticSqlRelFile = $extensionSiteRelPath . 'ext_tables_static+adt.sql';

        if (!$this->registry->get('extensionDataImport', $extTablesStaticSqlRelFile)) {

            $extTablesStaticSqlFile = ‪Environment::getPublicPath() . '/' . $extTablesStaticSqlRelFile;

            $shortFileHash = '';

            if (file_exists($extTablesStaticSqlFile)) {

                $extTablesStaticSqlContent = file_get_contents($extTablesStaticSqlFile);

                $shortFileHash = md5($extTablesStaticSqlContent);

                $this->‪importStaticSql($extTablesStaticSqlContent);

            }

            $this->registry->set('extensionDataImport', $extTablesStaticSqlRelFile, $shortFileHash);

            $this->‪emitAfterExtensionStaticSqlImportSignal($extTablesStaticSqlRelFile);

        }

    }


    protected function ‪emitAfterExtensionStaticSqlImportSignal($extTablesStaticSqlRelFile)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionStaticSqlImport', [$extTablesStaticSqlRelFile, $this]);

    }


    protected function ‪importInitialFiles($extensionSiteRelPath, $extensionKey)

    {

        $importRelFolder = $extensionSiteRelPath . 'Initialisation/Files';

        if (!$this->registry->get('extensionDataImport', $importRelFolder)) {

            $importFolder = ‪Environment::getPublicPath() . '/' . $importRelFolder;

            if (file_exists($importFolder)) {

                $destinationRelPath = ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'] . $extensionKey;

                $destinationAbsolutePath = ‪Environment::getPublicPath() . '/' . $destinationRelPath;

                if (!file_exists($destinationAbsolutePath) &&

                    GeneralUtility::isAllowedAbsPath($destinationAbsolutePath)

                ) {

                    GeneralUtility::mkdir($destinationAbsolutePath);

                }

                GeneralUtility::copyDirectory($importRelFolder, $destinationRelPath);

                $this->registry->set('extensionDataImport', $importRelFolder, 1);

                $this->‪emitAfterExtensionFileImportSignal($destinationAbsolutePath);

            }

        }

    }


    protected function ‪emitAfterExtensionFileImportSignal($destinationAbsolutePath)

    {

        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionFileImport', [$destinationAbsolutePath, $this]);

    }

}