InstallUtility.php

Go to the documentation of this file.

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

use TYPO3\CMS\Impexp\Utility\ImportExportUtility;
use TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;

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

    public $objectManager;

    public $installToolSqlParser;

    protected $dependencyUtility;

    protected $fileHandlingUtility;

    protected $listUtility;

    protected $databaseUtility;

    public $extensionRepository;

    protected $packageManager;

    protected $cacheManager;

    protected $signalSlotDispatcher;

    protected $registry;

    public function install($extensionKey) {
        $extension = $this->enrichExtensionWithDetails($extensionKey, FALSE);
        $this->ensureConfiguredDirectoriesExist($extension);
        if (!$this->isLoaded($extensionKey)) {
            $this->loadExtension($extensionKey);
        }
        if (!empty($extension['clearcacheonload']) || !empty($extension['clearCacheOnLoad'])) {
            $this->cacheManager->flushCaches();
        } else {
            $this->cacheManager->flushCachesInGroup('system');
        }
        $this->reloadCaches();

        $this->importInitialFiles($extension['siteRelPath'], $extensionKey);
        $this->processDatabaseUpdates($extension);
        $this->processRuntimeDatabaseUpdates($extensionKey);
        $this->saveDefaultConfiguration($extension['key']);
    }

    public function uninstall($extensionKey) {
        $dependentExtensions = $this->dependencyUtility->findInstalledExtensionsThatDependOnMe($extensionKey);
        if (is_array($dependentExtensions) && count($dependentExtensions) > 0) {
            throw new \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException(
                \TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate(
                    'extensionList.uninstall.dependencyError',
                    'extensionmanager',
                    array($extensionKey, implode(',', $dependentExtensions))
                ),
                1342554622
            );
        } else {
            $this->unloadExtension($extensionKey);
        }
    }

    public function isLoaded($extensionKey) {
        return $this->packageManager->isPackageActive($extensionKey);
    }

    protected function loadExtension($extensionKey) {
        $this->packageManager->activatePackage($extensionKey);
    }

    protected function unloadExtension($extensionKey) {
        $this->packageManager->deactivatePackage($extensionKey);
        $this->cacheManager->flushCachesInGroup('system');
    }

    public function isAvailable($extensionKey) {
        return $this->packageManager->isPackageAvailable($extensionKey);
    }

    public function enrichExtensionWithDetails($extensionKey, $loadTerInformation = TRUE) {
        $availableExtensions = $this->listUtility->getAvailableExtensions();
        if (isset($availableExtensions[$extensionKey])) {
            $extension = $availableExtensions[$extensionKey];
        } else {
            throw new \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException('Extension ' . $extensionKey . ' is not available', 1342864081);
        }
        if (!$loadTerInformation) {
            $availableAndInstalledExtensions = $this->listUtility->enrichExtensionsWithEmConfInformation(array($extensionKey => $extension));
        } else {
            $availableAndInstalledExtensions = $this->listUtility->enrichExtensionsWithEmConfAndTerInformation(array($extensionKey => $extension));
        }

        if (!isset($availableAndInstalledExtensions[$extensionKey])) {
            throw new \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException(
                'Please check your uploaded extension "' . $extensionKey . '". The configuration file "ext_emconf.php" seems to be invalid.',
                1391432222
            );
        }

        return $availableAndInstalledExtensions[$extensionKey];
    }

    protected function ensureConfiguredDirectoriesExist(array $extension) {
        $this->fileHandlingUtility->ensureConfiguredDirectoriesExist($extension);
    }

    public function processDatabaseUpdates(array $extension) {
        $extTablesSqlFile = PATH_site . $extension['siteRelPath'] . 'ext_tables.sql';
        $extTablesSqlContent = '';
        if (file_exists($extTablesSqlFile)) {
            $extTablesSqlContent .= \TYPO3\CMS\Core\Utility\GeneralUtility::getUrl($extTablesSqlFile);
        }
        if ($extTablesSqlContent !== '') {
            $this->updateDbWithExtTablesSql($extTablesSqlContent);
        }

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

    protected function processRuntimeDatabaseUpdates($extensionKey) {
        $sqlString = $this->emitTablesDefinitionIsBeingBuiltSignal($extensionKey);
        if (!empty($sqlString)) {
            $this->updateDbWithExtTablesSql(implode(LF . LF . LF . LF, $sqlString));
        }
    }

    protected function emitTablesDefinitionIsBeingBuiltSignal($extensionKey) {
        $signalReturn = $this->signalSlotDispatcher->dispatch(__CLASS__, 'tablesDefinitionIsBeingBuilt', array(array(), $extensionKey));
        // This is important to support old associated returns
        $signalReturn = array_values($signalReturn);
        $sqlString = $signalReturn[0];
        if (!is_array($sqlString)) {
            throw new \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException(
                sprintf(
                    'The signal %s of class %s returned a value of type %s, but array was expected.',
                    'tablesDefinitionIsBeingBuilt',
                    __CLASS__,
                    gettype($sqlString)
                ),
                1382360258
            );
        }
        return $sqlString;
    }

    public function reloadCaches() {
        \TYPO3\CMS\Core\Utility\OpcodeCacheUtility::clearAllActive();
        // Reload class aliases defined in Migrations/Code/ClassAliasMap.php
        \TYPO3\CMS\Core\Core\Bootstrap::getInstance()->getEarlyInstance('TYPO3\\CMS\\Core\\Core\\ClassLoader')
            ->setPackages($this->packageManager->getActivePackages());
        \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::loadExtLocalconf(FALSE);
        \TYPO3\CMS\Core\Core\Bootstrap::getInstance()->loadExtensionTables(FALSE);
    }

    protected function saveDefaultConfiguration($extensionKey) {
        $configUtility = $this->objectManager->get('TYPO3\\CMS\\Extensionmanager\\Utility\\ConfigurationUtility');
        $configUtility->saveDefaultConfiguration($extensionKey);
    }

    public function updateDbWithExtTablesSql($rawDefinitions) {
        $fieldDefinitionsFromFile = $this->installToolSqlParser->getFieldDefinitions_fileContent($rawDefinitions);
        if (count($fieldDefinitionsFromFile)) {
            $fieldDefinitionsFromCurrentDatabase = $this->installToolSqlParser->getFieldDefinitions_database();
            $diff = $this->installToolSqlParser->getDatabaseExtra($fieldDefinitionsFromFile, $fieldDefinitionsFromCurrentDatabase);
            $updateStatements = $this->installToolSqlParser->getUpdateSuggestions($diff);
            $db = $this->getDatabaseConnection();
            foreach ((array) $updateStatements['add'] as $string) {
                $db->admin_query($string);
            }
            foreach ((array) $updateStatements['change'] as $string) {
                $db->admin_query($string);
            }
            foreach ((array) $updateStatements['create_table'] as $string) {
                $db->admin_query($string);
            }
        }
    }

    public function importStaticSql($rawDefinitions) {
        $statements = $this->installToolSqlParser->getStatementarray($rawDefinitions, 1);
        list($statementsPerTable, $insertCount) = $this->installToolSqlParser->getCreateTables($statements, 1);
        $db = $this->getDatabaseConnection();
        // Traverse the tables
        foreach ($statementsPerTable as $table => $query) {
            $db->admin_query('DROP TABLE IF EXISTS ' . $table);
            $db->admin_query($query);
            if ($insertCount[$table]) {
                $insertStatements = $this->installToolSqlParser->getTableInsertStatements($statements, $table);
                foreach ($insertStatements as $statement) {
                    $db->admin_query($statement);
                }
            }
        }
    }

    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 \TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException('No valid extension path given.', 1342875724);
        }
    }

    public function getExtensionSqlDataDump($extension) {
        $extension = $this->enrichExtensionWithDetails($extension);
        $filePrefix = PATH_site . $extension['siteRelPath'];
        $sqlData['extTables'] = $this->getSqlDataDumpForFile($filePrefix . 'ext_tables.sql');
        $sqlData['staticSql'] = $this->getSqlDataDumpForFile($filePrefix . 'ext_tables_static+adt.sql');
        return $sqlData;
    }

    protected function getSqlDataDumpForFile($sqlFile) {
        $sqlData = '';
        if (file_exists($sqlFile)) {
            $sqlContent = \TYPO3\CMS\Core\Utility\GeneralUtility::getUrl($sqlFile);
            $fieldDefinitions = $this->installToolSqlParser->getFieldDefinitions_fileContent($sqlContent);
            $sqlData = $this->databaseUtility->dumpStaticTables($fieldDefinitions);
        }
        return $sqlData;
    }


    public function isUpdateAvailable(\TYPO3\CMS\Extensionmanager\Domain\Model\Extension $extensionData) {
        return (bool)$this->getUpdateableVersion($extensionData);
    }

    public function getUpdateableVersion(\TYPO3\CMS\Extensionmanager\Domain\Model\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 = array(
            $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 = array(
            $extensionSiteRelPath . 'Initialisation/data.t3d',
            $extensionSiteRelPath . 'Initialisation/data.xml'
        );
        foreach ($possibleImportFiles as $possibleImportFile) {
            if (!file_exists(PATH_site . $possibleImportFile)) {
                continue;
            }
            $importFileToUse = $possibleImportFile;
        }
        if ($importFileToUse !== NULL) {
            $importExportUtility = $this->objectManager->get('TYPO3\\CMS\\Impexp\\Utility\\ImportExportUtility');
            try {
                $importResult = $importExportUtility->importT3DFile(PATH_site . $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')->getLogger(__CLASS__);
                $logger->log(\TYPO3\CMS\Core\Log\LogLevel::WARNING, $e->getMessage());
            }
        }
    }

    protected function emitAfterExtensionT3DImportSignal($importFileToUse, $importResult) {
        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionT3DImport', array($importFileToUse, $importResult, $this));
    }

    protected function importStaticSqlFile($extensionSiteRelPath) {
        $extTablesStaticSqlRelFile = $extensionSiteRelPath . 'ext_tables_static+adt.sql';
        if (!$this->registry->get('extensionDataImport', $extTablesStaticSqlRelFile)) {
            $extTablesStaticSqlFile = PATH_site . $extTablesStaticSqlRelFile;
            if (file_exists($extTablesStaticSqlFile)) {
                $extTablesStaticSqlContent = \TYPO3\CMS\Core\Utility\GeneralUtility::getUrl($extTablesStaticSqlFile);
                $this->importStaticSql($extTablesStaticSqlContent);
            }
            $this->registry->set('extensionDataImport', $extTablesStaticSqlRelFile, 1);
            $this->emitAfterExtensionStaticSqlImportSignal($extTablesStaticSqlRelFile);
        }
    }

    protected function emitAfterExtensionStaticSqlImportSignal($extTablesStaticSqlRelFile) {
        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionStaticSqlImport', array($extTablesStaticSqlRelFile, $this));
    }

    protected function importInitialFiles($extensionSiteRelPath, $extensionKey) {
        $importRelFolder = $extensionSiteRelPath . 'Initialisation/Files';
        if (!$this->registry->get('extensionDataImport', $importRelFolder)) {
            $importFolder = PATH_site . $importRelFolder;
            if (file_exists($importFolder)) {
                $destinationRelPath = $GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'] . $extensionKey;
                $destinationAbsolutePath = PATH_site . $destinationRelPath;
                if (!file_exists($destinationAbsolutePath) &&
                    \TYPO3\CMS\Core\Utility\GeneralUtility::isAllowedAbsPath($destinationAbsolutePath)
                ) {
                    \TYPO3\CMS\Core\Utility\GeneralUtility::mkdir($destinationAbsolutePath);
                }
                \TYPO3\CMS\Core\Utility\GeneralUtility::copyDirectory($importRelFolder, $destinationRelPath);
                $this->registry->set('extensionDataImport', $importRelFolder, 1);
                $this->emitAfterExtensionFileImportSignal($destinationAbsolutePath);
            }
        }
    }

    protected function emitAfterExtensionFileImportSignal($destinationAbsolutePath) {
        $this->signalSlotDispatcher->dispatch(__CLASS__, 'afterExtensionFileImport', array($destinationAbsolutePath, $this));
    }

    protected function getDatabaseConnection() {
        return $GLOBALS['TYPO3_DB'];
    }
}