9.5/_task_module_controller_8php_source.html

<?php

namespace ‪TYPO3\CMS\Taskcenter\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 Psr\Http\Message\ResponseInterface;

use Psr\Http\Message\ServerRequestInterface;

use ‪TYPO3\CMS\Backend\Template\ModuleTemplate;

use ‪TYPO3\CMS\Backend\Utility\BackendUtility;

use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;

use ‪TYPO3\CMS\Core\Compatibility\PublicMethodDeprecationTrait;

use ‪TYPO3\CMS\Core\Compatibility\PublicPropertyDeprecationTrait;

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

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\Core\Utility\PathUtility;

use ‪TYPO3\CMS\Fluid\View\StandaloneView;

use ‪TYPO3\CMS\Taskcenter\TaskInterface;


class ‪TaskModuleController

{

    use ‪PublicPropertyDeprecationTrait;

    use ‪PublicMethodDeprecationTrait;


    private ‪$deprecatedPublicProperties = [

        'MCONF' => 'Using TaskModuleController::$MCONF is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'id' => 'Using TaskModuleController::$id is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'MOD_MENU' => 'Using TaskModuleController::$MOD_MENU is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'modMenu_type' => 'Using TaskModuleController::$modMenu_type is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'modMenu_setDefaultList' => 'Using TaskModuleController::$$modMenu_setDefaultList is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'modMenu_dontValidateList' => 'Using TaskModuleController::$modMenu_dontValidateList is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'content' => 'Using TaskModuleController::$content is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'perms_clause' => 'Using TaskModuleController::$perms_clause is deprecated, the property will be removed in TYPO3 v10.0.',

        'CMD' => 'Using TaskModuleController::$CMD is deprecated, the property will be removed in TYPO3 v10.0.',

        'extClassConf' => 'Using TaskModuleController::$extClassConf is deprecated, the property will be removed in TYPO3 v10.0.',

        'extObj' => 'Using TaskModuleController::$extObj is deprecated, the property will be removed in TYPO3 v10.0.',

    ];


    private ‪$deprecatedPublicMethods = [

        'menuConfig' => 'Using TaskModuleController::menuConfig() is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'mergeExternalItems' => 'Using TaskModuleController::mergeExternalItems() is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'handleExternalFunctionValue' => 'Using TaskModuleController::handleExternalFunctionValue() is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'getExternalItemConfig' => 'Using TaskModuleController::getExternalItemConfig() is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'main' => 'Using TaskModuleController::main() is deprecated and will not be possible anymore in TYPO3 v10.0.',

        'urlInIframe' => 'Using TaskModuleController::urlInIframe() is deprecated. The method will be removed in TYPO3 v10.0.',

        'extObjHeader' => 'Using TaskModuleController::extObjHeader() is deprecated. The method will be removed in TYPO3 v10.0.',

        'checkSubExtObj' => 'Using TaskModuleController::checkSubExtObj() is deprecated. The method will be removed in TYPO3 v10.0.',

        'checkExtObj' => 'Using TaskModuleController::checkExtObj() is deprecated. The method will be removed in TYPO3 v10.0.',

        'extObjContent' => 'Using TaskModuleController::extObjContent() is deprecated. The method will be removed in TYPO3 v10.0.',

        'getExtObjContent' => 'Using TaskModuleController::getExtObjContent() is deprecated. The method will be removed in TYPO3 v10.0.',

    ];


    protected ‪$MCONF = [];


    protected ‪$id;


    protected ‪$CMD;


    protected ‪$perms_clause;


    protected ‪$MOD_MENU = [

        'function' => []

    ];


    public ‪$MOD_SETTINGS = [];


    public ‪$modTSconfig;


    protected ‪$modMenu_type = '';


    protected ‪$modMenu_dontValidateList = '';


    protected ‪$modMenu_setDefaultList = '';


    protected ‪$extClassConf;


    protected ‪$content = '';


    protected ‪$extObj;


    protected ‪$pageinfo;


    protected ‪$moduleTemplate;


    protected ‪$moduleName = 'user_task';


    public function ‪__construct()

