InfoModuleController.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\Info\Controller;
 
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Backend\Routing\PreviewUriBuilder;
use ‪TYPO3\CMS\Backend\Routing\UriBuilder;
use ‪TYPO3\CMS\Backend\Template\Components\ButtonBar;
use ‪TYPO3\CMS\Backend\Template\ModuleTemplate;
use ‪TYPO3\CMS\Backend\Template\ModuleTemplateFactory;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Http\HtmlResponse;
use ‪TYPO3\CMS\Core\Imaging\Icon;
use ‪TYPO3\CMS\Core\Imaging\IconFactory;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Messaging\FlashMessage;
use ‪TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Type\Bitmask\Permission;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Fluid\View\StandaloneView;
 
class ‪InfoModuleController
{
    public ‪$pageinfo = [];
 
    protected ‪$moduleName = 'web_info';
 
    protected ‪$moduleTemplate;
 
    protected ‪$view;
 
    protected ‪$id;
 
    protected ‪$perms_clause;
 
    public ‪$MOD_MENU = [
        'function' => [],
    ];
 
    public ‪$MOD_SETTINGS = [];
 
    protected ‪$modTSconfig;
 
    protected ‪$modMenu_type = '';
 
    protected ‪$modMenu_dontValidateList = '';
 
    protected ‪$modMenu_setDefaultList = '';
 
    protected ‪$extClassConf;
 
    protected ‪$content = '';
 
    protected ‪$extObj;
 
    protected ‪IconFactory ‪$iconFactory;
    protected PageRenderer ‪$pageRenderer;
    protected ‪UriBuilder ‪$uriBuilder;
    protected ‪FlashMessageService ‪$flashMessageService;
    protected ContainerInterface ‪$container;
    protected ‪ModuleTemplateFactory ‪$moduleTemplateFactory;
 
    public function ‪__construct(
        ‪IconFactory ‪$iconFactory,
        PageRenderer ‪$pageRenderer,
        ‪UriBuilder ‪$uriBuilder,
        ‪FlashMessageService ‪$flashMessageService,
        ContainerInterface ‪$container,
        ‪ModuleTemplateFactory ‪$moduleTemplateFactory
    ) {
        $this->iconFactory = ‪$iconFactory;
        $this->pageRenderer = ‪$pageRenderer;
        $this->uriBuilder = ‪$uriBuilder;
        $this->flashMessageService = ‪$flashMessageService;
        $this->container = ‪$container;
        $this->moduleTemplateFactory = ‪$moduleTemplateFactory;
 
        $this->‪getLanguageService()->‪includeLLFile('EXT:info/Resources/Private/Language/locallang_mod_web_info.xlf');
    }
 
    protected function ‪init(ServerRequestInterface $request)
    {
        $this->id = (int)($request->getQueryParams()['id'] ?? $request->getParsedBody()['id'] ?? 0);
        $this->perms_clause = $this->‪getBackendUser()->‪getPagePermsClause(‪Permission::PAGE_SHOW);
        $this->‪menuConfig($request);
        $this->‪handleExternalFunctionValue();
    }
 
    protected function ‪main(ServerRequestInterface $request)
    {
        $backendUser = $this->‪getBackendUser();
 
        // The page will show only if there is a valid page and if this page
        // may be viewed by the user
        $this->pageinfo = BackendUtility::readPageAccess($this->id, $this->perms_clause) ?: [];
        if ($this->pageinfo !== []) {
            $this->moduleTemplate->getDocHeaderComponent()->setMetaInformation($this->pageinfo);
        }
        $access = $this->pageinfo !== [];
        if ($this->id && $access || $backendUser->isAdmin() && !$this->id) {
            if ($backendUser->isAdmin() && !$this->id) {
                $this->pageinfo = ['title' => '[root-level]', 'uid' => 0, 'pid' => 0];
            }
            // Setting up the context sensitive menu:
            $this->pageRenderer->loadRequireJsModule('TYPO3/CMS/Backend/ContextMenu');
            $this->pageRenderer->loadRequireJsModule('TYPO3/CMS/Backend/Element/ImmediateActionElement');
 
            $this->view = $this->‪getFluidTemplateObject();
            $this->view->assign('id', (int)$this->id);
            $this->view->assign('moduleName', (string)$this->uriBuilder->buildUriFromRoute($this->moduleName));
            $this->view->assign('functionMenuModuleContent', $this->‪extObjContent($request));
            // Setting up the buttons and markers for doc header
            $this->‪getButtons($request);
            $this->‪generateMenu();
            $this->content = $this->view->render();
        } else {
            // If no access or if ID == zero
            $this->content = $this->moduleTemplate->header($this->‪getLanguageService()->getLL('title'), false);
        }
 
        $this->moduleTemplate->setTitle(
            $this->‪getLanguageService()->sL($this->extClassConf['title']),
            $this->id !== 0 && isset($this->pageinfo['title']) ? $this->pageinfo['title'] : ''
        );
    }
 
