VersionUtility.php

<?php

namespace T3o\TerFe2\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 T3o\TerFe2\Service\LTSVersionService;
use T3o\TerFe2\Domain\Model\Download;
use T3o\TerFe2\Domain\Model\Extension;
use T3o\TerFe2\Domain\Repository\DownloadRepository;
use T3o\TerFe2\Domain\Repository\ExtensionRepository;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;

/**
 * Utilities to manage versions
 */
class VersionUtility
{
    const DOWNLOAD_SOURCE_TER = 1;
    const DOWNLOAD_SOURCE_PACKAGIST = 2;

    /**
     * Returns the three part version number (string) from an integer, eg 4012003 -> '4.12.3'
     *
     * @param int $versionInteger Integer representation of version number
     * @return string Version number as format x.x.x
     * @throws \InvalidArgumentException if $versionInteger is not an integer
     */
    public static function convertIntegerToVersionNumber(int $versionInteger): string
    {
        $versionString = str_pad($versionInteger, 9, '0', STR_PAD_LEFT);
        $parts = [
            substr($versionString, 0, 3),
            substr($versionString, 3, 3),
            substr($versionString, 6, 3),
        ];

        return (int)$parts[0] . '.' . (int)$parts[1] . '.' . (int)$parts[2];
    }

    /**
     * @param \T3o\TerFe2\Domain\Model\Extension $extension
     * @param int $mainVersion
     * @return bool
     */
    public static function doesExtensionSupportTypo3Version(\T3o\TerFe2\Domain\Model\Extension $extension, int $mainVersion): bool
    {
        foreach ($extension->getVersions() as $version) {
            if ($version->getTypo3Dependency() === null || $version->getReviewState() === \T3o\TerFe2\Domain\Model\Version::VERSION_IS_INSECURE) {
                continue;
            }

            if ($version->doesSupportTypo3Version($mainVersion)) {
                return true;
            }
        }

        return false;
    }
    
    /**
     * Generates a list with compatible TYPO3 versions from given dependencies
     *
     * @param array $dependencies
     * @return string
     */
    public static function getCompatibleTypo3Versions(array $dependencies): string
    {
        $compatibleTypo3Versions = [];

        foreach ($dependencies as $relation) {
            if ((string)($relation['kind'] ?? '') !== 'depends'
                || !in_array((string)($relation['extensionKey'] ?? ''), ['typo3', 'cms'], true)
            ) {
                continue;
            }

            $versionRange = (string)($relation['versionRange'] ?? '');

            // Assume all LTS versions are supported
            if ($versionRange === '*') {
                $compatibleTypo3Versions = self::getAllLtsVersionsAsMajor();
                continue;
            }

            // Extract all supported versions form minimal and maximal
            if (strpos($versionRange, '-') !== false) {
                [$min, $max] = explode('-', $versionRange);
                if ($min === null || $min === '0' || $min === '0.0.0') {
                    // Skip if minimal version is not valid
                    continue;
                }
                $min = self::getMajorVersion($min);
                if ($min <= 0 || $max === null) {
                    // Skip if major version could not be extracted or maximal version is not valid
                    continue;
                }
                if ($max === '0' || $max === '0.0.0') {
                    // Assume that all LTS versions between the minimal and the latest LTS are compatible.
                    $compatibleTypo3Versions = self::getVersionRange($min);
                    // Also break the foreach as all information was gathered.
                    break;
                }
                $max = self::getMajorVersion($max);
                if ($max <= 0) {
                    // Only add minimal since maximal could not be extracted
                    $compatibleTypo3Versions[] = $min;
                    continue;
                }
                // Add all major versions between min and max
                $compatibleTypo3Versions = self::getVersionRange($min, $max);
                // Also break the foreach as all information was gathered.
                break;
            }

            // Assume only the minimal version is supported
            if (strpos($versionRange, '.') !== false) {
                $major = self::getMajorVersion($versionRange);
                if ($major > 0) {
                    $compatibleTypo3Versions[] = $major;
                }
            }
        }

        return implode(',', array_unique($compatibleTypo3Versions));
    }

    /**
     * Generates an array of LTS versions with only their major number
     *
     * @return array
     */
    protected static function getAllLtsVersionsAsMajor(): array
    {
        $ltsVersions = GeneralUtility::makeInstance(LTSVersionService::class)->getAllLTSVersions();
        asort($ltsVersions, SORT_NUMERIC);
        foreach ($ltsVersions as &$ltsVersion) {
            $ltsVersion = self::getMajorVersion(self::convertIntegerToVersionNumber($ltsVersion));
        }
        return $ltsVersions;
    }

    /**
     * Generate range for min and max by removing invalid version numbers
     *
     * @param int $min
     * @param int|null $max
     * @return array
     */
    protected static function getVersionRange(int $min, int $max = null): array
    {
        $allLtsVersions = self::getAllLtsVersionsAsMajor();
        $max = (int)($max ?? end($allLtsVersions) ?: 0);

        if ($max <= 0) {
            return [];
        }

        $range = range($min, $max);
        foreach ($range as $key => $version) {
            if (!in_array($version, $allLtsVersions, true)) {
                unset($range[$key]);
            }
        }

        return $range;
    }

    /**
     * Extract the major version from version string
     *
     * @param string $versionString
     * @return int
     */
    protected static function getMajorVersion(string $versionString): int
    {
        $parts = explode('.', $versionString) ?: [];
        return (int)array_shift($parts);
    }

    /**
     * @param string $extensionKey
     * @param int $versionId
     * @param int $source
     * @param int $counter
     *
     * @throws \TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException
     * @throws \TYPO3\CMS\Extbase\Persistence\Exception\InvalidQueryException
     * @throws \TYPO3\CMS\Extbase\Persistence\Exception\UnknownObjectException
     */
    public static function updateVersionCounter(String $extensionKey, int $versionId, int $source = self::DOWNLOAD_SOURCE_TER, int $counter = 1)
    {
        $objectManager = GeneralUtility::makeInstance(ObjectManager::class);
        $persistenceManager = $objectManager->get(PersistenceManager::class);
        $extensionRepository = $objectManager->get(ExtensionRepository::class);


        $month = date('Ym');
        $downloadRepository = $objectManager->get(DownloadRepository::class);

        /** @var Download $downloadInfo */
        $downloadInfo = $downloadRepository->findDownloadCounterByMonthAndExtensionKey($month, $extensionKey, $versionId, $source);

        if (null === $downloadInfo) {
            $downloadInfo = new Download();
            $downloadInfo->setExtensionKey($extensionKey);
            $downloadInfo->setSource($source);
            $downloadInfo->setMonth($month);
            $downloadInfo->setVersionId($versionId);
            $downloadInfo->setCounter($counter);
            $downloadRepository->add($downloadInfo);
        } elseif ($downloadInfo->getCounter() > 0) {
            $downloadInfo->setCounter($downloadInfo->getCounter() + 1);
            $downloadRepository->update($downloadInfo);
        }

        // Sets Extension Last Download Sync to secure oldest syncs happens first.
        /** @var Extension $extension */
        $extension = $extensionRepository->findOneByExtKey($extensionKey);
        $extension->setLastDownloadSync(time());
        $extensionRepository->update($extension);

        $persistenceManager->persistAll();
    }
}