    {

        $this->moduleTemplate = GeneralUtility::makeInstance(ModuleTemplate::class);

        $this->‪getLanguageService()->‪includeLLFile('EXT:taskcenter/Resources/Private/Language/locallang_task.xlf');

        $this->MCONF = [

            'name' => ‪$this->moduleName

        ];

        // Name might be set from outside

        if (!$this->MCONF['name']) {

            $this->MCONF = ‪$GLOBALS['MCONF'];

        }

        $this->id = (int)GeneralUtility::_GP('id');

        // @deprecated since TYPO3 v9, will be removed in TYPO3 v10.0.

        $this->CMD = GeneralUtility::_GP('CMD');

        // @deprecated since TYPO3 v9, will be removed in TYPO3 v10.0.

        $this->perms_clause = $this->‪getBackendUser()->‪getPagePermsClause(‪Permission::PAGE_SHOW);

        $this->‪menuConfig();

        $this->‪handleExternalFunctionValue();

    }


    protected function ‪menuConfig()

    {

        $this->MOD_MENU = ['mode' => []];

        $languageService = $this->‪getLanguageService();

        $this->MOD_MENU['mode']['information'] = $languageService->sL('LLL:EXT:taskcenter/Resources/Private/Language/locallang.xlf:task_overview');

        $this->MOD_MENU['mode']['tasks'] = $languageService->sL('LLL:EXT:taskcenter/Resources/Private/Language/locallang.xlf:task_tasks');

        // Copied from parent::menuConfig, because parent is hardcoded to menu.function,

        // however menu.function is already used for the individual tasks. Therefore we use menu.mode here.

        // Page/be_user TSconfig settings and blinding of menu-items

        $this->modTSconfig['properties'] = ‪BackendUtility::getPagesTSconfig($this->id)['mod.'][$this->moduleName . '.'] ?? [];

        $this->MOD_MENU['mode'] = $this->‪mergeExternalItems($this->MCONF['name'], 'mode', $this->MOD_MENU['mode']);

        $blindActions = $this->modTSconfig['properties']['menu.']['mode.'] ?? [];

        foreach ($blindActions as $key => $value) {

            if (!$value && array_key_exists($key, $this->MOD_MENU['mode'])) {

                unset($this->MOD_MENU['mode'][$key]);

            }

        }

        // Page / user TSconfig settings and blinding of menu-items

        // Now overwrite the stuff again for unknown reasons

        $this->modTSconfig['properties'] = ‪BackendUtility::getPagesTSconfig($this->id)['mod.'][$this->MCONF['name'] . '.'] ?? [];

        $this->MOD_MENU['function'] = $this->‪mergeExternalItems($this->MCONF['name'], '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]);

            }

        }

