9.5/_dependency_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\Utility\ExtensionManagementUtility;

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

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

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

use ‪TYPO3\CMS\Extensionmanager\Exception;


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

{

    protected ‪$objectManager;


    protected ‪$extensionRepository;


    protected ‪$listUtility;


    protected ‪$emConfUtility;


    protected ‪$managementService;


    protected ‪$availableExtensions = [];


    protected ‪$localExtensionStorage = '';


    protected ‪$dependencyErrors = [];


    protected ‪$skipDependencyCheck = false;


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

    {

        $this->objectManager = ‪$objectManager;

    }


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

    {

        $this->extensionRepository = ‪$extensionRepository;

    }


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

    {

        $this->listUtility = ‪$listUtility;

    }


    public function ‪injectEmConfUtility(\‪TYPO3\CMS\Extensionmanager\Utility\EmConfUtility ‪$emConfUtility)

    {

        $this->emConfUtility = ‪$emConfUtility;

    }


    public function ‪injectManagementService(\‪TYPO3\CMS\Extensionmanager\Service\ExtensionManagementService ‪$managementService)

    {

        $this->managementService = ‪$managementService;

    }


    public function ‪setLocalExtensionStorage(‪$localExtensionStorage)

    {

        $this->localExtensionStorage = ‪$localExtensionStorage;

    }


    protected function ‪setAvailableExtensions()

    {

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

    }


    public function ‪setSkipDependencyCheck(‪$skipDependencyCheck)

    {

        $this->skipDependencyCheck = ‪$skipDependencyCheck;

    }


    public function ‪checkDependencies(‪Extension $extension)

    {

        $this->dependencyErrors = [];

        $dependencies = $extension->‪getDependencies();

        foreach ($dependencies as $dependency) {

            $identifier = strtolower($dependency->getIdentifier());

            try {

                if (in_array($identifier, ‪Dependency::$specialDependencies)) {

                    if (!$this->skipDependencyCheck) {

                        $methodName = 'check' . ucfirst($identifier) . 'Dependency';

                        $this->{$methodName}($dependency);

                    }

                } else {

                    if ($dependency->getType() === 'depends') {

                        $this->‪checkExtensionDependency($dependency);

                    }

                }

            } catch (Exception\UnresolvedDependencyException $e) {

                if (in_array($identifier, ‪Dependency::$specialDependencies)) {

                    $extensionKey = $extension->‪getExtensionKey();

                } else {

                    $extensionKey = $identifier;

                }

                if (!isset($this->dependencyErrors[$extensionKey])) {

                    $this->dependencyErrors[$extensionKey] = [];

                }

                $this->dependencyErrors[$extensionKey][] = [

                    'code' => $e->getCode(),

                    'message' => $e->getMessage()

                ];

            }

        }

    }


    public function ‪hasDependencyErrors()

    {

        return !empty($this->dependencyErrors);

    }


    public function ‪getDependencyErrors()

    {

        return ‪$this->dependencyErrors;

    }


    protected function ‪checkTypo3Dependency(‪Dependency $dependency)

    {

        $lowerCaseIdentifier = strtolower($dependency->‪getIdentifier());

        if ($lowerCaseIdentifier === 'typo3') {

            if (!($dependency->‪getLowestVersion() === '') && version_compare(‪VersionNumberUtility::getNumericTypo3Version(), $dependency->‪getLowestVersion()) === -1) {

                throw new Exception\UnresolvedTypo3DependencyException(

                    'Your TYPO3 version is lower than this extension requires. It requires TYPO3 versions ' . $dependency->‪getLowestVersion() . ' - ' . $dependency->‪getHighestVersion(),

                    1399144499

                );

            }

            if (!($dependency->‪getHighestVersion() === '') && version_compare($dependency->‪getHighestVersion(), ‪VersionNumberUtility::getNumericTypo3Version()) === -1) {

                throw new Exception\UnresolvedTypo3DependencyException(

                    'Your TYPO3 version is higher than this extension requires. It requires TYPO3 versions ' . $dependency->‪getLowestVersion() . ' - ' . $dependency->‪getHighestVersion(),

                    1399144521

                );

            }

        } else {

            throw new Exception\UnresolvedTypo3DependencyException(

                'checkTypo3Dependency can only check TYPO3 dependencies. Found dependency with identifier "' . $dependency->‪getIdentifier() . '"',

                1399144551

            );

        }

        return true;

    }


    protected function ‪checkPhpDependency(‪Dependency $dependency)

    {

        $lowerCaseIdentifier = strtolower($dependency->‪getIdentifier());

        if ($lowerCaseIdentifier === 'php') {

            if (!($dependency->‪getLowestVersion() === '') && version_compare(PHP_VERSION, $dependency->‪getLowestVersion()) === -1) {

                throw new Exception\UnresolvedPhpDependencyException(

                    'Your PHP version is lower than necessary. You need at least PHP version ' . $dependency->‪getLowestVersion(),

                    1377977857

                );

            }

            if (!($dependency->‪getHighestVersion() === '') && version_compare($dependency->‪getHighestVersion(), PHP_VERSION) === -1) {

                throw new Exception\UnresolvedPhpDependencyException(

                    'Your PHP version is higher than allowed. You can use PHP versions ' . $dependency->‪getLowestVersion() . ' - ' . $dependency->‪getHighestVersion(),

                    1377977856

                );

            }

        } else {

            throw new Exception\UnresolvedPhpDependencyException(

                'checkPhpDependency can only check PHP dependencies. Found dependency with identifier "' . $dependency->‪getIdentifier() . '"',

                1377977858

            );

        }

        return true;

    }


    protected function ‪checkExtensionDependency(Dependency $dependency)

    {

        $extensionKey = $dependency->getIdentifier();

        $extensionIsLoaded = $this->‪isDependentExtensionLoaded($extensionKey);

        if ($extensionIsLoaded === true) {

            $isLoadedVersionCompatible = $this->‪isLoadedVersionCompatible($dependency);

            if ($isLoadedVersionCompatible === true || $this->skipDependencyCheck) {

                return true;

            }

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

            $loadedVersion = $extension->getPackageMetaData()->‪getVersion();

            if (version_compare($loadedVersion, $dependency->getHighestVersion()) === -1) {

                try {

                    $this->‪getExtensionFromRepository($extensionKey, $dependency);

                } catch (Exception\UnresolvedDependencyException $e) {

                    throw new Exception\MissingVersionDependencyException(

                        'The extension ' . $extensionKey . ' is installed in version ' . $loadedVersion

                            . ' but needed in version ' . $dependency->getLowestVersion() . ' - ' . $dependency->getHighestVersion() . ' and could not be fetched from TER',

                        1396302624

                    );

                }

            } else {

                throw new Exception\MissingVersionDependencyException(

                    'The extension ' . $extensionKey . ' is installed in version ' . $loadedVersion .

                    ' but needed in version ' . $dependency->getLowestVersion() . ' - ' . $dependency->getHighestVersion(),

                    1430561927

                );

            }

        } else {

            $extensionIsAvailable = $this->‪isDependentExtensionAvailable($extensionKey);

            if ($extensionIsAvailable === true) {

                $isAvailableVersionCompatible = $this->‪isAvailableVersionCompatible($dependency);

                if ($isAvailableVersionCompatible) {

                    $unresolvedDependencyErrors = ‪$this->dependencyErrors;

                    $this->managementService->markExtensionForInstallation($extensionKey);

                    $this->dependencyErrors = array_merge($unresolvedDependencyErrors, $this->dependencyErrors);

                } else {

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

                    $availableVersion = $extension->getPackageMetaData()->‪getVersion();

                    if (version_compare($availableVersion, $dependency->getHighestVersion()) === -1) {

                        try {

                            $this->‪getExtensionFromRepository($extensionKey, $dependency);

                        } catch (Exception\MissingExtensionDependencyException $e) {

                            if (!$this->skipDependencyCheck) {

                                throw new Exception\MissingVersionDependencyException(

                                    'The extension ' . $extensionKey . ' is available in version ' . $availableVersion

                                    . ' but is needed in version ' . $dependency->getLowestVersion() . ' - ' . $dependency->getHighestVersion() . ' and could not be fetched from TER',

                                    1430560390

                                );

                            }

                        }

                    } else {

                        if (!$this->skipDependencyCheck) {

                            throw new Exception\MissingVersionDependencyException(

                                'The extension ' . $extensionKey . ' is available in version ' . $availableVersion

                                . ' but is needed in version ' . $dependency->getLowestVersion() . ' - ' . $dependency->getHighestVersion(),

                                1430562374

                            );

                        }

                        // Dependency check is skipped and the local version has to be installed

                        $this->managementService->markExtensionForInstallation($extensionKey);

                    }

                }

            } else {

                $unresolvedDependencyErrors = ‪$this->dependencyErrors;

                $this->‪getExtensionFromRepository($extensionKey, $dependency);

                $this->dependencyErrors = array_merge($unresolvedDependencyErrors, $this->dependencyErrors);

            }

        }


        return false;

    }


    protected function ‪getExtensionFromRepository($extensionKey, ‪Dependency $dependency)

    {

        if (!$this->‪getExtensionFromInExtensionRepository($extensionKey)) {

            $this->‪getExtensionFromTer($extensionKey, $dependency);

        }

    }


    protected function ‪getExtensionFromInExtensionRepository($extensionKey)

    {

        if ($this->localExtensionStorage !== '' && is_dir($this->localExtensionStorage)) {

            $extList = \TYPO3\CMS\Core\Utility\GeneralUtility::get_dirs($this->localExtensionStorage);

            if (in_array($extensionKey, $extList)) {

                $this->managementService->markExtensionForCopy($extensionKey, $this->localExtensionStorage);

                return true;

            }

        }

        return false;

    }


    protected function ‪getExtensionFromTer($extensionKey, ‪Dependency $dependency)

    {

        $isExtensionDownloadableFromTer = $this->‪isExtensionDownloadableFromTer($extensionKey);

        if (!$isExtensionDownloadableFromTer) {

            if (!$this->skipDependencyCheck) {

                if ($this->extensionRepository->countAll() > 0) {

                    throw new Exception\MissingExtensionDependencyException(

                        'The extension ' . $extensionKey . ' is not available from TER.',

                        1399161266

                    );

                }

                throw new Exception\MissingExtensionDependencyException(

                    'The extension ' . $extensionKey . ' could not be checked. Please update your Extension-List from TYPO3 Extension Repository (TER).',

                    1430580308

                );

            }

            return;

        }


        $isDownloadableVersionCompatible = $this->‪isDownloadableVersionCompatible($dependency);

        if (!$isDownloadableVersionCompatible) {

            if (!$this->skipDependencyCheck) {

                throw new Exception\MissingVersionDependencyException(

                    'No compatible version found for extension ' . $extensionKey,

                    1399161284

                );

            }

            return;

        }


        $latestCompatibleExtensionByIntegerVersionDependency = $this->‪getLatestCompatibleExtensionByIntegerVersionDependency($dependency);

        if (!$latestCompatibleExtensionByIntegerVersionDependency instanceof ‪Extension) {

            if (!$this->skipDependencyCheck) {

                throw new Exception\MissingExtensionDependencyException(

                    'Could not resolve dependency for "' . $dependency->‪getIdentifier() . '"',

                    1399161302

                );

            }

            return;

        }


        if ($this->‪isDependentExtensionLoaded($extensionKey)) {

            $this->managementService->markExtensionForUpdate($latestCompatibleExtensionByIntegerVersionDependency);

        } else {

            $this->managementService->markExtensionForDownload($latestCompatibleExtensionByIntegerVersionDependency);

        }

    }


    protected function ‪isDependentExtensionLoaded($extensionKey)

    {

        return ‪ExtensionManagementUtility::isLoaded($extensionKey);

    }


    protected function ‪isLoadedVersionCompatible(‪Dependency $dependency)

    {

        $extensionVersion = ‪ExtensionManagementUtility::getExtensionVersion($dependency->‪getIdentifier());

        return $this->‪isVersionCompatible($extensionVersion, $dependency);

    }


    protected function ‪isVersionCompatible($version, ‪Dependency $dependency)

    {

        if (!($dependency->‪getLowestVersion() === '') && version_compare($version, $dependency->‪getLowestVersion()) === -1) {

            return false;

        }

        if (!($dependency->‪getHighestVersion() === '') && version_compare($dependency->‪getHighestVersion(), $version) === -1) {

            return false;

        }

        return true;

    }


    protected function ‪isDependentExtensionAvailable($extensionKey)

    {

        $this->‪setAvailableExtensions();

        return array_key_exists($extensionKey, $this->availableExtensions);

    }


    protected function ‪isAvailableVersionCompatible(‪Dependency $dependency)

    {

        $this->‪setAvailableExtensions();

        $extensionData = $this->emConfUtility->includeEmConf($this->availableExtensions[$dependency->‪getIdentifier()]);

        return $this->‪isVersionCompatible($extensionData['version'], $dependency);

    }


    protected function ‪isExtensionDownloadableFromTer($extensionKey)

    {

        return $this->extensionRepository->countByExtensionKey($extensionKey) > 0;

    }


    protected function ‪isDownloadableVersionCompatible(‪Dependency $dependency)

    {

        $versions = $this->‪getLowestAndHighestIntegerVersions($dependency);

        $count = $this->extensionRepository->countByVersionRangeAndExtensionKey(

            $dependency->‪getIdentifier(),

            $versions['lowestIntegerVersion'],

            $versions['highestIntegerVersion']

        );

        return !empty($count);

    }


    protected function ‪getCompatibleExtension(iterable $extensions): ?‪Extension

    {

        foreach ($extensions as $extension) {

            $this->‪checkDependencies($extension);

            $extensionKey = $extension->getExtensionKey();


            if (isset($this->dependencyErrors[$extensionKey])) {

                // reset dependencyErrors and continue with next version

                unset($this->dependencyErrors[$extensionKey]);

                continue;

            }


            return $extension;

        }


        return null;

    }


    protected function ‪getLatestCompatibleExtensionByIntegerVersionDependency(‪Dependency $dependency)

    {

        $versions = $this->‪getLowestAndHighestIntegerVersions($dependency);

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

            $dependency->‪getIdentifier(),

            $versions['lowestIntegerVersion'],

            $versions['highestIntegerVersion']

        );

        return $this->‪getCompatibleExtension($compatibleDataSets);

    }


    protected function ‪getLowestAndHighestIntegerVersions(‪Dependency $dependency)

    {

        $lowestVersion = $dependency->‪getLowestVersion();

        $lowestVersionInteger = $lowestVersion ? ‪VersionNumberUtility::convertVersionNumberToInteger($lowestVersion) : 0;

        $highestVersion = $dependency->‪getHighestVersion();

        $highestVersionInteger = $highestVersion ? ‪VersionNumberUtility::convertVersionNumberToInteger($highestVersion) : 0;

        return [

            'lowestIntegerVersion' => $lowestVersionInteger,

            'highestIntegerVersion' => $highestVersionInteger

        ];

    }


    public function ‪findInstalledExtensionsThatDependOnMe($extensionKey)

    {

        $availableAndInstalledExtensions = $this->listUtility->getAvailableAndInstalledExtensionsWithAdditionalInformation();

        $dependentExtensions = [];

        foreach ($availableAndInstalledExtensions as $availableAndInstalledExtensionKey => $availableAndInstalledExtension) {

            if (isset($availableAndInstalledExtension['installed']) && $availableAndInstalledExtension['installed'] === true) {

                if (is_array($availableAndInstalledExtension['constraints']) && is_array($availableAndInstalledExtension['constraints']['depends']) && array_key_exists($extensionKey, $availableAndInstalledExtension['constraints']['depends'])) {

                    $dependentExtensions[] = $availableAndInstalledExtensionKey;

                }

            }

        }

        return $dependentExtensions;

    }


    public function ‪getExtensionsSuitableForTypo3Version($extensions)

    {

        $suitableExtensions = [];

        foreach ($extensions as $extension) {

            foreach ($extension->getDependencies() as $dependency) {

                if ($dependency->getIdentifier() === 'typo3') {

                    try {

                        if ($this->‪checkTypo3Dependency($dependency)) {

                            $suitableExtensions[] = $extension;

                        }

                    } catch (‪Exception\‪UnresolvedTypo3DependencyException $e) {

                    }

                    break;

                }

            }

        }

        return $suitableExtensions;

    }


    public function ‪filterYoungestVersionOfExtensionList(array $extensions, $showUnsuitable)

    {

        if (!$showUnsuitable) {

            $extensions = $this->‪getExtensionsSuitableForTypo3Version($extensions);

        }

        $filteredExtensions = [];

        foreach ($extensions as $extension) {

            $extensionKey = $extension->getExtensionKey();

            if (!array_key_exists($extensionKey, $filteredExtensions)) {

                $filteredExtensions[$extensionKey] = $extension;

                continue;

            }

            $currentVersion = $filteredExtensions[$extensionKey]->getVersion();

            $newVersion = $extension->getVersion();

            if (version_compare($newVersion, $currentVersion, '>')) {

                $filteredExtensions[$extensionKey] = $extension;

            }

        }

        return $filteredExtensions;

    }

}