    public function ‪mainAction(ServerRequestInterface $request): ResponseInterface
    {
        $this->moduleTemplate = $this->moduleTemplateFactory->create($request);
 
        $this->‪init($request);
 
        // Checking for first level external objects
        $this->‪checkExtObj($request);
 
        $this->‪main($request);
 
        $this->moduleTemplate->setContent($this->content);
        return new ‪HtmlResponse($this->moduleTemplate->renderContent());
    }
 
    protected function ‪getButtons(ServerRequestInterface $request)
    {
        $languageService = $this->‪getLanguageService();
        $buttonBar = $this->moduleTemplate->getDocHeaderComponent()->getButtonBar();
        // View page
        $previewDataAttributes = ‪PreviewUriBuilder::create((int)$this->pageinfo['uid'])
            ->withRootLine(BackendUtility::BEgetRootLine($this->pageinfo['uid']))
            ->buildDispatcherDataAttributes();
        $viewButton = $buttonBar->makeLinkButton()
            ->setHref('#')
            ->setDataAttributes($previewDataAttributes ?? [])
            ->setTitle($languageService->sL('LLL:EXT:core/Resources/Private/Language/locallang_core.xlf:labels.showPage'))
            ->setIcon($this->iconFactory->getIcon('actions-view-page', ‪Icon::SIZE_SMALL));
        $buttonBar->addButton($viewButton, ‪ButtonBar::BUTTON_POSITION_LEFT, 1);
 
        // Shortcut
        $shortcutArguments = [
            'id' => $request->getQueryParams()['id'] ?? 0,
        ];
        foreach (array_keys($this->MOD_MENU) as $key) {
            if (!empty($this->MOD_SETTINGS[$key])) {
                if (!is_array($shortcutArguments['SET'] ?? null)) {
                    $shortcutArguments['SET'] = [];
                }
                $shortcutArguments['SET'][$key] = $this->MOD_SETTINGS[$key];
            }
        }
        $shortCutButton = $buttonBar->makeShortcutButton()
            ->setRouteIdentifier($this->moduleName)
            ->setDisplayName($this->MOD_MENU['function'][$this->MOD_SETTINGS['function']])
            ->setArguments($shortcutArguments);
        $buttonBar->addButton($shortCutButton, ‪ButtonBar::BUTTON_POSITION_RIGHT);
 
        // CSH
        $cshButton = $buttonBar->makeHelpButton()
            ->setModuleName('xMOD_csh_corebe')
            ->setFieldName('pagetree_overview');
        $buttonBar->addButton($cshButton);
    }
 
    protected function ‪generateMenu()
    {
        $menu = $this->moduleTemplate->getDocHeaderComponent()->getMenuRegistry()->makeMenu();
        $menu->setIdentifier('WebInfoJumpMenu');
        foreach ($this->MOD_MENU['function'] as $controller => $title) {
            $item = $menu
                ->makeMenuItem()
                ->setHref(
                    (string)$this->uriBuilder->buildUriFromRoute(
                        $this->moduleName,
                        [
                            'id' => $this->id,
                            'SET' => [
                                'function' => $controller,
                            ],
                        ]
                    )
                )
                ->setTitle($title);
            if ($controller === $this->MOD_SETTINGS['function']) {
                $item->setActive(true);
            }
            $menu->addMenuItem($item);
        }
        $this->moduleTemplate->getDocHeaderComponent()->getMenuRegistry()->addMenu($menu);
    }
 
    protected function ‪getFluidTemplateObject()
    {
        ‪$view = GeneralUtility::makeInstance(StandaloneView::class);
        ‪$view->‪setLayoutRootPaths([GeneralUtility::getFileAbsFileName('EXT:info/Resources/Private/Layouts')]);
        ‪$view->‪setPartialRootPaths([GeneralUtility::getFileAbsFileName('EXT:info/Resources/Private/Partials')]);
        ‪$view->‪setTemplateRootPaths([GeneralUtility::getFileAbsFileName('EXT:info/Resources/Private/Templates')]);
 
        ‪$view->‪setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName('EXT:info/Resources/Private/Templates/Main.html'));
 
