FluidTemplateContentObject.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\Frontend\ContentObject;
 
use ‪TYPO3\CMS\Core\TypoScript\TypoScriptService;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
use ‪TYPO3\CMS\Extbase\Mvc\Web\RequestBuilder;
use ‪TYPO3\CMS\Fluid\View\StandaloneView;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ContentRenderingException;
 
class ‪FluidTemplateContentObject extends ‪AbstractContentObject
{
    protected ‪$view;
 
    protected ‪$contentDataProcessor;
 
    public function ‪__construct(ContentObjectRenderer ‪$cObj)
    {
        parent::__construct(‪$cObj);
        $this->contentDataProcessor = GeneralUtility::makeInstance(ContentDataProcessor::class);
    }
 
    public function ‪setContentDataProcessor(‪$contentDataProcessor)
    {
        $this->contentDataProcessor = ‪$contentDataProcessor;
    }
 
    public function ‪render($conf = [])
    {
        $parentView = ‪$this->view;
        $this->‪initializeStandaloneViewInstance();
 
        if (!is_array($conf)) {
            $conf = [];
        }
 
        $this->‪setFormat($conf);
        $this->‪setTemplate($conf);
        $this->‪setLayoutRootPath($conf);
        $this->‪setPartialRootPath($conf);
        $this->‪setExtbaseVariables($conf);
        $this->‪assignSettings($conf);
        $variables = $this->‪getContentObjectVariables($conf);
        $variables = $this->contentDataProcessor->process($this->cObj, $conf, $variables);
 
        $this->view->assignMultiple($variables);
 
        $this->‪renderFluidTemplateAssetsIntoPageRenderer();
        $content = $this->‪renderFluidView();
        $content = $this->‪applyStandardWrapToRenderedContent($content, $conf);
 
        $this->view = $parentView;
        return $content;
    }
 
    protected function ‪renderFluidTemplateAssetsIntoPageRenderer()
    {
        ‪$pageRenderer = $this->‪getPageRenderer();
        $headerAssets = $this->view->renderSection('HeaderAssets', ['contentObject' => $this], true);
        $footerAssets = $this->view->renderSection('FooterAssets', ['contentObject' => $this], true);
        if (!empty(trim($headerAssets))) {
            ‪$pageRenderer->addHeaderData($headerAssets);
        }
        if (!empty(trim($footerAssets))) {
            ‪$pageRenderer->addFooterData($footerAssets);
        }
    }
 
    protected function ‪initializeStandaloneViewInstance()
    {
        $this->view = GeneralUtility::makeInstance(StandaloneView::class);
    }
 
    protected function ‪setTemplate(array $conf)
    {
        // Fetch the Fluid template by templateName
        if (
            (!empty($conf['templateName']) || !empty($conf['templateName.']))
            && !empty($conf['templateRootPaths.']) && is_array($conf['templateRootPaths.'])
        ) {
            $templateRootPaths = $this->‪applyStandardWrapToFluidPaths($conf['templateRootPaths.']);
            $this->view->setTemplateRootPaths($templateRootPaths);
            $templateName = $this->cObj->stdWrapValue('templateName', $conf ?? []);
            $this->view->setTemplate($templateName);
        } elseif (!empty($conf['template']) && !empty($conf['template.'])) {
            // Fetch the Fluid template by template cObject
            $templateSource = $this->cObj->cObjGetSingle($conf['template'], $conf['template.'], 'template');
            if ($templateSource === '') {
                throw new ‪ContentRenderingException(
                    'Could not find template source for ' . $conf['template'],
                    1437420865
                );
            }
            $this->view->setTemplateSource($templateSource);
        } else {
            // Fetch the Fluid template by file stdWrap
            $file = (string)$this->cObj->stdWrapValue('file', $conf ?? []);
            // Get the absolute file name
            $templatePathAndFilename = GeneralUtility::getFileAbsFileName($file);
            $this->view->setTemplatePathAndFilename($templatePathAndFilename);
        }
    }
 
    protected function ‪setLayoutRootPath(array $conf)
    {
        // Override the default layout path via typoscript
        $layoutPaths = [];
 
        $layoutRootPath = (string)$this->cObj->stdWrapValue('layoutRootPath', $conf ?? []);
        if ($layoutRootPath !== '') {
            $layoutPaths[] = GeneralUtility::getFileAbsFileName($layoutRootPath);
        }
        if (isset($conf['layoutRootPaths.'])) {
            $layoutPaths = array_replace($layoutPaths, $this->‪applyStandardWrapToFluidPaths($conf['layoutRootPaths.']));
        }
        if (!empty($layoutPaths)) {
            $this->view->setLayoutRootPaths($layoutPaths);
        }
    }
 
