fluid/Classes/View/StandaloneView.php

Go to the documentation of this file.

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

use TYPO3\CMS\Core\Cache\CacheManager;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext;
use TYPO3\CMS\Extbase\Mvc\Web\Request as WebRequest;
use TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Utility\ArrayUtility;
use TYPO3\CMS\Fluid\Core\Compiler\TemplateCompiler;
use TYPO3\CMS\Fluid\Core\Parser\TemplateParser;
use TYPO3\CMS\Fluid\Core\Rendering\RenderingContext;
use TYPO3\CMS\Fluid\View\Exception\InvalidTemplateResourceException;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;

class StandaloneView extends AbstractTemplateView
{
    protected $templateSource = null;

    protected $templatePathAndFilename = null;

    protected $templateRootPaths = null;

    protected $partialRootPaths = null;

    protected $layoutRootPaths = null;

    public function __construct(ContentObjectRenderer $contentObject = null)
    {
        $this->objectManager = GeneralUtility::makeInstance(ObjectManager::class);
        $configurationManager = $this->objectManager->get(ConfigurationManagerInterface::class);
        if ($contentObject === null) {
            $contentObject = GeneralUtility::makeInstance(ContentObjectRenderer::class);
        }
        $configurationManager->setContentObject($contentObject);
        $this->templateParser = $this->objectManager->get(TemplateParser::class);
        $this->setRenderingContext($this->objectManager->get(RenderingContext::class));
        $request = $this->objectManager->get(WebRequest::class);
        $request->setRequestURI(GeneralUtility::getIndpEnv('TYPO3_REQUEST_URL'));
        $request->setBaseURI(GeneralUtility::getIndpEnv('TYPO3_SITE_URL'));
        $uriBuilder = $this->objectManager->get(UriBuilder::class);
        $uriBuilder->setRequest($request);
        $controllerContext = $this->objectManager->get(ControllerContext::class);
        $controllerContext->setRequest($request);
        $controllerContext->setUriBuilder($uriBuilder);
        $this->setControllerContext($controllerContext);
        $this->templateCompiler = $this->objectManager->get(TemplateCompiler::class);
        // singleton
        $this->templateCompiler->setTemplateCache(GeneralUtility::makeInstance(CacheManager::class)->getCache('fluid_template'));
    }

    public function setFormat($format)
    {
        $this->getRequest()->setFormat($format);
    }

    public function getFormat()
    {
        return $this->getRequest()->getFormat();
    }

    public function getRequest()
    {
        return $this->controllerContext->getRequest();
    }

    public function setTemplatePathAndFilename($templatePathAndFilename)
    {
        $this->templatePathAndFilename = $templatePathAndFilename;
    }

    public function getTemplatePathAndFilename()
    {
        return $this->templatePathAndFilename;
    }

    public function setTemplateSource($templateSource)
    {
        $this->templateSource = $templateSource;
    }

    public function setTemplateRootPaths(array $templateRootPaths)
    {
        $this->templateRootPaths = $templateRootPaths;
    }

    public function setTemplate($templateName)
    {
        if ($this->templateRootPaths === null) {
            throw new InvalidTemplateResourceException('No template root path has been specified. Use setTemplateRootPaths().', 1430635895);
        }
        $format = $this->getRequest()->getFormat();
        $templatePathAndFilename = null;
        $possibleTemplatePaths = $this->buildListOfTemplateCandidates($templateName, $this->templateRootPaths, $format);
        foreach ($possibleTemplatePaths as $possibleTemplatePath) {
            if ($this->testFileExistence($possibleTemplatePath)) {
                $templatePathAndFilename = $possibleTemplatePath;
                break;
            }
        }
        if ($templatePathAndFilename !== null) {
            $this->setTemplatePathAndFilename($templatePathAndFilename);
        } else {
            throw new InvalidTemplateResourceException('Could not load template file. Tried following paths: "' . implode('", "', $possibleTemplatePaths) . '".', 1430635896);
        }
    }

