ListController.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 ‪TYPO3\CMS\Backend\Template\Components\ButtonBar;
use ‪TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Backend\View\BackendTemplateView;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Imaging\Icon;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Mvc\View\ViewInterface;
use ‪TYPO3\CMS\Extbase\Utility\LocalizationUtility;
use ‪TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository;
use ‪TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;
use ‪TYPO3\CMS\Extensionmanager\Utility\DependencyUtility;
use ‪TYPO3\CMS\Extensionmanager\Utility\ExtensionModelUtility;
use ‪TYPO3\CMS\Extensionmanager\Utility\ListUtility;
use ‪TYPO3\CMS\Extensionmanager\Utility\Repository\Helper;
 
class ‪ListController extends ‪AbstractModuleController
{
    protected ‪$extensionRepository;
 
    protected ‪$listUtility;
 
    protected ‪$pageRenderer;
 
    protected ‪$dependencyUtility;
 
    protected ‪$backendUserFilter = '';
 
    public function ‪injectExtensionRepository(‪ExtensionRepository ‪$extensionRepository)
    {
        $this->extensionRepository = ‪$extensionRepository;
    }
 
    public function ‪injectListUtility(‪ListUtility ‪$listUtility)
    {
        $this->listUtility = ‪$listUtility;
    }
 
    public function ‪injectPageRenderer(‪PageRenderer ‪$pageRenderer)
    {
        $this->pageRenderer = ‪$pageRenderer;
    }
 
    public function ‪injectDependencyUtility(‪DependencyUtility ‪$dependencyUtility)
    {
        $this->dependencyUtility = ‪$dependencyUtility;
    }
 
    public function ‪initializeAction()
    {
        $this->pageRenderer->addInlineLanguageLabelFile('EXT:extensionmanager/Resources/Private/Language/locallang.xlf');
        $isAutomaticInstallationEnabled = (bool)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('extensionmanager', 'offlineMode');
        if ($isAutomaticInstallationEnabled) {
            $this->settings['offlineMode'] = true;
        }
    }
 
    protected function ‪initializeView(ViewInterface ‪$view)
    {
        if (‪$view instanceof BackendTemplateView) {
            parent::initializeView(‪$view);
            $this->‪generateMenu();
            $this->‪registerDocheaderButtons();
        }
    }
 
    protected function ‪addComposerModeNotification()
    {
        if (‪Environment::isComposerMode()) {
            $this->‪addFlashMessage(
                ‪LocalizationUtility::translate(
                    'composerMode.message',
                    'extensionmanager'
                ) ?? '',
                ‪LocalizationUtility::translate(
                    'composerMode.title',
                    'extensionmanager'
                ) ?? '',
                ‪FlashMessage::INFO
            );
        }
    }
 
    public function ‪indexAction()
    {
        if ($this->request->hasArgument('filter') && is_string($this->request->getArgument('filter'))) {
            $this->backendUserFilter = $this->request->getArgument('filter');
            $this->‪saveBackendUserFilter();
        } else {
            $this->backendUserFilter = $this->‪getBackendUserFilter();
        }
 
        $this->‪addComposerModeNotification();
        $availableAndInstalledExtensions = $this->listUtility->getAvailableAndInstalledExtensionsWithAdditionalInformation($this->backendUserFilter);
        ksort($availableAndInstalledExtensions);
        $this->view->assignMultiple(
            [
                'extensions' => $availableAndInstalledExtensions,
                'isComposerMode' => ‪Environment::isComposerMode(),
                'backendUserFilter' => $this->backendUserFilter ?: 'All'
            ]
        );
        $this->‪handleTriggerArguments();
    }
 
    public function ‪unresolvedDependenciesAction($extensionKey)
    {
        $availableExtensions = $this->listUtility->getAvailableExtensions();
        if (isset($availableExtensions[$extensionKey])) {
            $extensionArray = $this->listUtility->enrichExtensionsWithEmConfAndTerInformation(
                [
                    $extensionKey => $availableExtensions[$extensionKey]
                ]
            );
            $extensionModelUtility = $this->objectManager->get(ExtensionModelUtility::class);
            $extension = $extensionModelUtility->mapExtensionArrayToModel($extensionArray[$extensionKey]);
        } else {
            throw new ExtensionManagerException('Extension ' . $extensionKey . ' is not available', 1402421007);
        }
        $this->dependencyUtility->checkDependencies($extension);
        $this->view->assign('extension', $extension);
        $this->view->assign('unresolvedDependencies', $this->dependencyUtility->getDependencyErrors());
    }
 
    public function ‪terAction($search = '')
    {
        $this->‪addComposerModeNotification();
        $search = trim($search);
        if (!empty($search)) {
            $extensions = $this->extensionRepository->findByTitleOrAuthorNameOrExtensionKey($search);
        } else {
            $extensions = $this->extensionRepository->findAll();
        }
        $availableAndInstalledExtensions = $this->listUtility->getAvailableAndInstalledExtensions($this->listUtility->getAvailableExtensions());
        $this->view->assign('extensions', $extensions)
                ->assign('search', $search)
                ->assign('availableAndInstalled', $availableAndInstalledExtensions);
    }
 
