DownloadController.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Extensionmanager\Controller;
 
use Psr\Http\Message\ResponseInterface;
use ‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use ‪TYPO3\CMS\Core\Messaging\AbstractMessage;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Http\ForwardResponse;
use ‪TYPO3\CMS\Extbase\Mvc\View\JsonView;
use ‪TYPO3\CMS\Extbase\Utility\LocalizationUtility;
use ‪TYPO3\CMS\Extensionmanager\Domain\Model\Extension;
use ‪TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository;
use ‪TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;
use ‪TYPO3\CMS\Extensionmanager\Service\ExtensionManagementService;
use ‪TYPO3\CMS\Fluid\View\TemplateView;
 
class ‪DownloadController extends ‪AbstractController
{
    protected ‪ExtensionRepository ‪$extensionRepository;
    protected ‪ExtensionManagementService ‪$managementService;
 
    protected ‪$defaultViewObjectName = JsonView::class;
 
    protected ‪$view;
 
    public function ‪__construct(
        ‪ExtensionRepository ‪$extensionRepository,
        ‪ExtensionManagementService ‪$managementService
    ) {
        $this->extensionRepository = ‪$extensionRepository;
        $this->managementService = ‪$managementService;
    }
 
    public function ‪checkDependenciesAction(‪Extension $extension): ResponseInterface
    {
        $message = '';
        $title = '';
        $hasDependencies = false;
        $hasErrors = false;
        $dependencyTypes = null;
        $configuration = [
            'value' => [
                'dependencies' => [],
            ],
        ];
        $isAutomaticInstallationEnabled = (bool)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('extensionmanager', 'automaticInstallation');
        if (!$isAutomaticInstallationEnabled) {
            // if automatic installation is deactivated, no dependency check is needed (download only)
            $action = 'installExtensionWithoutSystemDependencyCheck';
        } else {
            $action = 'installFromTer';
            try {
                $dependencyTypes = $this->managementService->getAndResolveDependencies($extension);
                if (!empty($dependencyTypes)) {
                    $hasDependencies = true;
                    $message = '<p>' . $this->‪translate('downloadExtension.dependencies.headline') . '</p>';
                    foreach ($dependencyTypes as $dependencyType => $dependencies) {
                        $extensions = '';
                        foreach ($dependencies as $extensionKey => $dependency) {
                            if (!isset($configuration['value']['dependencies'][$dependencyType])) {
                                $configuration['value']['dependencies'][$dependencyType] = [];
                            }
                            $configuration['value']['dependencies'][$dependencyType][$extensionKey] = [
                                '_exclude' => [
                                    'categoryIndexFromStringOrNumber',
                                ],
                            ];
                            $extensions .= $this->‪translate(
                                'downloadExtension.dependencies.extensionWithVersion',
                                [
                                    $extensionKey, $dependency->getVersion(),
                                ]
                            ) . '<br />';
                        }
                        $message .= $this->‪translate(
                            'downloadExtension.dependencies.typeHeadline',
                            [
                                $this->‪translate('downloadExtension.dependencyType.' . $dependencyType),
                                $extensions,
                            ]
                        );
                    }
                    $title = $this->‪translate('downloadExtension.dependencies.resolveAutomatically');
                }
            } catch (\Exception $e) {
                $hasErrors = true;
                $title = $this->‪translate('downloadExtension.dependencies.errorTitle');
                $message = $e->getMessage();
            }
        }
 
        $url = $this->uriBuilder->uriFor(
            $action,
            ['extension' => $extension->‪getUid(), 'format' => 'json'],
            'Download'
        );
        $this->view->setConfiguration($configuration);
        $this->view->assign('value', [
            'dependencies' => $dependencyTypes,
            'url' => $url,
            'message' => $message,
            'hasErrors' => $hasErrors,
            'hasDependencies' => $hasDependencies,
            'title' => $title,
        ]);
 
        return $this->‪jsonResponse();
    }
 
    protected function ‪initializeInstallFromTerAction()
    {
        // @todo: Switch to JsonView
        $this->defaultViewObjectName = TemplateView::class;
    }
 
    public function ‪installFromTerAction(Extension $extension, $downloadPath = 'Local'): ResponseInterface
    {
        [$result, $errorMessages] = $this->‪installFromTer($extension, $downloadPath);
        $isAutomaticInstallationEnabled = (bool)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('extensionmanager', 'automaticInstallation');
        $this->view->assignMultiple([
            'result'  => $result,
            'extension' => $extension,
            'installationTypeLanguageKey' => $isAutomaticInstallationEnabled ? '' : '.downloadOnly',
            'unresolvedDependencies' => $errorMessages,
        ]);
 
        return $this->‪htmlResponse();
    }
 