    public function setLayoutRootPath($layoutRootPath)
    {
        GeneralUtility::logDeprecatedFunction();
        $this->setLayoutRootPaths(array($layoutRootPath));
    }

    public function setLayoutRootPaths(array $layoutRootPaths)
    {
        $this->layoutRootPaths = $layoutRootPaths;
    }

    public function getLayoutRootPath()
    {
        GeneralUtility::logDeprecatedFunction();
        $layoutRootPaths = $this->getLayoutRootPaths();
        return array_shift($layoutRootPaths);
    }

    public function getLayoutRootPaths()
    {
        if ($this->layoutRootPaths === null && $this->templatePathAndFilename === null) {
            throw new InvalidTemplateResourceException('No layout root path has been specified. Use setLayoutRootPaths().', 1288091419);
        }
        if ($this->layoutRootPaths === null) {
            $this->layoutRootPaths = array(dirname($this->templatePathAndFilename) . '/Layouts');
        }
        return $this->layoutRootPaths;
    }

    public function setPartialRootPath($partialRootPath)
    {
        GeneralUtility::logDeprecatedFunction();
        $this->setPartialRootPaths(array($partialRootPath));
    }

    public function getPartialRootPath()
    {
        GeneralUtility::logDeprecatedFunction();
        $partialRootPaths = $this->getPartialRootPaths();
        return array_shift($partialRootPaths);
    }

    public function setPartialRootPaths(array $partialRootPaths)
    {
        $this->partialRootPaths = $partialRootPaths;
    }

    public function getPartialRootPaths()
    {
        if ($this->partialRootPaths === null && $this->templatePathAndFilename === null) {
            throw new InvalidTemplateResourceException('No partial root path has been specified. Use setPartialRootPaths().', 1288094511);
        }
        if ($this->partialRootPaths === null) {
            $this->partialRootPaths = array(dirname($this->templatePathAndFilename) . '/Partials');
        }
        return $this->partialRootPaths;
    }

    public function hasTemplate()
    {
        try {
            $this->getTemplateSource();
            return true;
        } catch (InvalidTemplateResourceException $e) {
            return false;
        }
    }

    protected function getTemplateIdentifier($actionName = null)
    {
        if ($this->templateSource === null) {
            $templatePathAndFilename = $this->getTemplatePathAndFilename();
            $templatePathAndFilenameInfo = pathinfo($templatePathAndFilename);
            $templateFilenameWithoutExtension = basename($templatePathAndFilename, '.' . $templatePathAndFilenameInfo['extension']);
            $prefix = sprintf('template_file_%s', $templateFilenameWithoutExtension);
            return $this->createIdentifierForFile($templatePathAndFilename, $prefix);
        } else {
            $templateSource = $this->getTemplateSource();
            $prefix = 'template_source';
            $templateIdentifier = sprintf('Standalone_%s_%s', $prefix, sha1($templateSource));
            return $templateIdentifier;
        }
    }

    protected function getTemplateSource($actionName = null)
    {
        if ($this->templateSource === null && $this->templatePathAndFilename === null) {
            throw new InvalidTemplateResourceException('No template has been specified. Use either setTemplateSource() or setTemplatePathAndFilename().', 1288085266);
        }
        if ($this->templateSource === null) {
            if (!$this->testFileExistence($this->templatePathAndFilename)) {
                throw new InvalidTemplateResourceException('Template could not be found at "' . $this->templatePathAndFilename . '".', 1288087061);
            }
            $this->templateSource = file_get_contents($this->templatePathAndFilename);
        }
        return $this->templateSource;
    }

    protected function getLayoutIdentifier($layoutName = 'Default')
    {
        $layoutPathAndFilename = $this->getLayoutPathAndFilename($layoutName);
        $prefix = 'layout_' . $layoutName;
        return $this->createIdentifierForFile($layoutPathAndFilename, $prefix);
    }

