9.5/_extension_management_service_8php_source.html

<?php

namespace ‪TYPO3\CMS\Extensionmanager\Service;


/*

 * 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\Utility\GeneralUtility;

use ‪TYPO3\CMS\Extbase\Object\ObjectManager;

use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;

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


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

{

    protected ‪$downloadQueue;


    protected ‪$dependencyUtility;


    protected ‪$installUtility;


    protected ‪$extensionModelUtility;


    protected ‪$downloadUtility;


    protected ‪$automaticInstallationEnabled = true;


    protected ‪$skipDependencyCheck = false;


    public function ‪injectDownloadQueue(\‪TYPO3\CMS\Extensionmanager\Domain\Model\DownloadQueue ‪$downloadQueue)

    {

        $this->downloadQueue = ‪$downloadQueue;

    }


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

    {

        $this->dependencyUtility = ‪$dependencyUtility;

    }


    public function ‪injectInstallUtility(\‪TYPO3\CMS\Extensionmanager\Utility\InstallUtility ‪$installUtility)

    {

        $this->installUtility = ‪$installUtility;

    }


    public function ‪injectExtensionModelUtility(\‪TYPO3\CMS\Extensionmanager\Utility\ExtensionModelUtility ‪$extensionModelUtility)

    {

        $this->extensionModelUtility = ‪$extensionModelUtility;

    }


    public function ‪injectDownloadUtility(\‪TYPO3\CMS\Extensionmanager\Utility\DownloadUtility ‪$downloadUtility)

    {

        $this->downloadUtility = ‪$downloadUtility;

    }


    public function ‪markExtensionForInstallation($extensionKey)

    {

        // We have to check for dependencies of the extension first, before marking it for installation

        // because this extension might have dependencies, which need to be installed first

        $this->installUtility->reloadAvailableExtensions();

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

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

        $this->downloadQueue->addExtensionToInstallQueue($extension);

    }


    public function ‪markExtensionForCopy($extensionKey, $sourceFolder)

    {

        $this->downloadQueue->addExtensionToCopyQueue($extensionKey, $sourceFolder);

    }


    public function ‪markExtensionForDownload(‪Extension $extension)

    {

        // We have to check for dependencies of the extension first, before marking it for download

        // because this extension might have dependencies, which need to be downloaded and installed first

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

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

            $this->downloadQueue->addExtensionToQueue($extension);

        }

    }


    public function ‪markExtensionForUpdate(Extension $extension)

    {

        // We have to check for dependencies of the extension first, before marking it for download

        // because this extension might have dependencies, which need to be downloaded and installed first

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

        $this->downloadQueue->addExtensionToQueue($extension, 'update');

    }


    public function ‪setSkipDependencyCheck(‪$skipDependencyCheck)

    {

        $this->skipDependencyCheck = ‪$skipDependencyCheck;

    }


    public function ‪setAutomaticInstallationEnabled(‪$automaticInstallationEnabled)

    {

        $this->automaticInstallationEnabled = (bool)‪$automaticInstallationEnabled;

    }


    public function ‪installExtension(‪Extension $extension)

    {

        $this->‪downloadExtension($extension);

        if (!$this->‪checkDependencies($extension)) {

            return false;

        }


        $downloadedDependencies = [];

        $updatedDependencies = [];

        $installQueue = [];


        // First resolve all dependencies and the sub-dependencies until all queues are empty as new extensions might be

        // added each time

        // Extensions have to be installed in reverse order. Extensions which were added at last are dependencies of

        // earlier ones and need to be available before

        while (!$this->downloadQueue->isCopyQueueEmpty()

            || !$this->downloadQueue->isQueueEmpty('download')

            || !$this->downloadQueue->isQueueEmpty('update')

        ) {

            // First copy all available extension

            // This might change other queues again

            $copyQueue = $this->downloadQueue->resetExtensionCopyStorage();

            if (!empty($copyQueue)) {

                $this->‪copyDependencies($copyQueue);

            }

            $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);

            // Get download and update information

            $queue = $this->downloadQueue->resetExtensionQueue();

            if (!empty($queue['download'])) {

                $downloadedDependencies = array_merge($downloadedDependencies, $this->‪downloadDependencies($queue['download']));

            }

            $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);

            if ($this->automaticInstallationEnabled) {

                if (!empty($queue['update'])) {

                    $this->‪downloadDependencies($queue['update']);

                    $updatedDependencies = array_merge($updatedDependencies, $this->‪uninstallDependenciesToBeUpdated($queue['update']));

                }

                $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);

            }

        }


        // If there were any dependency errors we have to abort here

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

            return false;

        }


        // Attach extension to install queue

        $this->downloadQueue->addExtensionToInstallQueue($extension);

        $installQueue += $this->downloadQueue->resetExtensionInstallStorage();

        $installedDependencies = [];

        if ($this->automaticInstallationEnabled) {

            $installedDependencies = $this->‪installDependencies($installQueue);

        }


        return array_merge($downloadedDependencies, $updatedDependencies, $installedDependencies);

    }


    public function ‪getDependencyErrors()

    {

        return $this->dependencyUtility->getDependencyErrors();

    }


    public function ‪getExtension($extensionKey)

    {

        return $this->extensionModelUtility->mapExtensionArrayToModel(

            $this->installUtility->enrichExtensionWithDetails($extensionKey)

        );

    }


    public function ‪isAvailable($extensionKey)

    {

        return $this->installUtility->isAvailable($extensionKey);

    }


    public function ‪reloadPackageInformation($extensionKey)

    {

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

    }


    protected function ‪downloadExtension(‪Extension $extension)

    {

        $this->‪downloadMainExtension($extension);

        $this->‪setInExtensionRepository($extension->‪getExtensionKey());

    }


    protected function ‪checkDependencies(‪Extension $extension)

    {

        $this->dependencyUtility->setSkipDependencyCheck($this->skipDependencyCheck);

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


        return !$this->dependencyUtility->hasDependencyErrors();

    }


    protected function ‪setInExtensionRepository($extensionKey)

    {

        $paths = ‪Extension::returnInstallPaths();

        $path = $paths[$this->downloadUtility->getDownloadPath()];

        $localExtensionStorage = $path . $extensionKey . '/Initialisation/Extensions/';

        $this->dependencyUtility->setLocalExtensionStorage($localExtensionStorage);

    }


    protected function ‪copyDependencies(array $copyQueue)

    {

        $installPaths = ‪Extension::returnAllowedInstallPaths();

        foreach ($copyQueue as $extensionKey => $sourceFolder) {

            $destination = $installPaths['Local'] . $extensionKey;

            GeneralUtility::mkdir($destination);

            GeneralUtility::copyDirectory($sourceFolder . $extensionKey, $destination);

            $this->‪markExtensionForInstallation($extensionKey);

            $this->downloadQueue->removeExtensionFromCopyQueue($extensionKey);

        }

    }


    protected function ‪uninstallDependenciesToBeUpdated(array $updateQueue)

    {

        $resolvedDependencies = [];

        foreach ($updateQueue as $extensionToUpdate) {

            $this->installUtility->uninstall($extensionToUpdate->getExtensionKey());

            $resolvedDependencies['updated'][$extensionToUpdate->getExtensionKey()] = $extensionToUpdate;

        }

        return $resolvedDependencies;

    }


    protected function ‪installDependencies(array $installQueue)

    {

        if (empty($installQueue)) {

            return [];

        }

        $this->‪emitWillInstallExtensionsSignal($installQueue);

        $resolvedDependencies = [];

        $this->installUtility->install(...array_keys($installQueue));

        foreach ($installQueue as $extensionKey => $_) {

            $this->‪emitHasInstalledExtensionSignal($extensionKey);

            if (!isset($resolvedDependencies['installed']) || !is_array($resolvedDependencies['installed'])) {

                $resolvedDependencies['installed'] = [];

            }

            $resolvedDependencies['installed'][$extensionKey] = $extensionKey;

        }

        return $resolvedDependencies;

    }


    protected function ‪downloadDependencies(array ‪$downloadQueue)

    {

        $resolvedDependencies = [];

        foreach (‪$downloadQueue as $extensionToDownload) {

            $this->downloadUtility->download($extensionToDownload);

            $this->downloadQueue->removeExtensionFromQueue($extensionToDownload);

            $resolvedDependencies['downloaded'][$extensionToDownload->getExtensionKey()] = $extensionToDownload;

            $this->‪markExtensionForInstallation($extensionToDownload->getExtensionKey());

        }

        return $resolvedDependencies;

    }


    public function ‪getAndResolveDependencies(‪Extension $extension)

    {

        $this->dependencyUtility->setSkipDependencyCheck($this->skipDependencyCheck);

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

        $installQueue = $this->downloadQueue->getExtensionInstallStorage();

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

            $installQueue = ['install' => $installQueue];

        }

        return array_merge($this->downloadQueue->getExtensionQueue(), $installQueue);

    }


    public function ‪downloadMainExtension(‪Extension $extension)

    {

        // The extension object has a uid if the extension is not present in the system

        // or an update of a present extension is triggered.

        if ($extension->‪getUid()) {

            $this->downloadUtility->download($extension);

        }

    }


    protected function ‪emitWillInstallExtensionsSignal(array $installQueue)

    {

        $this->‪getSignalSlotDispatcher()->‪dispatch(__CLASS__, 'willInstallExtensions', [$installQueue]);

    }


    protected function ‪emitHasInstalledExtensionSignal($extensionKey)

    {

        $this->‪getSignalSlotDispatcher()->‪dispatch(__CLASS__, 'hasInstalledExtensions', [$extensionKey]);

    }


    protected function ‪getSignalSlotDispatcher()

    {

        if (!isset($this->signalSlotDispatcher)) {

            $this->signalSlotDispatcher = GeneralUtility::makeInstance(ObjectManager::class)

                ->get(Dispatcher::class);

        }

        return ‪$this->signalSlotDispatcher;

    }

}