9.5/_upgrade_controller_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Install\Controller;


/*

 * 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 PhpParser\NodeTraverser;

use PhpParser\NodeVisitor\NameResolver;

use PhpParser\ParserFactory;

use Psr\Http\Message\ResponseInterface;

use Psr\Http\Message\ServerRequestInterface;

use Symfony\Component\Finder\Finder;

use Symfony\Component\Finder\SplFileInfo;

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

use ‪TYPO3\CMS\Core\Database\ConnectionPool;

use ‪TYPO3\CMS\Core\Database\Schema\Exception\StatementException;

use ‪TYPO3\CMS\Core\FormProtection\FormProtectionFactory;

use ‪TYPO3\CMS\Core\FormProtection\InstallToolFormProtection;

use ‪TYPO3\CMS\Core\Http\JsonResponse;

use ‪TYPO3\CMS\Core\Messaging\FlashMessage;

use ‪TYPO3\CMS\Core\Messaging\FlashMessageQueue;

use ‪TYPO3\CMS\Core\Migrations\TcaMigration;

use ‪TYPO3\CMS\Core\Package\PackageInterface;

use TYPO3\CMS\Core\Package\PackageManager;

use ‪TYPO3\CMS\Core\Registry;

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

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

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

use ‪TYPO3\CMS\Install\CoreVersion\CoreRelease;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\CodeStatistics;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\GeneratorClassesResolver;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ArrayDimensionMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ArrayGlobalMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ClassConstantMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ClassNameMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ConstantMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\ConstructorArgumentMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\FunctionCallMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\InterfaceMethodChangedMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodAnnotationMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodArgumentDroppedMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodArgumentDroppedStaticMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodArgumentRequiredMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodArgumentRequiredStaticMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodArgumentUnusedMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodCallMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\MethodCallStaticMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\PropertyAnnotationMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\PropertyExistsStaticMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\PropertyProtectedMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\Matcher\PropertyPublicMatcher;

use ‪TYPO3\CMS\Install\ExtensionScanner\Php\MatcherFactory;

use ‪TYPO3\CMS\Install\Service\ClearCacheService;

use ‪TYPO3\CMS\Install\Service\CoreUpdateService;

use TYPO3\CMS\Install\Service\CoreVersionService;

use ‪TYPO3\CMS\Install\Service\LoadTcaService;

use ‪TYPO3\CMS\Install\Service\UpgradeWizardsService;

use ‪TYPO3\CMS\Install\UpgradeAnalysis\DocumentationFile;


class ‪UpgradeController extends ‪AbstractController

{

    protected ‪$coreUpdateService;


    protected ‪$coreVersionService;


    protected ‪$packageManager;


    public function ‪__construct(PackageManager ‪$packageManager = null)

    {

        $this->packageManager = ‪$packageManager ?? GeneralUtility::makeInstance(PackageManager::class);

    }


    protected ‪$matchers = [

        [

            'class' => ArrayDimensionMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ArrayDimensionMatcher.php',

        ],

        [

            'class' => ArrayGlobalMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ArrayGlobalMatcher.php',

        ],

        [

            'class' => ClassConstantMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ClassConstantMatcher.php',

        ],

        [

            'class' => ClassNameMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ClassNameMatcher.php',

        ],

        [

            'class' => ConstantMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ConstantMatcher.php',

        ],

        [

            'class' => ConstructorArgumentMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/ConstructorArgumentMatcher.php',

        ],

        [

            'class' => PropertyAnnotationMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/PropertyAnnotationMatcher.php',

        ],

        [

            'class' => MethodAnnotationMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodAnnotationMatcher.php',

        ],

        [

            'class' => FunctionCallMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/FunctionCallMatcher.php',

        ],

        [

            'class' => InterfaceMethodChangedMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/InterfaceMethodChangedMatcher.php',

        ],

        [

            'class' => MethodArgumentDroppedMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodArgumentDroppedMatcher.php',

        ],

        [

            'class' => MethodArgumentDroppedStaticMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodArgumentDroppedStaticMatcher.php',

        ],

        [

            'class' => MethodArgumentRequiredMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodArgumentRequiredMatcher.php',

        ],

        [

            'class' => MethodArgumentRequiredStaticMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodArgumentRequiredStaticMatcher.php',

        ],

        [

            'class' => MethodArgumentUnusedMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodArgumentUnusedMatcher.php',

        ],

        [

            'class' => MethodCallMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodCallMatcher.php',

        ],

        [

            'class' => MethodCallStaticMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/MethodCallStaticMatcher.php',

        ],

        [

            'class' => PropertyExistsStaticMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/PropertyExistsStaticMatcher.php'

        ],

        [

            'class' => PropertyProtectedMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/PropertyProtectedMatcher.php',

        ],

        [

            'class' => PropertyPublicMatcher::class,

            'configurationFile' => 'EXT:install/Configuration/ExtensionScanner/Php/PropertyPublicMatcher.php',

        ],

    ];


    public function ‪cardsAction(ServerRequestInterface $request): ResponseInterface

    {

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/Cards.html');

        $view->assign('extensionFoldersInTypo3conf', (new Finder())->directories()->in(‪Environment::getExtensionsPath())->depth(0)->count());

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪coreUpdateActivateAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->activateVersion($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪coreUpdateCheckPreConditionsAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->checkPreConditions($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪coreUpdateDownloadAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->downloadVersion($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪coreUpdateGetDataAction(ServerRequestInterface $request): ResponseInterface

    {

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/CoreUpdate.html');

        ‪$coreUpdateService = GeneralUtility::makeInstance(CoreUpdateService::class);

        ‪$coreVersionService = GeneralUtility::makeInstance(CoreVersionService::class);

        $view->assignMultiple([

            'coreUpdateEnabled' => ‪$coreUpdateService->‪isCoreUpdateEnabled(),

            'coreUpdateComposerMode' => ‪Environment::isComposerMode(),

            'coreUpdateIsReleasedVersion' => ‪$coreVersionService->isInstalledVersionAReleasedVersion(),

            'coreUpdateIsSymLinkedCore' => is_link(‪Environment::getPublicPath() . '/typo3_src'),

        ]);

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪coreUpdateIsUpdateAvailableAction(): ResponseInterface

    {

        $action = null;

        $this->‪coreUpdateInitialize();

        $messageQueue = new ‪FlashMessageQueue('install');


        $messages = [];


        if ($this->coreVersionService->isInstalledVersionAReleasedVersion()) {

            $versionMaintenanceWindow = $this->coreVersionService->getMaintenanceWindow();

            $renderVersionInformation = false;


            if (!$versionMaintenanceWindow->isSupportedByCommunity() && !$versionMaintenanceWindow->isSupportedByElts()) {

                $messages[] = [

                    'title' => 'Outdated version',

                    'message' => 'The currently installed TYPO3 version ' . $this->coreVersionService->getInstalledVersion() . ' does not receive any further updates, please consider upgrading to a supported version!',

                    'severity' => ‪FlashMessage::ERROR,

                ];

                $renderVersionInformation = true;

            } else {

                $currentVersion = $this->coreVersionService->getInstalledVersion();

                $isCurrentVersionElts = $this->coreVersionService->isCurrentInstalledVersionElts();

                $latestRelease = $this->coreVersionService->getYoungestPatchRelease();


                $availableReleases = [];

                if ($this->coreVersionService->isPatchReleaseSuitableForUpdate($latestRelease)) {

                    $availableReleases[] = $latestRelease;


                    if (!$latestRelease->isElts()) {

                        $action = ['title' => 'Update now to version ' . $latestRelease->getVersion(), 'action' => 'updateRegular'];

                    }

                }

                if (!$versionMaintenanceWindow->isSupportedByCommunity()) {

                    if ($latestRelease->isElts()) {

                        // Check if there's a public release left that's not installed yet

                        $latestCommunityDrivenRelease = $this->coreVersionService->getYoungestCommunityPatchRelease();

                        if ($this->coreVersionService->isPatchReleaseSuitableForUpdate($latestCommunityDrivenRelease)) {

                            $availableReleases[] = $latestCommunityDrivenRelease;

                            $action = ['title' => 'Update now to version ' . $latestCommunityDrivenRelease->getVersion(), 'action' => 'updateRegular'];

                        }

                    } elseif (!$isCurrentVersionElts) {

                        // Inform user about ELTS being available soon if:

                        // - regular support ran out

                        // - the current installed version is no ELTS

                        // - no ELTS update was released, yet

                        $messages[] = [

                            'title' => 'ELTS will be available soon',

                            'message' => sprintf('The currently installed TYPO3 version %s doesn\'t receive any community-driven updates anymore, consider subscribing to Extended Long Term Support (ELTS) releases. Please read the information below.', $currentVersion),

                            'severity' => ‪FlashMessage::WARNING,

                        ];

                        $renderVersionInformation = true;

                    }

                }


                if ($availableReleases === []) {

                    $messages[] = [

                        'title' => 'Up to date',

                        'message' => 'There are no TYPO3 updates available.',

                        'severity' => ‪FlashMessage::NOTICE,

                    ];

                } else {

                    foreach ($availableReleases as $availableRelease) {

                        $isUpdateSecurityRelevant = $this->coreVersionService->isUpdateSecurityRelevant($availableRelease);

                        $versionString = $availableRelease->getVersion();

                        if ($availableRelease->isElts()) {

                            $versionString .= ' ELTS';

                        }


                        if ($isUpdateSecurityRelevant) {

                            $title = ($availableRelease->isElts() ? 'ELTS ' : '') . 'Security update available!';

                            $message = sprintf('The currently installed version is %s, update to security relevant released version %s is available.', $currentVersion, $versionString);

                            $severity = ‪FlashMessage::ERROR;

                        } else {

                            $title = ($availableRelease->isElts() ? 'ELTS ' : '') . 'Update available!';

                            $message = sprintf('Currently installed version is %s, update to regular released version %s is available.', $currentVersion, $versionString);

                            $severity = ‪FlashMessage::WARNING;

                        }


                        if ($availableRelease->isElts()) {

                            if ($isCurrentVersionElts) {

                                $message .= ' Please visit my.typo3.org to download the release in your ELTS area.';

                            } else {

                                $message .= ' ' . sprintf('The currently installed TYPO3 version %s doesn\'t receive any community-driven updates anymore, consider subscribing to Extended Long Term Support (ELTS) releases. Please read the information below.', $currentVersion);

                            }


                            $renderVersionInformation = true;

                        }


                        $messages[] = [

                            'title' => $title,

                            'message' => $message,

                            'severity' => $severity,

                        ];

                    }

                }

            }


            if ($renderVersionInformation) {

                $supportedMajorReleases = $this->coreVersionService->getSupportedMajorReleases();

                $supportMessages = [];

                if (!empty($supportedMajorReleases['community'])) {

                    $supportMessages[] = sprintf('Currently community-supported TYPO3 versions: %s (more information at https://get.typo3.org).', implode(', ', $supportedMajorReleases['community']));

                }

                if (!empty($supportedMajorReleases['elts'])) {

                    $supportMessages[] = sprintf('Currently supported TYPO3 ELTS versions: %s (more information at https://typo3.com/elts).', implode(', ', $supportedMajorReleases['elts']));

                }


                $messages[] = [

                    'title' => 'TYPO3 Version information',

                    'message' => implode(' ', $supportMessages),

                    'severity' => ‪FlashMessage::INFO,

                ];

            }


            foreach ($messages as $message) {

                $messageQueue->enqueue(new ‪FlashMessage($message['message'], $message['title'], $message['severity']));

            }

        } else {

            $messageQueue->enqueue(new ‪FlashMessage(

                '',

                'Current version is a development version and can not be updated',

                ‪FlashMessage::WARNING

            ));

        }

        $responseData = [

            'success' => true,

            'status' => $messageQueue,

        ];

        if (isset($action)) {

            $responseData['action'] = $action;

        }

        return new ‪JsonResponse($responseData);

    }


    public function ‪coreUpdateMoveAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->moveVersion($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪coreUpdateUnpackAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->unpackVersion($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪coreUpdateVerifyChecksumAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪coreUpdateInitialize();

        return new ‪JsonResponse([

            'success' => $this->coreUpdateService->verifyFileChecksum($this->coreUpdateGetVersionToHandle($request)),

            'status' => $this->coreUpdateService->getMessages(),

        ]);

    }


    public function ‪extensionCompatTesterLoadedExtensionListAction(ServerRequestInterface $request): ResponseInterface

    {

        $formProtection = ‪FormProtectionFactory::get(InstallToolFormProtection::class);

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/ExtensionCompatTester.html');

        $view->assignMultiple([

            'extensionCompatTesterLoadExtLocalconfToken' => $formProtection->generateToken('installTool', 'extensionCompatTesterLoadExtLocalconf'),

            'extensionCompatTesterLoadExtTablesToken' => $formProtection->generateToken('installTool', 'extensionCompatTesterLoadExtTables'),

            'extensionCompatTesterUninstallToken' => $formProtection->generateToken('installTool', 'extensionCompatTesterUninstallExtension'),

        ]);


        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪extensionCompatTesterLoadExtLocalconfAction(ServerRequestInterface $request): ResponseInterface

    {

        $brokenExtensions = [];

        foreach ($this->packageManager->getActivePackages() as $package) {

            try {

                $this->‪extensionCompatTesterLoadExtLocalconfForExtension($package);

            } catch (\Throwable $e) {

                $brokenExtensions[] = [

                    'name' => $package->getPackageKey(),

                    'isProtected' => $package->isProtected()

                ];

            }

        }

        return new ‪JsonResponse([

            'brokenExtensions' => $brokenExtensions,

        ], empty($brokenExtensions) ? 200 : 500);

    }


    public function ‪extensionCompatTesterLoadExtTablesAction(ServerRequestInterface $request): ResponseInterface

    {

        $brokenExtensions = [];

        $activePackages = $this->packageManager->getActivePackages();

        foreach ($activePackages as $package) {

            // Load all ext_localconf files first

            $this->‪extensionCompatTesterLoadExtLocalconfForExtension($package);

        }

        foreach ($activePackages as $package) {

            try {

                $this->‪extensionCompatTesterLoadExtTablesForExtension($package);

            } catch (\Throwable $e) {

                $brokenExtensions[] = [

                    'name' => $package->getPackageKey(),

                    'isProtected' => $package->isProtected()

                ];

            }

        }

        return new ‪JsonResponse([

            'brokenExtensions' => $brokenExtensions,

        ], empty($brokenExtensions) ? 200 : 500);

    }


    public function ‪extensionCompatTesterUninstallExtensionAction(ServerRequestInterface $request): ResponseInterface

    {

        $extension = $request->getParsedBody()['install']['extension'];

        if (empty($extension)) {

            throw new \RuntimeException(

                'No extension given',

                1505407269

            );

        }

        $messageQueue = new ‪FlashMessageQueue('install');

        if (‪ExtensionManagementUtility::isLoaded($extension)) {

            try {

                ‪ExtensionManagementUtility::unloadExtension($extension);

                GeneralUtility::makeInstance(ClearCacheService::class)->clearAll();

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


                $messageQueue->enqueue(new ‪FlashMessage(

                    'Extension "' . $extension . '" unloaded.',

                    '',

                    ‪FlashMessage::ERROR

                ));

            } catch (\‪Exception $e) {

                $messageQueue->enqueue(new ‪FlashMessage(

                    $e->getMessage(),

                    '',

                    ‪FlashMessage::ERROR

                ));

            }

        }

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messageQueue,

        ]);

    }


    public function ‪extensionScannerGetDataAction(ServerRequestInterface $request): ResponseInterface

    {

        $extensionsInTypo3conf = (new Finder())->directories()->in(‪Environment::getExtensionsPath())->depth(0)->sortByName();

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/ExtensionScanner.html');

        $formProtection = ‪FormProtectionFactory::get(InstallToolFormProtection::class);

        $view->assignMultiple([

            'extensionScannerExtensionList' => $extensionsInTypo3conf,

            'extensionScannerFilesToken' => $formProtection->generateToken('installTool', 'extensionScannerFiles'),

            'extensionScannerScanFileToken' => $formProtection->generateToken('installTool', 'extensionScannerScanFile'),

            'extensionScannerMarkFullyScannedRestFilesToken' => $formProtection->generateToken('installTool', 'extensionScannerMarkFullyScannedRestFiles'),

        ]);

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪extensionScannerFilesAction(ServerRequestInterface $request): ResponseInterface

    {

        // Get and validate path

        $extension = $request->getParsedBody()['install']['extension'];

        $extensionBasePath = ‪Environment::getExtensionsPath() . '/' . $extension;

        if (empty($extension) || !GeneralUtility::isAllowedAbsPath($extensionBasePath)) {

            throw new \RuntimeException(

                'Path to extension ' . $extension . ' not allowed.',

                1499777261

            );

        }

        if (!is_dir($extensionBasePath)) {

            throw new \RuntimeException(

                'Extension path ' . $extensionBasePath . ' does not exist or is no directory.',

                1499777330

            );

        }


        ‪$finder = new Finder();

        $files = ‪$finder->files()->in($extensionBasePath)->name('*.php')->sortByName();

        // A list of file names relative to extension directory

        $relativeFileNames = [];

        foreach ($files as $file) {

            $relativeFileNames[] = GeneralUtility::fixWindowsFilePath($file->getRelativePathname());

        }

        return new ‪JsonResponse([

            'success' => true,

            'files' => $relativeFileNames,

        ]);

    }


    public function ‪extensionScannerMarkFullyScannedRestFilesAction(ServerRequestInterface $request): ResponseInterface

    {

        $foundRestFileHashes = (array)$request->getParsedBody()['install']['hashes'];

        // First un-mark files marked as scanned-ok

        $registry = new ‪Registry();

        $registry->removeAllByNamespace('extensionScannerNotAffected');

        // Find all .rst files (except those from v8), see if they are tagged with "FullyScanned"

        // and if their content is not in incoming "hashes" array, mark as "not affected"

        $documentationFile = new ‪DocumentationFile();

        ‪$finder = new Finder();

        $restFilesBasePath = ‪ExtensionManagementUtility::extPath('core') . 'Documentation/Changelog';

        $restFiles = ‪$finder->files()->in($restFilesBasePath);

        $fullyScannedRestFilesNotAffected = [];

        foreach ($restFiles as $restFile) {

            // Skip files in "8.x" directory

            if (strpos($restFile->getRelativePath(), '8') === 0) {

                continue;

            }


            // Build array of file (hashes) not affected by current scan, if they are tagged as "FullyScanned"

            $parsedRestFile = array_pop($documentationFile->getListEntry(str_replace(

                '\\',

                '/',

                realpath($restFile->getPathname())

            )));

            if (!in_array($parsedRestFile['file_hash'], $foundRestFileHashes, true)

                && in_array('FullyScanned', $parsedRestFile['tags'], true)

            ) {

                $fullyScannedRestFilesNotAffected[] = $parsedRestFile['file_hash'];

            }

        }

        foreach ($fullyScannedRestFilesNotAffected as $fileHash) {

            $registry->set('extensionScannerNotAffected', $fileHash, $fileHash);

        }

        return new ‪JsonResponse([

            'success' => true,

            'markedAsNotAffected' => count($fullyScannedRestFilesNotAffected),

        ]);

    }


    public function ‪extensionScannerScanFileAction(ServerRequestInterface $request): ResponseInterface

    {

        // Get and validate path and file

        $extension = $request->getParsedBody()['install']['extension'];

        $extensionBasePath = ‪Environment::getExtensionsPath() . '/' . $extension;

        if (empty($extension) || !GeneralUtility::isAllowedAbsPath($extensionBasePath)) {

            throw new \RuntimeException(

                'Path to extension ' . $extension . ' not allowed.',

                1499789246

            );

        }

        if (!is_dir($extensionBasePath)) {

            throw new \RuntimeException(

                'Extension path ' . $extensionBasePath . ' does not exist or is no directory.',

                1499789259

            );

        }

        $file = $request->getParsedBody()['install']['file'];

        $absoluteFilePath = $extensionBasePath . '/' . $file;

        if (empty($file) || !GeneralUtility::isAllowedAbsPath($absoluteFilePath)) {

            throw new \RuntimeException(

                'Path to file ' . $file . ' of extension ' . $extension . ' not allowed.',

                1499789384

            );

        }

        if (!is_file($absoluteFilePath)) {

            throw new \RuntimeException(

                'File ' . $file . ' not found or is not a file.',

                1499789433

            );

        }


        ‪$parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);

        // Parse PHP file to AST and traverse tree calling visitors

        $statements = ‪$parser->parse(file_get_contents($absoluteFilePath));


        // The built in NameResolver translates class names shortened with 'use' to fully qualified

        // class names at all places. Incredibly useful for us and added as first visitor.

        // IMPORTANT: first process completely to resolve fully qualified names of arguments

        // (otherwise GeneratorClassesResolver will NOT get reliable results)

        $traverser = new NodeTraverser();

        $traverser->addVisitor(new NameResolver());

        $statements = $traverser->traverse($statements);


        // IMPORTANT: second process to actually work on the pre-resolved statements

        $traverser = new NodeTraverser();

        // Understand GeneralUtility::makeInstance('My\\Package\\Foo\\Bar') as fqdn class name in first argument

        $traverser->addVisitor(new ‪GeneratorClassesResolver());

        // Count ignored lines, effective code lines, ...

        $statistics = new ‪CodeStatistics();

        $traverser->addVisitor($statistics);


        // Add all configured matcher classes

        $matcherFactory = new ‪MatcherFactory();

        ‪$matchers = $matcherFactory->createAll($this->matchers);

        foreach (‪$matchers as $matcher) {

            $traverser->addVisitor($matcher);

        }


        $traverser->traverse($statements);


        // Gather code matches

        $matches = [[]];

        foreach (‪$matchers as $matcher) {

            $matches[] = $matcher->getMatches();

        }

        $matches = array_merge(...$matches);


        // Prepare match output

        $restFilesBasePath = ‪ExtensionManagementUtility::extPath('core') . 'Documentation/Changelog';

        $documentationFile = new ‪DocumentationFile();

        $preparedMatches = [];

        foreach ($matches as $match) {

            $preparedHit = [];

            $preparedHit['uniqueId'] = str_replace('.', '', uniqid((string)mt_rand(), true));

            $preparedHit['message'] = $match['message'];

            $preparedHit['line'] = $match['line'];

            $preparedHit['indicator'] = $match['indicator'];

            $preparedHit['lineContent'] = $this->‪extensionScannerGetLineFromFile($absoluteFilePath, $match['line']);

            $preparedHit['restFiles'] = [];

            foreach ($match['restFiles'] as $fileName) {

                ‪$finder = new Finder();

                $restFileLocation = ‪$finder->files()->in($restFilesBasePath)->name($fileName);

                if ($restFileLocation->count() !== 1) {

                    throw new \RuntimeException(

                        'ResT file ' . $fileName . ' not found or multiple files found.',

                        1499803909

                    );

                }

                foreach ($restFileLocation as $restFile) {

                    $restFileLocation = $restFile->getPathname();

                    break;

                }

                $parsedRestFile = array_pop($documentationFile->getListEntry(str_replace(

                    '\\',

                    '/',

                    realpath($restFileLocation)

                )));

                $version = GeneralUtility::trimExplode(DIRECTORY_SEPARATOR, $restFileLocation);

                array_pop($version);

                // something like "8.2" .. "8.7" .. "master"

                $parsedRestFile['version'] = array_pop($version);

                $parsedRestFile['uniqueId'] = str_replace('.', '', uniqid((string)mt_rand(), true));

                $preparedHit['restFiles'][] = $parsedRestFile;

            }

            $preparedMatches[] = $preparedHit;

        }

        return new ‪JsonResponse([

            'success' => true,

            'matches' => $preparedMatches,

            'isFileIgnored' => $statistics->isFileIgnored(),

            'effectiveCodeLines' => $statistics->getNumberOfEffectiveCodeLines(),

            'ignoredLines' => $statistics->getNumberOfIgnoredLines(),

        ]);

    }


    public function ‪tcaExtTablesCheckAction(ServerRequestInterface $request): ResponseInterface

    {

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/TcaExtTablesCheck.html');

        $messageQueue = new ‪FlashMessageQueue('install');

        $loadTcaService = GeneralUtility::makeInstance(LoadTcaService::class);

        $loadTcaService->loadExtensionTablesWithoutMigration();

        $baseTca = ‪$GLOBALS['TCA'];

        foreach ($this->packageManager->getActivePackages() as $package) {

            $this->‪extensionCompatTesterLoadExtLocalconfForExtension($package);


            $extensionKey = $package->getPackageKey();

            $extTablesPath = $package->getPackagePath() . 'ext_tables.php';

            if (@file_exists($extTablesPath)) {

                $loadTcaService->loadSingleExtTablesFile($extensionKey);

                $newTca = ‪$GLOBALS['TCA'];

                if ($newTca !== $baseTca) {

                    $messageQueue->enqueue(new ‪FlashMessage(

                        '',

                        $extensionKey,

                        ‪FlashMessage::NOTICE

                    ));

                }

                $baseTca = $newTca;

            }

        }

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messageQueue,

            'html' => $view->render(),

        ]);

    }


    public function ‪tcaMigrationsCheckAction(ServerRequestInterface $request): ResponseInterface

    {

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/TcaMigrationsCheck.html');

        $messageQueue = new ‪FlashMessageQueue('install');

        GeneralUtility::makeInstance(LoadTcaService::class)->loadExtensionTablesWithoutMigration();

        $tcaMigration = GeneralUtility::makeInstance(TcaMigration::class);

        ‪$GLOBALS['TCA'] = $tcaMigration->migrate(‪$GLOBALS['TCA']);

        $tcaMessages = $tcaMigration->getMessages();

        foreach ($tcaMessages as $tcaMessage) {

            $messageQueue->enqueue(new ‪FlashMessage(

                '',

                $tcaMessage,

                ‪FlashMessage::NOTICE

            ));

        }

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messageQueue,

            'html' => $view->render(),

        ]);

    }


    public function ‪upgradeDocsGetContentAction(ServerRequestInterface $request): ResponseInterface

    {

        $formProtection = ‪FormProtectionFactory::get(InstallToolFormProtection::class);

        $documentationDirectories = $this->‪getDocumentationDirectories();

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/UpgradeDocsGetContent.html');

        $view->assignMultiple([

            'upgradeDocsMarkReadToken' => $formProtection->generateToken('installTool', 'upgradeDocsMarkRead'),

            'upgradeDocsUnmarkReadToken' => $formProtection->generateToken('installTool', 'upgradeDocsUnmarkRead'),

            'upgradeDocsVersions' => $documentationDirectories,

        ]);

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪upgradeDocsGetChangelogForVersionAction(ServerRequestInterface $request): ResponseInterface

    {

        $version = $request->getQueryParams()['install']['version'] ?? '';

        $this->‪assertValidVersion($version);


        $documentationFiles = $this->‪getDocumentationFiles($version);

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/UpgradeDocsGetChangelogForVersion.html');

        $view->assignMultiple([

            'upgradeDocsFiles' => $documentationFiles['normalFiles'],

            'upgradeDocsReadFiles' => $documentationFiles['readFiles'],

            'upgradeDocsNotAffectedFiles' => $documentationFiles['notAffectedFiles'],

        ]);

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    public function ‪upgradeDocsMarkReadAction(ServerRequestInterface $request): ResponseInterface

    {

        $registry = new ‪Registry();

        $filePath = $request->getParsedBody()['install']['ignoreFile'];

        $fileHash = md5_file($filePath);

        $registry->set('upgradeAnalysisIgnoredFiles', $fileHash, $filePath);

        return new ‪JsonResponse([

            'success' => true,

        ]);

    }


    public function ‪upgradeDocsUnmarkReadAction(ServerRequestInterface $request): ResponseInterface

    {

        $registry = new ‪Registry();

        $filePath = $request->getParsedBody()['install']['ignoreFile'];

        $fileHash = md5_file($filePath);

        $registry->remove('upgradeAnalysisIgnoredFiles', $fileHash);

        return new ‪JsonResponse([

            'success' => true,

        ]);

    }


    public function ‪upgradeWizardsBlockingDatabaseAddsAction(): ResponseInterface

    {

        // ext_localconf, db and ext_tables must be loaded for the updates :(

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $adds = [];

        $needsUpdate = false;

        try {

            $adds = $upgradeWizardsService->getBlockingDatabaseAdds();

            if (!empty($adds)) {

                $needsUpdate = true;

            }

        } catch (‪StatementException $exception) {

            $needsUpdate = true;

        }

        return new ‪JsonResponse([

            'success' => true,

            'needsUpdate' => $needsUpdate,

            'adds' => $adds,

        ]);

    }


    public function ‪upgradeWizardsBlockingDatabaseExecuteAction(): ResponseInterface

    {

        // ext_localconf, db and ext_tables must be loaded for the updates :(

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $upgradeWizardsService->addMissingTablesAndFields();

        $messages = new ‪FlashMessageQueue('install');

        $messages->enqueue(new ‪FlashMessage(

            '',

            'Added missing database fields and tables'

        ));

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messages,

        ]);

    }


    public function ‪upgradeWizardsBlockingDatabaseCharsetFixAction(): ResponseInterface

    {

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $upgradeWizardsService->setDatabaseCharsetUtf8();

        $messages = new ‪FlashMessageQueue('install');

        $messages->enqueue(new ‪FlashMessage(

            '',

            'Default connection database has been set to utf8'

        ));

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messages,

        ]);

    }


    public function ‪upgradeWizardsBlockingDatabaseCharsetTestAction(): ResponseInterface

    {

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $result = !$upgradeWizardsService->isDatabaseCharsetUtf8();

        return new ‪JsonResponse([

            'success' => true,

            'needsUpdate' => $result,

        ]);

    }


    public function ‪upgradeWizardsDoneUpgradesAction(): ResponseInterface

    {

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $wizardsDone = $upgradeWizardsService->listOfWizardsDone();

        $rowUpdatersDone = $upgradeWizardsService->listOfRowUpdatersDone();

        $messages = new ‪FlashMessageQueue('install');

        if (empty($wizardsDone) && empty($rowUpdatersDone)) {

            $messages->enqueue(new ‪FlashMessage(

                '',

                'No wizards are marked as done'

            ));

        }

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messages,

            'wizardsDone' => $wizardsDone,

            'rowUpdatersDone' => $rowUpdatersDone,

        ]);

    }


    public function ‪upgradeWizardsExecuteAction(ServerRequestInterface $request): ResponseInterface

    {

        // ext_localconf, db and ext_tables must be loaded for the updates :(

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $identifier = $request->getParsedBody()['install']['identifier'];

        $messages = $upgradeWizardsService->executeWizard($identifier);

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messages,

        ]);

    }


    public function ‪upgradeWizardsInputAction(ServerRequestInterface $request): ResponseInterface

    {

        // ext_localconf, db and ext_tables must be loaded for the updates :(

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $identifier = $request->getParsedBody()['install']['identifier'];

        $result = $upgradeWizardsService->getWizardUserInput($identifier);

        return new ‪JsonResponse([

            'success' => true,

            'status' => [],

            'userInput' => $result,

        ]);

    }


    public function ‪upgradeWizardsListAction(): ResponseInterface

    {

        // ext_localconf, db and ext_tables must be loaded for the updates :(

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $wizards = $upgradeWizardsService->getUpgradeWizardsList();

        return new ‪JsonResponse([

            'success' => true,

            'status' => [],

            'wizards' => $wizards,

        ]);

    }


    public function ‪upgradeWizardsMarkUndoneAction(ServerRequestInterface $request): ResponseInterface

    {

        $this->‪loadExtLocalconfDatabaseAndExtTables();

        $wizardToBeMarkedAsUndoneIdentifier = $request->getParsedBody()['install']['identifier'];

        $upgradeWizardsService = new ‪UpgradeWizardsService();

        $result = $upgradeWizardsService->markWizardUndone($wizardToBeMarkedAsUndoneIdentifier);

        $messages = new ‪FlashMessageQueue('install');

        if ($result) {

            $messages->enqueue(new ‪FlashMessage(

                'Wizard has been marked undone'

            ));

        } else {

            $messages->enqueue(new ‪FlashMessage(

                'Wizard has not been marked undone',

                '',

                ‪FlashMessage::ERROR

            ));

        }

        return new ‪JsonResponse([

            'success' => true,

            'status' => $messages,

        ]);

    }


    public function ‪upgradeWizardsGetDataAction(ServerRequestInterface $request): ResponseInterface

    {

        $view = $this->‪initializeStandaloneView($request, 'Upgrade/UpgradeWizards.html');

        $formProtection = ‪FormProtectionFactory::get(InstallToolFormProtection::class);

        $view->assignMultiple([

            'upgradeWizardsMarkUndoneToken' => $formProtection->generateToken('installTool', 'upgradeWizardsMarkUndone'),

            'upgradeWizardsInputToken' => $formProtection->generateToken('installTool', 'upgradeWizardsInput'),

            'upgradeWizardsExecuteToken' => $formProtection->generateToken('installTool', 'upgradeWizardsExecute'),

        ]);

        return new ‪JsonResponse([

            'success' => true,

            'html' => $view->render(),

        ]);

    }


    protected function ‪coreUpdateInitialize()

    {

        $this->coreUpdateService = GeneralUtility::makeInstance(CoreUpdateService::class);

        $this->coreVersionService = GeneralUtility::makeInstance(CoreVersionService::class);

        if (!$this->coreUpdateService->isCoreUpdateEnabled()) {

            throw new \RuntimeException(

                'Core Update disabled in this environment',

                1381609294

            );

        }

        // @todo: Does the core updater really depend on loaded ext_* files?

        $this->‪loadExtLocalconfDatabaseAndExtTables();

    }


    protected function ‪coreUpdateGetVersionToHandle(ServerRequestInterface $request): ‪CoreRelease

    {

        $type = $request->getQueryParams()['install']['type'];

        if (!isset($type) || empty($type)) {

            throw new \RuntimeException(

                'Type must be set to either "regular" or "development"',

                1380975303

            );

        }

        return $this->coreVersionService->getYoungestCommunityPatchRelease();

    }


    protected function ‪extensionCompatTesterLoadExtLocalconfForExtension(‪PackageInterface $package)

    {

        $extLocalconfPath = $package->‪getPackagePath() . 'ext_localconf.php';

        // This is the main array meant to be manipulated in the ext_localconf.php files

        // In general it is recommended to not rely on it to be globally defined in that

        // scope but to use $GLOBALS['TYPO3_CONF_VARS'] instead.

        // Nevertheless we define it here as global for backwards compatibility.

        global $TYPO3_CONF_VARS;

        if (@file_exists($extLocalconfPath)) {

            // $_EXTKEY and $_EXTCONF are available in ext_localconf.php

            // and are explicitly set in cached file as well

            $_EXTKEY = $package->‪getPackageKey();

            $_EXTCONF = ‪$GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$_EXTKEY] ?? null;

            require $extLocalconfPath;

        }

    }


    protected function ‪extensionCompatTesterLoadExtTablesForExtension(‪PackageInterface $package)

    {

        $extTablesPath = $package->‪getPackagePath() . 'ext_tables.php';

        // In general it is recommended to not rely on it to be globally defined in that

        // scope, but we can not prohibit this without breaking backwards compatibility

        global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;

        global $TBE_MODULES, $TBE_MODULES_EXT, $TCA;

        global $PAGES_TYPES, $TBE_STYLES;

        global $_EXTKEY;

        // Load each ext_tables.php file of loaded extensions

        $_EXTKEY = $package->‪getPackageKey();

        if (@file_exists($extTablesPath)) {

            // $_EXTKEY and $_EXTCONF are available in ext_tables.php

            // and are explicitly set in cached file as well

            $_EXTCONF = ‪$GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$_EXTKEY] ?? null;

            require $extTablesPath;

        }

    }


    protected function ‪getDocumentationDirectories(): array

    {

        $documentationFileService = new ‪DocumentationFile();

        $documentationDirectories = $documentationFileService->findDocumentationDirectories(

            str_replace('\\', '/', realpath(‪ExtensionManagementUtility::extPath('core') . 'Documentation/Changelog'))

        );

        return array_reverse($documentationDirectories);

    }


    protected function ‪getDocumentationFiles(string $version): array

    {

        $documentationFileService = new ‪DocumentationFile();

        $documentationFiles = $documentationFileService->findDocumentationFiles(

            str_replace('\\', '/', realpath(‪ExtensionManagementUtility::extPath('core') . 'Documentation/Changelog/' . $version))

        );


        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_registry');

        $filesMarkedAsRead = $queryBuilder

            ->select('*')

            ->from('sys_registry')

            ->where(

                $queryBuilder->expr()->eq(

                    'entry_namespace',

                    $queryBuilder->createNamedParameter('upgradeAnalysisIgnoredFiles', \PDO::PARAM_STR)

                )

            )

            ->execute()

            ->fetchAll();

        $hashesMarkedAsRead = [];

        foreach ($filesMarkedAsRead as $file) {

            $hashesMarkedAsRead[] = $file['entry_key'];

        }


        $fileMarkedAsNotAffected = $queryBuilder

            ->select('*')

            ->from('sys_registry')

            ->where(

                $queryBuilder->expr()->eq(

                    'entry_namespace',

                    $queryBuilder->createNamedParameter('extensionScannerNotAffected', \PDO::PARAM_STR)

                )

            )

            ->execute()

            ->fetchAll();

        $hashesMarkedAsNotAffected = [];

        foreach ($fileMarkedAsNotAffected as $file) {

            $hashesMarkedAsNotAffected[] = $file['entry_key'];

        }


        $readFiles = [];

        $notAffectedFiles = [];

        foreach ($documentationFiles as $fileId => $fileData) {

            if (in_array($fileData['file_hash'], $hashesMarkedAsRead, true)) {

                $readFiles[$fileId] = $fileData;

                unset($documentationFiles[$fileId]);

            } elseif (in_array($fileData['file_hash'], $hashesMarkedAsNotAffected, true)) {

                $notAffectedFiles[$fileId] = $fileData;

                unset($documentationFiles[$fileId]);

            }

        }


        return [

            'normalFiles' => $documentationFiles,

            'readFiles' => $readFiles,

            'notAffectedFiles' => $notAffectedFiles,

        ];

    }


    protected function ‪extensionScannerGetLineFromFile(string $file, int $lineNumber): string

    {

        $fileContent = file($file, FILE_IGNORE_NEW_LINES);

        $line = '';

        if (isset($fileContent[$lineNumber - 1])) {

            $line = trim($fileContent[$lineNumber - 1]);

        }

        return $line;

    }


    protected function ‪assertValidVersion(string $version): void

    {

        if ($version !== 'master' && !preg_match('/^\d+.\d+(?:.(?:\d+|x))?$/', $version)) {

            throw new \InvalidArgumentException('Given version "' . $version . '" is invalid', 1537209128);

        }

    }

}