    protected function getLayoutSource($layoutName = 'Default')
    {
        $layoutPathAndFilename = $this->getLayoutPathAndFilename($layoutName);
        $layoutSource = file_get_contents($layoutPathAndFilename);
        if ($layoutSource === false) {
            throw new InvalidTemplateResourceException('"' . $layoutPathAndFilename . '" is not a valid template resource URI.', 1312215888);
        }
        return $layoutSource;
    }

    protected function getLayoutPathAndFilename($layoutName = 'Default')
    {
        $possibleLayoutPaths = $this->buildListOfTemplateCandidates($layoutName, $this->getLayoutRootPaths(), $this->getRequest()->getFormat());
        foreach ($possibleLayoutPaths as $layoutPathAndFilename) {
            if ($this->testFileExistence($layoutPathAndFilename)) {
                return $layoutPathAndFilename;
            }
        }

        throw new InvalidTemplateResourceException('Could not load layout file. Tried following paths: "' . implode('", "', $possibleLayoutPaths) . '".', 1288092555);
    }

    protected function getPartialIdentifier($partialName)
    {
        $partialPathAndFilename = $this->getPartialPathAndFilename($partialName);
        $prefix = 'partial_' . $partialName;
        return $this->createIdentifierForFile($partialPathAndFilename, $prefix);
    }

    protected function getPartialSource($partialName)
    {
        $partialPathAndFilename = $this->getPartialPathAndFilename($partialName);
        $partialSource = file_get_contents($partialPathAndFilename);
        if ($partialSource === false) {
            throw new InvalidTemplateResourceException('"' . $partialPathAndFilename . '" is not a valid template resource URI.', 1257246932);
        }
        return $partialSource;
    }

    protected function getPartialPathAndFilename($partialName)
    {
        $possiblePartialPaths = $this->buildListOfTemplateCandidates($partialName, $this->getPartialRootPaths(), $this->getRequest()->getFormat());
        foreach ($possiblePartialPaths as $partialPathAndFilename) {
            if ($this->testFileExistence($partialPathAndFilename)) {
                return $partialPathAndFilename;
            }
        }
        throw new InvalidTemplateResourceException('Could not load partial file. Tried following paths: "' . implode('", "', $possiblePartialPaths) . '".', 1288092556);
    }

    protected function buildListOfTemplateCandidates($templateName, array $paths, $format)
    {
        $upperCasedTemplateName = $this->ucFileNameInPath($templateName);
        $possibleTemplatePaths = array();
        $paths = ArrayUtility::sortArrayWithIntegerKeys($paths);
        $paths = array_reverse($paths, true);
        foreach ($paths as $layoutRootPath) {
            $possibleTemplatePaths[] = $this->resolveFileNamePath($layoutRootPath . '/' . $upperCasedTemplateName . '.' . $format);
            $possibleTemplatePaths[] = $this->resolveFileNamePath($layoutRootPath . '/' . $upperCasedTemplateName);
            if ($upperCasedTemplateName !== $templateName) {
                $possibleTemplatePaths[] = $this->resolveFileNamePath($layoutRootPath . '/' . $templateName . '.' . $format);
                $possibleTemplatePaths[] = $this->resolveFileNamePath($layoutRootPath . '/' . $templateName);
            }
        }
        return $possibleTemplatePaths;
    }

    protected function createIdentifierForFile($pathAndFilename, $prefix)
    {
        $templateModifiedTimestamp = filemtime($pathAndFilename);
        $templateIdentifier = sprintf('Standalone_%s_%s', $prefix, sha1($pathAndFilename . '|' . $templateModifiedTimestamp));
        $templateIdentifier = str_replace('/', '_', str_replace('.', '_', $templateIdentifier));
        return $templateIdentifier;
    }

    protected function resolveFileNamePath($pathAndFilename)
    {
        return GeneralUtility::getFileAbsFileName(GeneralUtility::fixWindowsFilePath($pathAndFilename), false);
    }
}