    protected function ‪setPartialRootPath(array $conf)
    {
        $partialPaths = [];
 
        $partialRootPath = (string)$this->cObj->stdWrapValue('partialRootPath', $conf ?? []);
        if ($partialRootPath !== '') {
            $partialPaths[] = GeneralUtility::getFileAbsFileName($partialRootPath);
        }
        if (isset($conf['partialRootPaths.'])) {
            $partialPaths = array_replace($partialPaths, $this->‪applyStandardWrapToFluidPaths($conf['partialRootPaths.']));
        }
        if (!empty($partialPaths)) {
            $this->view->setPartialRootPaths($partialPaths);
        }
    }
 
    protected function ‪setFormat(array $conf)
    {
        $format = $this->cObj->stdWrapValue('format', $conf ?? []);
        if ($format) {
            $this->view->setFormat($format);
        }
    }
 
    protected function ‪setExtbaseVariables(array $conf)
    {
        $requestPluginName = $this->cObj->stdWrapValue('pluginName', $conf['extbase.'] ?? []);
        if ($requestPluginName) {
            $this->view->getRequest()->setPluginName($requestPluginName);
        }
        $requestControllerExtensionName = $this->cObj->stdWrapValue('controllerExtensionName', $conf['extbase.'] ?? []);
        if ($requestControllerExtensionName) {
            $this->view->getRequest()->setControllerExtensionName($requestControllerExtensionName);
        }
        $requestControllerName = $this->cObj->stdWrapValue('controllerName', $conf['extbase.'] ?? []);
        if ($requestControllerName) {
            $this->view->getRequest()->setControllerName($requestControllerName);
        }
        $requestControllerActionName = $this->cObj->stdWrapValue('controllerActionName', $conf['extbase.'] ?? []);
        if ($requestControllerActionName) {
            $this->view->getRequest()->setControllerActionName($requestControllerActionName);
        }
 
        if (
            $requestPluginName
            && $requestControllerExtensionName
            && $requestControllerName
            && $requestControllerActionName
        ) {
            $configurationManager = GeneralUtility::makeInstance(ConfigurationManager::class);
            $configurationManager->setConfiguration([
                'extensionName' => $requestControllerExtensionName,
                'pluginName' => $requestPluginName,
            ]);
 
            if (!isset(‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['extbase']['extensions'][$requestControllerExtensionName]['plugins'][$requestPluginName]['controllers'])) {
                ‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['extbase']['extensions'][$requestControllerExtensionName]['plugins'][$requestPluginName]['controllers'] = [
                    $requestControllerName => [
                        'actions' => [
                            $requestControllerActionName,
                        ],
                    ],
                ];
            }
 
            $requestBuilder = GeneralUtility::makeInstance(RequestBuilder::class);
            $this->view->getRenderingContext()->setRequest($requestBuilder->build($this->request));
        }
    }
 
    protected function ‪getContentObjectVariables(array $conf)
    {
        $variables = [];
        $reservedVariables = ['data', 'current'];
        // Accumulate the variables to be process and loop them through cObjGetSingle
        $variablesToProcess = (array)($conf['variables.'] ?? []);
        foreach ($variablesToProcess as $variableName => $cObjType) {
            if (is_array($cObjType)) {
                continue;
            }
            if (!in_array($variableName, $reservedVariables)) {
                $cObjConf = $variablesToProcess[$variableName . '.'] ?? [];
                $variables[$variableName] = $this->cObj->cObjGetSingle($cObjType, $cObjConf, 'variables.' . $variableName);
            } else {
                throw new \InvalidArgumentException(
                    'Cannot use reserved name "' . $variableName . '" as variable name in FLUIDTEMPLATE.',
                    1288095720
                );
            }
        }
        $variables['data'] = $this->cObj->data;
        $variables['current'] = $this->cObj->data[$this->cObj->currentValKey ?? null] ?? null;
        return $variables;
    }
 
    protected function ‪assignSettings(array $conf)
    {
        if (isset($conf['settings.'])) {
            $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);
            $settings = $typoScriptService->convertTypoScriptArrayToPlainArray($conf['settings.']);
            $this->view->assign('settings', $settings);
        }
    }
 
    protected function ‪renderFluidView()
    {
        return $this->view->render();
    }
 
    protected function ‪applyStandardWrapToRenderedContent($content, array $conf)
    {
        if (isset($conf['stdWrap.'])) {
            $content = $this->cObj->stdWrap($content, $conf['stdWrap.']);
        }
        return $content;
    }
 
    protected function ‪applyStandardWrapToFluidPaths(array $paths)
    {
        $finalPaths = [];
        foreach ($paths as $key => $path) {
            if (str_ends_with((string)$key, '.')) {
                if (isset($paths[substr($key, 0, -1)])) {
                    continue;
                }
                $path = $this->cObj->stdWrap('', $path);
            } elseif (isset($paths[$key . '.'])) {
                $path = $this->cObj->stdWrap($path, $paths[$key . '.']);
            }
            $finalPaths[$key] = GeneralUtility::getFileAbsFileName($path);
        }
        return $finalPaths;
    }
}