    public function ‪installExtensionWithoutSystemDependencyCheckAction(Extension $extension): ResponseInterface
    {
        $this->managementService->setSkipDependencyCheck(true);
        return (new ForwardResponse('installFromTer'))->withArguments(['extension' => $extension, 'downloadPath' => 'Local']);
    }
 
    public function ‪installDistributionAction(Extension $extension)
    {
        if (!‪ExtensionManagementUtility::isLoaded('impexp')) {
            return (new ForwardResponse('distributions'))->withControllerName('List');
        }
        $errorMessages = $this->‪installFromTer($extension)[1];
        if ($errorMessages) {
            foreach ($errorMessages as $extensionKey => $messages) {
                foreach ($messages as $message) {
                    $this->‪addFlashMessage(
                        $message['message'],
                        ‪LocalizationUtility::translate(
                            'distribution.error.headline',
                            'extensionmanager',
                            [$extensionKey]
                        ) ?? '',
                        ‪AbstractMessage::ERROR
                    );
                }
            }
 
            // Redirect back to distributions list action
            $this->‪redirect(
                'distributions',
                'List'
            );
        } else {
            // FlashMessage that extension is installed
            $this->‪addFlashMessage(
                ‪LocalizationUtility::translate(
                    'distribution.welcome.message',
                    'extensionmanager',
                    [$extension->getExtensionKey()]
                ) ?? '',
                ‪LocalizationUtility::translate('distribution.welcome.headline', 'extensionmanager') ?? ''
            );
 
            // Redirect to show action
            $this->‪redirect(
                'show',
                'Distribution',
                null,
                ['extension' => $extension]
            );
        }
    }
 
    protected function ‪updateExtensionAction(): ResponseInterface
    {
        $extensionKey = $this->request->getArgument('extension');
        $version = $this->request->getArgument('version');
        $extension = $this->extensionRepository->findOneByExtensionKeyAndVersion($extensionKey, $version);
        if (!$extension instanceof Extension) {
            $extension = $this->extensionRepository->findHighestAvailableVersion($extensionKey);
        }
        $installedExtensions = ‪ExtensionManagementUtility::getLoadedExtensionListArray();
        try {
            if (in_array($extensionKey, $installedExtensions, true)) {
                // To resolve new dependencies the extension is installed again
                $this->managementService->installExtension($extension);
            } else {
                $this->managementService->downloadMainExtension($extension);
            }
            $this->‪addFlashMessage(
                $this->‪translate('extensionList.updateFlashMessage.body', [$extensionKey]),
                $this->‪translate('extensionList.updateFlashMessage.title')
            );
        } catch (\Exception $e) {
            $this->‪addFlashMessage($e->getMessage(), '', ‪FlashMessage::ERROR);
        }
 
        return $this->‪jsonResponse();
    }
 
    protected function ‪updateCommentForUpdatableVersionsAction(): ResponseInterface
    {
        $extensionKey = $this->request->getArgument('extension');
        $versionStart = $this->request->getArgument('integerVersionStart');
        $versionStop = $this->request->getArgument('integerVersionStop');
        $updateComments = [];
        $updatableVersions = $this->extensionRepository->findByVersionRangeAndExtensionKeyOrderedByVersion(
            $extensionKey,
            $versionStart,
            $versionStop,
            false
        );
        $highestPossibleVersion = false;
 
        foreach ($updatableVersions as $updatableVersion) {
            if ($highestPossibleVersion === false) {
                $highestPossibleVersion = $updatableVersion->getVersion();
            }
            $updateComments[$updatableVersion->getVersion()] = $updatableVersion->getUpdateComment();
        }
 
        $this->view->assign('value', [
            'updateComments' => $updateComments,
            'url' => $this->uriBuilder->uriFor(
                'updateExtension',
                ['extension' => $extensionKey, 'version' => $highestPossibleVersion]
            ),
        ]);
 
        return $this->‪jsonResponse();
    }
 
    protected function ‪installFromTer(Extension $extension, $downloadPath = 'Local')
    {
        $result = false;
        $errorMessages = [];
        try {
            $this->managementService->setDownloadPath($downloadPath);
            $isAutomaticInstallationEnabled = (bool)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('extensionmanager', 'automaticInstallation');
            $this->managementService->setAutomaticInstallationEnabled($isAutomaticInstallationEnabled);
            if (($result = $this->managementService->installExtension($extension)) === false) {
                $errorMessages = $this->managementService->getDependencyErrors();
            }
        } catch (ExtensionManagerException $e) {
            $errorMessages = [
                $extension->getExtensionKey() => [
                    [
                        'code' => $e->getCode(),
                        'message' => $e->getMessage(),
                    ],
                ],
            ];
        }
 
        return [$result, $errorMessages];
    }
}