        ‪$view->‪getRequest()->‪setControllerExtensionName('info');
        return ‪$view;
    }
 
    protected function ‪menuConfig(ServerRequestInterface $request)
    {
        // Page / user TSconfig settings and blinding of menu-items
        $this->modTSconfig['properties'] = BackendUtility::getPagesTSconfig($this->id)['mod.']['web_info.'] ?? [];
        $this->MOD_MENU['function'] = $this->‪mergeExternalItems('web_info', 'function', $this->MOD_MENU['function']);
        $blindActions = $this->modTSconfig['properties']['menu.']['function.'] ?? [];
        foreach ($blindActions as $key => $value) {
            if (!$value && array_key_exists($key, $this->MOD_MENU['function'])) {
                unset($this->MOD_MENU['function'][$key]);
            }
        }
        $moduleSet = $request->getParsedBody()['SET'] ?? $request->getQueryParams()['SET'] ?? [];
        $this->MOD_SETTINGS = BackendUtility::getModuleData($this->MOD_MENU, $moduleSet, 'web_info', $this->modMenu_type, $this->modMenu_dontValidateList, $this->modMenu_setDefaultList);
    }
 
    protected function ‪mergeExternalItems($modName, $menuKey, $menuArr)
    {
        $mergeArray = ‪$GLOBALS['TBE_MODULES_EXT'][$modName]['MOD_MENU'][$menuKey];
        if (is_array($mergeArray)) {
            $backendUser = $this->‪getBackendUser();
            foreach ($mergeArray as $k => $v) {
                if (((string)$v['ws'] === '' || ($backendUser->workspace === 0 && GeneralUtility::inList($v['ws'], 'online')))
                    || ($backendUser->workspace > 0 && GeneralUtility::inList($v['ws'], 'custom'))
                ) {
                    $menuArr[$k] = $this->‪getLanguageService()->‪sL($v['title']);
                }
            }
        }
        return $menuArr;
    }
 
    protected function ‪handleExternalFunctionValue($MM_key = 'function', $MS_value = null)
    {
        if ($MS_value === null) {
            $MS_value = $this->MOD_SETTINGS[$MM_key];
        }
        $this->extClassConf = $this->‪getExternalItemConfig('web_info', $MM_key, $MS_value);
    }
 
    protected function ‪getExternalItemConfig($modName, $menuKey, $value = '')
    {
        if (isset(‪$GLOBALS['TBE_MODULES_EXT'][$modName])) {
            return (string)$value !== ''
                ? ‪$GLOBALS['TBE_MODULES_EXT'][$modName]['MOD_MENU'][$menuKey][$value]
                : ‪$GLOBALS['TBE_MODULES_EXT'][$modName]['MOD_MENU'][$menuKey];
        }
        return null;
    }
 
    protected function ‪checkExtObj(ServerRequestInterface $request)
    {
        if (is_array($this->extClassConf) && $this->extClassConf['name']) {
            if ($this->container->has($this->extClassConf['name'])) {
                $this->extObj = $this->container->get($this->extClassConf['name']);
            } else {
                $this->extObj = GeneralUtility::makeInstance($this->extClassConf['name']);
            }
            if (is_callable([$this->extObj, 'init'])) {
                $this->extObj->init($this, $request);
            }
            // Re-write:
            $moduleSet = $request->getParsedBody()['SET'] ?? $request->getQueryParams()['SET'] ?? [];
            $this->MOD_SETTINGS = BackendUtility::getModuleData($this->MOD_MENU, $moduleSet, 'web_info', $this->modMenu_type, $this->modMenu_dontValidateList, $this->modMenu_setDefaultList);
        }
    }
 
    protected function ‪extObjContent(ServerRequestInterface $request)
    {
        if ($this->extObj === null) {
            $languageService = $this->‪getLanguageService();
            $flashMessage = GeneralUtility::makeInstance(
                FlashMessage::class,
                $languageService->sL('LLL:EXT:backend/Resources/Private/Language/locallang.xlf:no_modules_registered'),
                $languageService->getLL('title'),
                ‪FlashMessage::ERROR
            );
            $defaultFlashMessageQueue = $this->flashMessageService->getMessageQueueByIdentifier();
            $defaultFlashMessageQueue->enqueue($flashMessage);
        } else {
            if (is_callable([$this->extObj, 'main'])) {
                $main = $this->extObj->main($request);
                if ($main instanceof ResponseInterface) {
                    $stream = $main->getBody();
                    $stream->rewind();
                    $main = $stream->getContents();
                }
                return $main;
            }
        }
    }
 
    protected function ‪getLanguageService(): LanguageService
    {
        return ‪$GLOBALS['LANG'];
    }
 
    protected function ‪getBackendUser(): BackendUserAuthentication
    {
        return ‪$GLOBALS['BE_USER'];
    }
}