AbstractTemplateView.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Fluid\View;

/*                                                                        *
 * This script is backported from the TYPO3 Flow package "TYPO3.Fluid".   *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 *  of the License, or (at your option) any later version.                *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

abstract class AbstractTemplateView implements \TYPO3\CMS\Extbase\Mvc\View\ViewInterface
{
    const RENDERING_TEMPLATE = 1;
    const RENDERING_PARTIAL = 2;
    const RENDERING_LAYOUT = 3;

    protected $controllerContext;

    protected $objectManager;

    protected $templateParser;

    protected $templateCompiler;

    protected $baseRenderingContext;

    protected $renderingStack = [];

    protected $partialIdentifierCache = [];

    public function injectTemplateCompiler(\TYPO3\CMS\Fluid\Core\Compiler\TemplateCompiler $templateCompiler)
    {
        $this->templateCompiler = $templateCompiler;
        $this->templateCompiler->setTemplateCache(\TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class)->getCache('fluid_template'));
    }

    public function setRenderingContext(\TYPO3\CMS\Fluid\Core\Rendering\RenderingContextInterface $renderingContext)
    {
        $this->baseRenderingContext = $renderingContext;
        $this->baseRenderingContext->getViewHelperVariableContainer()->setView($this);
        $this->controllerContext = $renderingContext->getControllerContext();
    }

    public function setControllerContext(\TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext $controllerContext)
    {
        $this->controllerContext = $controllerContext;
    }

    public function initializeView()
    {
    }
    // Here, the backporter can insert the initializeView method, which is needed for Fluid v4.

    public function assign($key, $value)
    {
        $templateVariableContainer = $this->baseRenderingContext->getTemplateVariableContainer();
        if ($templateVariableContainer->exists($key)) {
            $templateVariableContainer->remove($key);
        }
        $templateVariableContainer->add($key, $value);
        return $this;
    }

    public function assignMultiple(array $values)
    {
        $templateVariableContainer = $this->baseRenderingContext->getTemplateVariableContainer();
        foreach ($values as $key => $value) {
            if ($templateVariableContainer->exists($key)) {
                $templateVariableContainer->remove($key);
            }
            $templateVariableContainer->add($key, $value);
        }
        return $this;
    }

    public function render($actionName = null)
    {
        $this->baseRenderingContext->setControllerContext($this->controllerContext);
        $this->templateParser->setConfiguration($this->buildParserConfiguration());

        $templateIdentifier = $this->getTemplateIdentifier($actionName);
        if ($this->templateCompiler->has($templateIdentifier)) {
            $parsedTemplate = $this->templateCompiler->get($templateIdentifier);
        } else {
            $parsedTemplate = $this->templateParser->parse($this->getTemplateSource($actionName));
            if ($parsedTemplate->isCompilable()) {
                $this->templateCompiler->store($templateIdentifier, $parsedTemplate);
            }
        }

        if ($parsedTemplate->hasLayout()) {
            $layoutName = $parsedTemplate->getLayoutName($this->baseRenderingContext);
            $layoutIdentifier = $this->getLayoutIdentifier($layoutName);
            if ($this->templateCompiler->has($layoutIdentifier)) {
                $parsedLayout = $this->templateCompiler->get($layoutIdentifier);
            } else {
                $parsedLayout = $this->templateParser->parse($this->getLayoutSource($layoutName));
                if ($parsedLayout->isCompilable()) {
                    $this->templateCompiler->store($layoutIdentifier, $parsedLayout);
                }
            }
            $this->startRendering(self::RENDERING_LAYOUT, $parsedTemplate, $this->baseRenderingContext);
            $output = $parsedLayout->render($this->baseRenderingContext);
            $this->stopRendering();
        } else {
            $this->startRendering(self::RENDERING_TEMPLATE, $parsedTemplate, $this->baseRenderingContext);
            $output = $parsedTemplate->render($this->baseRenderingContext);
            $this->stopRendering();
        }

        return $output;
    }

    public function renderSection($sectionName, array $variables, $ignoreUnknown = false)
    {
        $renderingContext = $this->getCurrentRenderingContext();
        if ($this->getCurrentRenderingType() === self::RENDERING_LAYOUT) {
            // in case we render a layout right now, we will render a section inside a TEMPLATE.
            $renderingTypeOnNextLevel = self::RENDERING_TEMPLATE;
        } else {
            $variableContainer = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\ViewHelper\TemplateVariableContainer::class, $variables);
            $renderingContext = clone $renderingContext;
            $renderingContext->injectTemplateVariableContainer($variableContainer);
            $renderingTypeOnNextLevel = $this->getCurrentRenderingType();
        }

        $parsedTemplate = $this->getCurrentParsedTemplate();

        if ($parsedTemplate->isCompiled()) {
            $methodNameOfSection = 'section_' . sha1($sectionName);
            if ($ignoreUnknown && !method_exists($parsedTemplate, $methodNameOfSection)) {
                return '';
            }
            $this->startRendering($renderingTypeOnNextLevel, $parsedTemplate, $renderingContext);
            $output = $parsedTemplate->{$methodNameOfSection}($renderingContext);
            $this->stopRendering();
        } else {
            $sections = $parsedTemplate->getVariableContainer()->get('sections');
            if (!array_key_exists($sectionName, $sections)) {
                $controllerObjectName = $this->controllerContext->getRequest()->getControllerObjectName();
                if ($ignoreUnknown) {
                    return '';
                } else {
                    throw new \TYPO3\CMS\Fluid\View\Exception\InvalidSectionException(sprintf('Could not render unknown section "%s" in %s used by %s.', $sectionName, get_class($this), $controllerObjectName), 1227108982);
                }
            }
            $section = $sections[$sectionName];

            $renderingContext->getViewHelperVariableContainer()->add(\TYPO3\CMS\Fluid\ViewHelpers\SectionViewHelper::class, 'isCurrentlyRenderingSection', 'TRUE');

            $this->startRendering($renderingTypeOnNextLevel, $parsedTemplate, $renderingContext);
            $output = $section->evaluate($renderingContext);
            $this->stopRendering();
        }

        return $output;
    }

    public function renderPartial($partialName, $sectionName, array $variables)
    {
        $partialNameWithFormat = $partialName . '.' . $this->controllerContext->getRequest()->getFormat();
        if (!isset($this->partialIdentifierCache[$partialNameWithFormat])) {
            $this->partialIdentifierCache[$partialNameWithFormat] = $this->getPartialIdentifier($partialName);
        }
        $partialIdentifier = $this->partialIdentifierCache[$partialNameWithFormat];

        if ($this->templateCompiler->has($partialIdentifier)) {
            $parsedPartial = $this->templateCompiler->get($partialIdentifier);
        } else {
            $parsedPartial = $this->templateParser->parse($this->getPartialSource($partialName));
            if ($parsedPartial->isCompilable()) {
                $this->templateCompiler->store($partialIdentifier, $parsedPartial);
            }
        }

        $variableContainer = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\ViewHelper\TemplateVariableContainer::class, $variables);
        $renderingContext = clone $this->getCurrentRenderingContext();
        $renderingContext->injectTemplateVariableContainer($variableContainer);

        $this->startRendering(self::RENDERING_PARTIAL, $parsedPartial, $renderingContext);
        if ($sectionName !== null) {
            $output = $this->renderSection($sectionName, $variables);
        } else {
            $output = $parsedPartial->render($renderingContext);
        }
        $this->stopRendering();

        return $output;
    }

    protected function ucFileNameInPath($templatePath)
    {
        if (strpos($templatePath, '/') > 0) {
            $pathParts = explode('/', $templatePath);
            $index = count($pathParts) - 1;
            $pathParts[$index] = ucfirst($pathParts[$index]);

            $upperCasedTemplateName = implode('/', $pathParts);
        } else {
            $upperCasedTemplateName = ucfirst($templatePath);
        }
        return $upperCasedTemplateName;
    }

    protected function testFileExistence($filePath)
    {
        return is_file($filePath);
    }

    abstract protected function getTemplateIdentifier($actionName = null);

    abstract protected function getTemplateSource($actionName = null);

    abstract protected function getLayoutIdentifier($layoutName = 'Default');

    abstract protected function getLayoutSource($layoutName = 'Default');

    abstract protected function getPartialIdentifier($partialName);

    abstract protected function getPartialSource($partialName);

    protected function buildParserConfiguration()
    {
        $parserConfiguration = $this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\Configuration::class);
        if ($this->controllerContext->getRequest()->getFormat() === 'html') {
            $parserConfiguration->addInterceptor($this->objectManager->get(\TYPO3\CMS\Fluid\Core\Parser\Interceptor\Escape::class));
        }
        return $parserConfiguration;
    }

    protected function startRendering($type, \TYPO3\CMS\Fluid\Core\Parser\ParsedTemplateInterface $parsedTemplate, \TYPO3\CMS\Fluid\Core\Rendering\RenderingContextInterface $renderingContext)
    {
        array_push($this->renderingStack, ['type' => $type, 'parsedTemplate' => $parsedTemplate, 'renderingContext' => $renderingContext]);
    }

    protected function stopRendering()
    {
        array_pop($this->renderingStack);
    }

    protected function getCurrentRenderingType()
    {
        $currentRendering = end($this->renderingStack);
        return $currentRendering['type'];
    }

    protected function getCurrentParsedTemplate()
    {
        $currentRendering = end($this->renderingStack);
        return $currentRendering['parsedTemplate'];
    }

    protected function getCurrentRenderingContext()
    {
        $currentRendering = end($this->renderingStack);
        return $currentRendering['renderingContext'];
    }

    public function canRender(\TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext $controllerContext)
    {
        return true;
    }
}