        $this->MOD_SETTINGS = ‪BackendUtility::getModuleData($this->MOD_MENU, GeneralUtility::_GP('SET'), $this->MCONF['name'], $this->modMenu_type, $this->modMenu_dontValidateList, $this->modMenu_setDefaultList);

    }


    protected function ‪generateMenu()

    {

        $menu = $this->moduleTemplate->getDocHeaderComponent()->getMenuRegistry()->makeMenu();

        $menu->setIdentifier('WebFuncJumpMenu');

        $uriBuilder = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\UriBuilder::class);

        foreach ($this->MOD_MENU['mode'] as $controller => $title) {

            $item = $menu

                ->makeMenuItem()

                ->setHref(

                    (string)$uriBuilder->buildUriFromRoute(

                        $this->moduleName,

                        [

                            'id' => $this->id,

                            'SET' => [

                                'mode' => $controller

                            ]

                        ]

                    )

                )

                ->setTitle($title);

            if ($controller === $this->MOD_SETTINGS['mode']) {

                $item->setActive(true);

            }

            $menu->addMenuItem($item);

        }

        $this->moduleTemplate->getDocHeaderComponent()->getMenuRegistry()->addMenu($menu);

    }


    public function ‪mainAction(ServerRequestInterface $request): ResponseInterface

    {

        // @deprecated since TYPO3 v9, will be removed in TYPO3 v10.0.

        ‪$GLOBALS['SOBE'] = $this;


        $this->‪main();

        $this->moduleTemplate->setContent($this->content);

        return new HtmlResponse($this->moduleTemplate->renderContent());

    }


    protected function ‪main()

    {

        $this->‪getButtons();

        $this->‪generateMenu();

        $this->moduleTemplate->addJavaScriptCode(

            'TaskCenterInlineJavascript',

            'if (top.fsMod) { top.fsMod.recentIds["web"] = 0; }'

        );


        // Render content depending on the mode

        $mode = (string)$this->MOD_SETTINGS['mode'];

        if ($mode === 'information') {

            $this->‪renderInformationContent();

        } else {

            $this->‪renderModuleContent();

        }

        // Renders the module page

        $this->moduleTemplate->setTitle($this->‪getLanguageService()->getLL('title'));

    }


    protected function ‪renderModuleContent()

    {

        $languageService = $this->‪getLanguageService();

        $chosenTask = (string)$this->MOD_SETTINGS['function'];

        // Render the taskcenter task as default

        if (empty($chosenTask) || $chosenTask === 'index') {

            $chosenTask = 'taskcenter.tasks';

        }

        // Render the task

        $actionContent = '';

        $flashMessage = null;

        list($extKey, $taskClass) = explode('.', $chosenTask, 2);

        if (class_exists($taskClass)) {

            $taskInstance = GeneralUtility::makeInstance($taskClass, $this);

            if ($taskInstance instanceof TaskInterface) {

                // Check if the task is restricted to admins only

                if ($this->‪checkAccess($extKey, $taskClass)) {

                    $actionContent .= $taskInstance->getTask();

                } else {

                    $flashMessage = GeneralUtility::makeInstance(

                        FlashMessage::class,

                        $languageService->getLL('error-access'),

                        $languageService->getLL('error_header'),

                        ‪FlashMessage::ERROR

                    );

                }

            } else {

                // Error if the task is not an instance of \TYPO3\CMS\Taskcenter\TaskInterface

                $flashMessage = GeneralUtility::makeInstance(

                    FlashMessage::class,

                    sprintf($languageService->getLL('error_no-instance'), $taskClass, TaskInterface::class),

                    $languageService->getLL('error_header'),

                    ‪FlashMessage::ERROR

                );

            }

        } else {

            $flashMessage = GeneralUtility::makeInstance(

                FlashMessage::class,

                $languageService->sL('LLL:EXT:taskcenter/Resources/Private/Language/locallang_mod.xlf:mlang_labels_tabdescr'),

                $languageService->sL('LLL:EXT:taskcenter/Resources/Private/Language/locallang_mod.xlf:mlang_tabs_tab'),

                ‪FlashMessage::INFO

            );

        }


        if ($flashMessage) {

            $flashMessageService = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Messaging\FlashMessageService::class);

            $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();

            $defaultFlashMessageQueue->enqueue($flashMessage);

        }


        $assigns = [];

        $assigns['reports'] = $this->‪indexAction();

        $assigns['taskClass'] = strtolower(str_replace('\\', '-', htmlspecialchars($extKey . '-' . $taskClass)));

        $assigns['actionContent'] = $actionContent;


        // Rendering of the output via fluid

        $view = GeneralUtility::makeInstance(StandaloneView::class);

        $view->setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName(

            'EXT:taskcenter/Resources/Private/Templates/ModuleContent.html'

        ));

        $view->assignMultiple($assigns);

        $this->content .= $view->render();

    }


    protected function ‪renderInformationContent()

    {

        $assigns = [];

        $assigns['LLPrefix'] = 'LLL:EXT:taskcenter/Resources/Private/Language/locallang.xlf:';

        $assigns['LLPrefixMod'] = 'LLL:EXT:taskcenter/Resources/Private/Language/locallang_mod.xlf:';

        $assigns['LLPrefixTask'] = 'LLL:EXT:taskcenter/Resources/Private/Language/locallang_task.xlf:';

        $assigns['admin'] = $this->‪getBackendUser()->‪isAdmin();


        // Rendering of the output via fluid

        $view = GeneralUtility::makeInstance(StandaloneView::class);

        $view->setTemplateRootPaths([GeneralUtility::getFileAbsFileName('EXT:taskcenter/Resources/Private/Templates')]);

        $view->setPartialRootPaths([GeneralUtility::getFileAbsFileName('EXT:taskcenter/Resources/Private/Partials')]);

        $view->setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName(

            'EXT:taskcenter/Resources/Private/Templates/InformationContent.html'

        ));

        $view->assignMultiple($assigns);

        $this->content .= $view->render();

    }


    public function ‪description($title, $description = '')

    {

        $descriptionView = GeneralUtility::makeInstance(StandaloneView::class);

        $descriptionView->setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName(

            'EXT:taskcenter/Resources/Private/Partials/Description.html'

        ));

        $descriptionView->assign('title', $title);

        $descriptionView->assign('description', $description);

        return $descriptionView->render();

    }


    public function ‪renderListMenu($items, $mainMenu = false)

    {

        $assigns = [];

        $assigns['mainMenu'] = $mainMenu;


        // Change the sorting of items to the user's one

        if ($mainMenu) {

            $userSorting = unserialize($this->‪getBackendUser()->uc['taskcenter']['sorting'], ['allowed_classes' => false]);

            if (is_array($userSorting)) {

                $newSorting = [];

                foreach ($userSorting as $item) {

                    if (isset($items[$item])) {

                        $newSorting[] = $items[$item];

                        unset($items[$item]);

                    }

                }

                $items = $newSorting + $items;

            }

        }

        if (is_array($items) && !empty($items)) {

            foreach ($items as $itemKey => &$item) {

                // Check for custom icon

                if (!empty($item['icon'])) {

                    if (strpos($item['icon'], '<img ') === false) {

                        $iconFile = GeneralUtility::getFileAbsFileName($item['icon']);

                        if (@is_file($iconFile)) {

                            $item['iconFile'] = ‪PathUtility::getAbsoluteWebPath($iconFile);

                        }

                    }

                }

                ‪$id = $this->‪getUniqueKey($item['uid']);

                $contentId = strtolower(str_replace('\\', '-', ‪$id));

                $item['uniqueKey'] = ‪$id;

                $item['contentId'] = $contentId;

                // Collapsed & expanded menu items

                if (isset($this->‪getBackendUser()->uc['taskcenter']['states'][‪$id]) && $this->‪getBackendUser()->uc['taskcenter']['states'][‪$id]) {

                    $item['ariaExpanded'] = 'true';

                    $item['collapseIcon'] = 'actions-view-list-expand';

                    $item['collapsed'] = '';

                } else {

                    $item['ariaExpanded'] = 'false';

                    $item['collapseIcon'] = 'actions-view-list-collapse';

                    $item['collapsed'] = 'in';

                }

                // Active menu item

                $panelState = (string)$this->MOD_SETTINGS['function'] == $item['uid'] ? 'panel-active' : 'panel-default';

                $item['panelState'] = $panelState;

            }

        }

        $assigns['items'] = $items;


        // Rendering of the output via fluid

        $view = GeneralUtility::makeInstance(StandaloneView::class);

        $view->setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName(

            'EXT:taskcenter/Resources/Private/Templates/ListMenu.html'

        ));

        $view->assignMultiple($assigns);

        return $view->render();

    }


    protected function ‪indexAction()

    {

        $languageService = $this->‪getLanguageService();

        ‪$content = '';

        $tasks = [];

        $defaultIcon = 'EXT:taskcenter/Resources/Public/Icons/module-taskcenter.svg';

        $uriBuilder = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\UriBuilder::class);

        // Render the tasks only if there are any available

        if (count(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['taskcenter'] ?? [])) {

            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['taskcenter'] as $extKey => $extensionReports) {

                foreach ($extensionReports as $taskClass => $task) {

                    if (!$this->‪checkAccess($extKey, $taskClass)) {

                        continue;

                    }

                    $link = (string)$uriBuilder->buildUriFromRoute('user_task') . '&SET[function]=' . $extKey . '.' . $taskClass;

                    $taskTitle = $languageService->sL($task['title']);

                    $taskDescriptionHtml = '';


                    if (class_exists($taskClass)) {

                        $taskInstance = GeneralUtility::makeInstance($taskClass, $this);

                        if ($taskInstance instanceof TaskInterface) {

                            $taskDescriptionHtml = $taskInstance->getOverview();

                        }

                    }

                    // Generate an array of all tasks

                    $uniqueKey = $this->‪getUniqueKey($extKey . '.' . $taskClass);

                    $tasks[$uniqueKey] = [

                        'title' => $taskTitle,

                        'descriptionHtml' => $taskDescriptionHtml,

                        'description' => $languageService->sL($task['description']),

                        'icon' => !empty($task['icon']) ? $task['icon'] : $defaultIcon,

                        'link' => $link,

                        'uid' => $extKey . '.' . $taskClass

                    ];

                }

            }

            ‪$content .= $this->‪renderListMenu($tasks, true);

        } else {

            $flashMessage = GeneralUtility::makeInstance(

                FlashMessage::class,

                $languageService->getLL('no-tasks'),

                '',

                ‪FlashMessage::INFO

            );

            $flashMessageService = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Messaging\FlashMessageService::class);

            $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();

            $defaultFlashMessageQueue->enqueue($flashMessage);

        }

        return ‪$content;

    }


    protected function ‪getButtons()

    {

        $buttonBar = $this->moduleTemplate->getDocHeaderComponent()->getButtonBar();


        // Shortcut

        $shortcutButton = $buttonBar->makeShortcutButton()

            ->setModuleName($this->moduleName)

            ->setSetVariables(['function']);

        $buttonBar->addButton($shortcutButton);

    }


    protected function ‪checkAccess($extKey, $taskClass): bool

    {

        $backendUser = $this->‪getBackendUser();

        // Admins are always allowed

        if ($backendUser->isAdmin()) {

            return true;

        }

        // Check if task is restricted to admins

        if ((int)‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['taskcenter'][$extKey][$taskClass]['admin'] === 1) {

            return false;

        }

        // Check if task is blinded with TsConfig (taskcenter.<extkey>.<taskName>

        return (bool)($backendUser->getTSConfig()['taskcenter.'][$extKey . '.'][$taskClass] ?? true);

    }


    protected function ‪urlInIframe($url)

    {

        $urlView = GeneralUtility::makeInstance(StandaloneView::class);

        $urlView->setTemplatePathAndFilename(GeneralUtility::getFileAbsFileName(

            'EXT:taskcenter/Resources/Private/Partials/UrlInIframe.html'

        ));

        $urlView->assign('url', $url);

        return $urlView->render();

    }


    protected function ‪getUniqueKey($string)

    {

        $search = ['.', '_'];

        $replace = ['-', ''];

        return str_replace($search, $replace, $string);

    }


    protected function ‪getBackendUser(): ‪BackendUserAuthentication

    {

        return ‪$GLOBALS['BE_USER'];

    }


    protected function ‪getLanguageService(): ‪LanguageService

    {

        return ‪$GLOBALS['LANG'];

    }


    public function ‪getModuleTemplate(): ModuleTemplate

    {

        return ‪$this->moduleTemplate;

    }


    protected function ‪mergeExternalItems($modName, $menuKey, $menuArr)

    {

        $mergeArray = ‪$GLOBALS['TBE_MODULES_EXT'][$modName]['MOD_MENU'][$menuKey];

        if (is_array($mergeArray)) {

            foreach ($mergeArray as $k => $v) {

                if (((string)$v['ws'] === '' || $this->‪getBackendUser()->workspace === 0 && GeneralUtility::inList($v['ws'], 'online')) || $this->‪getBackendUser()->workspace === -1 && GeneralUtility::inList($v['ws'], 'offline') || $this->‪getBackendUser()->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($this->MCONF['name'], $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()

    {

        if (is_array($this->extClassConf) && $this->extClassConf['name']) {

            $this->extObj = GeneralUtility::makeInstance($this->extClassConf['name']);

            $this->extObj->init($this, $this->extClassConf);

            // Re-write:

            $this->MOD_SETTINGS = ‪BackendUtility::getModuleData($this->MOD_MENU, GeneralUtility::_GP('SET'), $this->MCONF['name'], $this->modMenu_type, $this->modMenu_dontValidateList, $this->modMenu_setDefaultList);

        }

    }


    protected function ‪checkSubExtObj()

    {

        if (is_object($this->extObj)) {

            $this->extObj->checkExtObj();

        }

    }


    protected function ‪extObjHeader()

    {

        if (is_callable([$this->extObj, 'head'])) {

            $this->extObj->head();

        }

    }


    protected function ‪extObjContent()

    {

        if ($this->extObj === null) {

            $flashMessage = GeneralUtility::makeInstance(

                FlashMessage::class,

                $this->‪getLanguageService()->sL('LLL:EXT:backend/Resources/Private/Language/locallang.xlf:no_modules_registered'),

                $this->‪getLanguageService()->getLL('title'),

                ‪FlashMessage::ERROR

            );

            $flashMessageService = GeneralUtility::makeInstance(FlashMessageService::class);

            $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();

            $defaultFlashMessageQueue->enqueue($flashMessage);

        } else {

            $this->extObj->pObj = $this;

            if (is_callable([$this->extObj, 'main'])) {

                $this->content .= $this->extObj->main();

            }

        }

    }


    protected function ‪getExtObjContent()

    {

        $savedContent = ‪$this->content;

        $this->content = '';

        $this->‪extObjContent();

        $newContent = ‪$this->content;

        $this->content = $savedContent;

        return $newContent;

    }


    protected function ‪getPageRenderer(): PageRenderer

    {

        return GeneralUtility::makeInstance(PageRenderer::class);

    }

}