    public function ‪distributionsAction($showUnsuitableDistributions = false)
    {
        $this->‪addComposerModeNotification();
        $importExportInstalled = ‪ExtensionManagementUtility::isLoaded('impexp');
        if ($importExportInstalled) {
            try {
                $repositoryHelper = $this->objectManager->get(Helper::class);
                // Check if a TER update has been done at all, if not, fetch it directly
                // Repository needs an update, but not because of the extension hash has changed
                $isExtListUpdateNecessary = $repositoryHelper->isExtListUpdateNecessary();
                if ($isExtListUpdateNecessary > 0 && ($isExtListUpdateNecessary & $repositoryHelper::PROBLEM_EXTENSION_HASH_CHANGED) === 0) {
                    $repositoryHelper->updateExtList();
                }
            } catch (ExtensionManagerException $e) {
                $this->‪addFlashMessage($e->getMessage(), $e->getCode(), ‪FlashMessage::ERROR);
            }
 
            $officialDistributions = $this->extensionRepository->findAllOfficialDistributions();
            $communityDistributions = $this->extensionRepository->findAllCommunityDistributions();
 
            $officialDistributions = $this->dependencyUtility->filterYoungestVersionOfExtensionList($officialDistributions->toArray(), $showUnsuitableDistributions);
            $communityDistributions = $this->dependencyUtility->filterYoungestVersionOfExtensionList($communityDistributions->toArray(), $showUnsuitableDistributions);
 
            $this->view->assign('officialDistributions', $officialDistributions);
            $this->view->assign('communityDistributions', $communityDistributions);
        }
        $this->view->assign('enableDistributionsView', $importExportInstalled);
        $this->view->assign('showUnsuitableDistributions', $showUnsuitableDistributions);
    }
 
    public function ‪showAllVersionsAction($extensionKey)
    {
        $currentVersion = $this->extensionRepository->findOneByCurrentVersionByExtensionKey($extensionKey);
        $extensions = $this->extensionRepository->findByExtensionKeyOrderedByVersion($extensionKey);
 
        $this->view->assignMultiple(
            [
                'extensionKey' => $extensionKey,
                'currentVersion' => $currentVersion,
                'extensions' => $extensions
            ]
        );
    }
 
    protected function ‪registerDocheaderButtons()
    {
        if (‪Environment::isComposerMode()) {
            return;
        }
 
        if (!in_array($this->actionMethodName, ['indexAction', 'terAction', 'showAllVersionsAction'], true)) {
            return;
        }
 
        $buttonBar = $this->view->getModuleTemplate()->getDocHeaderComponent()->getButtonBar();
        ‪$uriBuilder = $this->controllerContext->getUriBuilder();
 
        if ($this->actionMethodName === 'showAllVersionsAction') {
            $uri = ‪$uriBuilder->‪reset()->uriFor('ter', [], 'List');
            $title = $this->‪translate('extConfTemplate.backToList');
            $icon = $this->view->getModuleTemplate()->getIconFactory()->getIcon('actions-view-go-back', ‪Icon::SIZE_SMALL);
            $classes = '';
        } else {
            $uri = ‪$uriBuilder->‪reset()->uriFor('form', [], 'UploadExtensionFile');
            $title = $this->‪translate('extensionList.uploadExtension');
            $icon = $this->view->getModuleTemplate()->getIconFactory()->getIcon('actions-edit-upload', ‪Icon::SIZE_SMALL);
            $classes = 't3js-upload';
        }
        $button = $buttonBar->makeLinkButton()
            ->setHref($uri)
            ->setTitle($title)
            ->setClasses($classes)
            ->setIcon($icon);
        $buttonBar->addButton($button, ‪ButtonBar::BUTTON_POSITION_LEFT);
    }
 
    protected function ‪getBackendUserFilter(): string
    {
        $backendUser = $this->‪getBackendUserAuthentication();
 
        if (!$backendUser instanceof ‪BackendUserAuthentication) {
            return '';
        }
 
        return $backendUser->uc['BackendComponents']['States']['ExtensionManager']['filter'] ?? '';
    }
 
    protected function ‪saveBackendUserFilter(): void
    {
        $backendUser = $this->‪getBackendUserAuthentication();
 
        if (!$backendUser instanceof BackendUserAuthentication) {
            return;
        }
 
        $backendUserId = (int)$backendUser->user['uid'];
        $backendUserRecord = ‪BackendUtility::getRecord('be_users', $backendUserId);
 
        if (is_array($backendUserRecord) && isset($backendUserRecord['uc'])) {
            $uc = unserialize($backendUserRecord['uc'], ['allowed_classes' => false]);
            if (is_array($uc)) {
                $uc['BackendComponents']['States']['ExtensionManager']['filter'] = ‪$this->backendUserFilter;
                $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('be_users');
                $connection->update('be_users', ['uc' => serialize($uc)], ['uid' => $backendUserId], ['uc' => ‪Connection::PARAM_LOB]);
            }
        }
    }
 
    protected function ‪getBackendUserAuthentication(): ?BackendUserAuthentication
    {
        return ‪$GLOBALS['BE_USER'];
    }
}