/** * Invoke the ViewHelper described by the ViewHelperNode, the properties * of which will already have been filled by the ViewHelperResolver. * * @param string|ViewHelperInterface $viewHelperClassName * @param array $arguments * @param RenderingContextInterface $renderingContext * @param \Closure $renderChildrenClosure * @return mixed */ public function invoke($viewHelperClassNameOrInstance, array $arguments, RenderingContextInterface $renderingContext, \Closure $renderChildrenClosure = NULL) { if ($viewHelperClassNameOrInstance instanceof ViewHelperInterface) { $viewHelper = $viewHelperClassNameOrInstance; } else { $viewHelper = $this->viewHelperResolver->createViewHelperInstanceFromClassName($viewHelperClassNameOrInstance); } $expectedViewHelperArguments = $renderingContext->getViewHelperResolver()->getArgumentDefinitionsForViewHelper($viewHelper); // Rendering process $evaluatedArguments = array(); foreach ($expectedViewHelperArguments as $argumentName => $argumentDefinition) { if (isset($arguments[$argumentName])) { /** @var NodeInterface|mixed $argumentValue */ $argumentValue = $arguments[$argumentName]; $evaluatedArguments[$argumentName] = $argumentValue instanceof NodeInterface ? $argumentValue->evaluate($renderingContext) : $argumentValue; } else { $evaluatedArguments[$argumentName] = $argumentDefinition->getDefaultValue(); } } $this->abortIfUnregisteredArgumentsExist($expectedViewHelperArguments, $evaluatedArguments); $this->abortIfRequiredArgumentsAreMissing($expectedViewHelperArguments, $evaluatedArguments); $viewHelper->setArguments($evaluatedArguments); $viewHelper->setRenderingContext($renderingContext); if ($renderChildrenClosure) { $viewHelper->setRenderChildrenClosure($renderChildrenClosure); } return $viewHelper->initializeArgumentsAndRender(); }
/** * Pre-process the template source before it is returned to the TemplateParser or passed to * the next TemplateProcessorInterface instance. * * Detects all tags that carry an `xmlns:` definition using a Fluid-compatible prefix and a * conventional namespace URL (http://typo3.org/ns/). Extracts the detected namespaces and * removes the detected tag. * * @param string $templateSource * @return string */ public function preProcessSource($templateSource) { $matches = array(); $namespacePattern = 'xmlns:([a-z0-9]+)="(http\\:\\/\\/typo3\\.org\\/ns\\/[^"]+)"'; $matched = preg_match('/<([a-z0-9]+)(?:[^>]*?)\\s+' . $namespacePattern . '[^>]*>/', $templateSource, $matches); if ($matched) { $namespaces = array(); preg_match_all('/' . $namespacePattern . '/', $matches[0], $namespaces, PREG_SET_ORDER); foreach ($namespaces as $set) { $namespaceUrl = $set[2]; $namespaceUri = substr($namespaceUrl, 20); $namespacePhp = str_replace('/', '\\', $namespaceUri); $this->renderingContext->getViewHelperResolver()->addNamespace($set[1], $namespacePhp); } if (strpos($matches[0], 'data-namespace-typo3-fluid="true"')) { $templateSource = str_replace($matches[0], '', $templateSource); $closingTagName = $matches[1]; $closingTag = '</' . $closingTagName . '>'; if (strpos($templateSource, $closingTag)) { $templateSource = substr($templateSource, 0, strrpos($templateSource, $closingTag)) . substr($templateSource, strrpos($templateSource, $closingTag) + strlen($closingTag)); } } else { if (!empty($namespaces)) { $namespaceAttributesToRemove = []; foreach ($namespaces as $namespace) { $namespaceAttributesToRemove[] = preg_quote($namespace[1], '/') . '="' . preg_quote($namespace[2], '/') . '"'; } $matchWithRemovedNamespaceAttributes = preg_replace('/(?:\\s*+xmlns:(?:' . implode('|', $namespaceAttributesToRemove) . ')\\s*+)++/', ' ', $matches[0]); $templateSource = str_replace($matches[0], $matchWithRemovedNamespaceAttributes, $templateSource); } } } return $templateSource; }
/** * Invoke the ViewHelper described by the ViewHelperNode, the properties * of which will already have been filled by the ViewHelperResolver. * * @param string|ViewHelperInterface $viewHelperClassNameOrInstance * @param array $arguments * @param RenderingContextInterface $renderingContext * @param null|\Closure $renderChildrenClosure * @return string */ public function invoke($viewHelperClassNameOrInstance, array $arguments, RenderingContextInterface $renderingContext, \Closure $renderChildrenClosure = null) { $viewHelperResolver = $renderingContext->getViewHelperResolver(); if ($viewHelperClassNameOrInstance instanceof ViewHelperInterface) { $viewHelper = $viewHelperClassNameOrInstance; } else { $viewHelper = $viewHelperResolver->createViewHelperInstanceFromClassName($viewHelperClassNameOrInstance); } $expectedViewHelperArguments = $viewHelperResolver->getArgumentDefinitionsForViewHelper($viewHelper); // Rendering process $evaluatedArguments = []; $undeclaredArguments = []; foreach ($expectedViewHelperArguments as $argumentName => $argumentDefinition) { if (isset($arguments[$argumentName])) { /** @var NodeInterface|mixed $argumentValue */ $argumentValue = $arguments[$argumentName]; $evaluatedArguments[$argumentName] = $argumentValue instanceof NodeInterface ? $argumentValue->evaluate($renderingContext) : $argumentValue; } else { $evaluatedArguments[$argumentName] = $argumentDefinition->getDefaultValue(); } } foreach ($arguments as $argumentName => $argumentValue) { if (!array_key_exists($argumentName, $evaluatedArguments)) { $undeclaredArguments[$argumentName] = $argumentValue instanceof NodeInterface ? $argumentValue->evaluate($renderingContext) : $argumentValue; } } if ($renderChildrenClosure) { $viewHelper->setRenderChildrenClosure($renderChildrenClosure); } $viewHelper->setRenderingContext($renderingContext); $viewHelper->setArguments($evaluatedArguments); $viewHelper->handleAdditionalArguments($undeclaredArguments); return $viewHelper->initializeArgumentsAndRender(); }
/** * @param RenderingContextInterface $renderingContext * @return void */ public function setRenderingContext(RenderingContextInterface $renderingContext) { $this->renderingContext = $renderingContext; $this->templateVariableContainer = $renderingContext->getVariableProvider(); $this->viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer(); if ($renderingContext instanceof FlowAwareRenderingContextInterface) { $this->controllerContext = $renderingContext->getControllerContext(); } }
/** * Evaluate this node and return the correct object. * * Handles each part (denoted by .) in $this->objectPath in the following order: * - call appropriate getter * - call public property, if exists * - fail * * The first part of the object path has to be a variable in the * VariableProvider. * * @param RenderingContextInterface $renderingContext * @return mixed The evaluated object, can be any object type. */ public function evaluate(RenderingContextInterface $renderingContext) { $objectPath = strtolower($this->objectPath); $variableProvider = $renderingContext->getVariableProvider(); if ($objectPath === '_all') { return $variableProvider->getAll(); } return VariableExtractor::extract($variableProvider, $this->objectPath, $this->accessors); }
/** * @param mixed $candidate * @param RenderingContextInterface $renderingContext * @return mixed */ protected static function getTemplateVariableOrValueItself($candidate, RenderingContextInterface $renderingContext) { $variables = $renderingContext->getVariableProvider()->getAll(); $extractor = new VariableExtractor(); $suspect = $extractor->getByPath($variables, $candidate); if (NULL === $suspect) { return $candidate; } return $suspect; }
/** * Constructor. * * @param RenderingContextInterface $renderingContext a RenderingContext, provided by invoker * @param string $namespace the namespace identifier of the ViewHelper. * @param string $identifier the name of the ViewHelper to render, inside the namespace provided. * @param NodeInterface[] $arguments Arguments of view helper - each value is a RootNode. * @param ParsingState $state */ public function __construct(RenderingContextInterface $renderingContext, $namespace, $identifier, array $arguments, ParsingState $state) { $resolver = $renderingContext->getViewHelperResolver(); $this->arguments = $arguments; $this->viewHelperClassName = $resolver->resolveViewHelperClassName($namespace, $identifier); $this->uninitializedViewHelper = $resolver->createViewHelperInstanceFromClassName($this->viewHelperClassName); $this->uninitializedViewHelper->setRenderingContext($renderingContext); $this->uninitializedViewHelper->setViewHelperNode($this); $this->argumentDefinitions = $resolver->getArgumentDefinitionsForViewHelper($this->uninitializedViewHelper); $this->rewriteBooleanNodesInArgumentsObjectTree($this->argumentDefinitions, $this->arguments); $this->validateArguments($this->argumentDefinitions, $this->arguments); }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return string */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $table = $arguments['table']; $field = $arguments['field']; $wrap = $arguments['wrap']; if ($table === null) { $currentRequest = $renderingContext->getControllerContext()->getRequest(); $moduleName = $currentRequest->getPluginName(); $table = '_MOD_' . $moduleName; } return '<div class="docheader-csh">' . BackendUtility::cshItem($table, $field, '', $wrap) . '</div>'; }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return mixed */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $templateVariableContainer = $renderingContext->getVariableProvider(); $map = $arguments['map']; foreach ($map as $aliasName => $value) { $templateVariableContainer->add($aliasName, $value); } $output = $renderChildrenClosure(); foreach ($map as $aliasName => $value) { $templateVariableContainer->remove($aliasName); } return $output; }
/** * Constructor. * * @param RenderingContextInterface $renderingContext a RenderingContext, provided by invoker * @param string $namespace the namespace identifier of the ViewHelper. * @param string $identifier the name of the ViewHelper to render, inside the namespace provided. * @param NodeInterface[] $arguments Arguments of view helper - each value is a RootNode. * @param ParsingState $state */ public function __construct(RenderingContextInterface $renderingContext, $namespace, $identifier, array $arguments, ParsingState $state) { $resolver = $renderingContext->getViewHelperResolver(); $this->arguments = $arguments; $this->viewHelperClassName = $resolver->resolveViewHelperClassName($namespace, $identifier); $this->uninitializedViewHelper = $resolver->createViewHelperInstanceFromClassName($this->viewHelperClassName); $this->uninitializedViewHelper->setViewHelperNode($this); // Note: RenderingContext required here though replaced later. See https://github.com/TYPO3Fluid/Fluid/pull/93 $this->uninitializedViewHelper->setRenderingContext($renderingContext); $this->argumentDefinitions = $resolver->getArgumentDefinitionsForViewHelper($this->uninitializedViewHelper); $this->rewriteBooleanNodesInArgumentsObjectTree($this->argumentDefinitions, $this->arguments); $this->validateArguments($this->argumentDefinitions, $this->arguments); }
/** * @param null $arguments * @param RenderingContextInterface $renderingContext * @return bool */ protected static function evaluateCondition($arguments = null, RenderingContextInterface $renderingContext) { $objectManager = $renderingContext->getObjectManager(); /** @var Context $securityContext */ $securityContext = $objectManager->get(Context::class); $activeTokens = $securityContext->getAuthenticationTokens(); $isAuthenticated = false; foreach ($activeTokens as $token) { if ($token->isAuthenticated()) { $isAuthenticated = true; } } return $isAuthenticated; }
/** * Sets up this test case * * @return void */ protected function setUp() { $this->singletonInstances = GeneralUtility::getSingletonInstances(); $this->view = $this->getAccessibleMock(\TYPO3\CMS\Fluid\View\StandaloneView::class, array('testFileExistence', 'buildParserConfiguration', 'getOrParseAndStoreTemplate'), array(), '', false); $this->mockConfigurationManager = $this->getMock(ConfigurationManagerInterface::class); $this->mockObjectManager = $this->getMock(\TYPO3\CMS\Extbase\Object\ObjectManager::class); $this->mockObjectManager->expects($this->any())->method('get')->will($this->returnCallback(array($this, 'objectManagerCallback'))); $this->mockRequest = $this->getMock(Request::class); $this->mockUriBuilder = $this->getMock(UriBuilder::class); $this->mockContentObject = $this->getMock(\TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::class); $this->mockControllerContext = $this->getMock(ControllerContext::class); $this->mockControllerContext->expects($this->any())->method('getRequest')->will($this->returnValue($this->mockRequest)); $this->mockTemplatePaths = $this->getMock(TemplatePaths::class); $this->mockViewHelperVariableContainer = $this->getMock(ViewHelperVariableContainer::class); $this->mockRenderingContext = $this->getMock(\TYPO3\CMS\Fluid\Tests\Unit\Core\Rendering\RenderingContextFixture::class); $this->mockRenderingContext->expects($this->any())->method('getControllerContext')->will($this->returnValue($this->mockControllerContext)); $this->mockRenderingContext->expects($this->any())->method('getViewHelperVariableContainer')->will($this->returnValue($this->mockViewHelperVariableContainer)); $this->mockRenderingContext->expects($this->any())->method('getVariableProvider')->willReturn($this->mockVariableProvider); $this->mockRenderingContext->expects($this->any())->method('getTemplatePaths')->willReturn($this->mockTemplatePaths); $this->view->_set('objectManager', $this->mockObjectManager); $this->view->_set('baseRenderingContext', $this->mockRenderingContext); $this->view->_set('controllerContext', $this->mockControllerContext); $this->view->expects($this->any())->method('getOrParseAndStoreTemplate')->willReturn($this->mockParsedTemplate); GeneralUtility::setSingletonInstance(\TYPO3\CMS\Extbase\Object\ObjectManager::class, $this->mockObjectManager); GeneralUtility::addInstance(\TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::class, $this->mockContentObject); $this->mockCacheManager = $this->getMock(\TYPO3\CMS\Core\Cache\CacheManager::class, array(), array(), '', false); $mockCache = $this->getMock(\TYPO3Fluid\Fluid\Core\Cache\FluidCacheInterface::class, array(), array(), '', false); $this->mockCacheManager->expects($this->any())->method('getCache')->will($this->returnValue($mockCache)); GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $this->mockCacheManager); }
/** * Pre-process the template source before it is * returned to the TemplateParser or passed to * the next TemplateProcessorInterface instance. * * @param string $templateSource * @return string */ public function preProcessSource($templateSource) { $matches = []; preg_match_all(self::$SCAN_PATTERN_ESCAPINGMODIFIER, $templateSource, $matches, PREG_SET_ORDER); if ($matches === []) { return $templateSource; } if (count($matches) > 1) { throw new Exception('There is more than one escaping modifier defined. There can only be one {escapingEnabled=...} per template.', 1407331080); } if (strtolower($matches[0]['enabled']) === 'false') { $this->renderingContext->getTemplateParser()->setEscapingEnabled(false); } $templateSource = preg_replace(self::$SCAN_PATTERN_ESCAPINGMODIFIER, '', $templateSource); return $templateSource; }
/** * Loads the template source and render the template. * If "layoutName" is set in a PostParseFacet callback, it will render the file with the given layout. * * @param string $actionName If set, this action's template will be rendered instead of the one defined in the context. * @return string Rendered Template * @api */ public function render($actionName = NULL) { $this->templateParser->setConfiguration($this->buildParserConfiguration()); $this->templateParser->setVariableProvider($this->baseRenderingContext->getVariableProvider()); $this->templateParser->setViewHelperResolver($this->viewHelperResolver); $this->baseRenderingContext->setViewHelperResolver($this->viewHelperResolver); $controllerName = $this->baseRenderingContext->getControllerName(); if (!$actionName) { $actionName = $this->baseRenderingContext->getControllerAction(); } $actionName = ucfirst($actionName); if (empty($templateIdentifier)) { $templateIdentifier = $this->templatePaths->getTemplateIdentifier($controllerName, $actionName); } $parsedTemplate = $this->getOrParseAndStoreTemplate($templateIdentifier, function ($parent, TemplatePaths $paths) use($controllerName, $actionName) { return $paths->getTemplateSource($controllerName, $actionName); }); $parsedTemplate->addCompiledNamespaces($this->baseRenderingContext); if (!$parsedTemplate->hasLayout()) { $this->startRendering(self::RENDERING_TEMPLATE, $parsedTemplate, $this->baseRenderingContext); $output = $parsedTemplate->render($this->baseRenderingContext); $this->stopRendering(); } else { $layoutName = $parsedTemplate->getLayoutName($this->baseRenderingContext); $layoutIdentifier = $this->templatePaths->getLayoutIdentifier($layoutName); $parsedLayout = $this->getOrParseAndStoreTemplate($layoutIdentifier, function ($parent, TemplatePaths $paths) use($layoutName) { return $paths->getLayoutSource($layoutName); }); $this->startRendering(self::RENDERING_LAYOUT, $parsedTemplate, $this->baseRenderingContext); $output = $parsedLayout->render($this->baseRenderingContext); $this->stopRendering(); } return $output; }
/** * Throw an UnknownNamespaceException for any unknown and not ignored * namespace inside the template string * * @param string $templateSource * @return void */ public function throwExceptionsForUnhandledNamespaces($templateSource) { $viewHelperResolver = $this->renderingContext->getViewHelperResolver(); $splitTemplate = preg_split(Patterns::$SPLIT_PATTERN_TEMPLATE_DYNAMICTAGS, $templateSource, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY); foreach ($splitTemplate as $templateElement) { if (preg_match(Patterns::$SCAN_PATTERN_TEMPLATE_VIEWHELPERTAG, $templateElement, $matchedVariables) > 0) { if (!$viewHelperResolver->isNamespaceValidOrIgnored($matchedVariables['NamespaceIdentifier'])) { throw new UnknownNamespaceException('Unkown Namespace: ' . htmlspecialchars($matchedVariables[0])); } continue; } elseif (preg_match(Patterns::$SCAN_PATTERN_TEMPLATE_CLOSINGVIEWHELPERTAG, $templateElement, $matchedVariables) > 0) { continue; } $sections = preg_split(Patterns::$SPLIT_PATTERN_SHORTHANDSYNTAX, $templateElement, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY); foreach ($sections as $section) { if (preg_match(Patterns::$SCAN_PATTERN_SHORTHANDSYNTAX_OBJECTACCESSORS, $section, $matchedVariables) > 0) { preg_match_all(Patterns::$SPLIT_PATTERN_SHORTHANDSYNTAX_VIEWHELPER, $section, $shorthandViewHelpers, PREG_SET_ORDER); if (is_array($shorthandViewHelpers) === true) { foreach ($shorthandViewHelpers as $shorthandViewHelper) { if (!$viewHelperResolver->isNamespaceValidOrIgnored($shorthandViewHelper['NamespaceIdentifier'])) { throw new UnknownNamespaceException('Unkown Namespace: ' . $shorthandViewHelper['NamespaceIdentifier']); } } } } } } }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return string */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $pageUid = $arguments['pageUid']; $additionalParams = $arguments['additionalParams']; $pageType = $arguments['pageType']; $noCache = $arguments['noCache']; $noCacheHash = $arguments['noCacheHash']; $section = $arguments['section']; $linkAccessRestrictedPages = $arguments['linkAccessRestrictedPages']; $absolute = $arguments['absolute']; $addQueryString = $arguments['addQueryString']; $argumentsToBeExcludedFromQueryString = $arguments['argumentsToBeExcludedFromQueryString']; $addQueryStringMethod = $arguments['addQueryStringMethod']; $uriBuilder = $renderingContext->getControllerContext()->getUriBuilder(); $uri = $uriBuilder->setTargetPageUid($pageUid)->setTargetPageType($pageType)->setNoCache($noCache)->setUseCacheHash(!$noCacheHash)->setSection($section)->setLinkAccessRestrictedPages($linkAccessRestrictedPages)->setArguments($additionalParams)->setCreateAbsoluteUri($absolute)->setAddQueryString($addQueryString)->setArgumentsToBeExcludedFromQueryString($argumentsToBeExcludedFromQueryString)->setAddQueryStringMethod($addQueryStringMethod)->build(); return $uri; }
/** * Return array element by key. * * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return string * @api */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $element = $arguments['element']; $formRuntime = $arguments['formRuntime']; $property = null; if (!empty($arguments['property'])) { $property = $arguments['property']; } elseif (!empty($arguments['renderingOptionProperty'])) { $property = $arguments['renderingOptionProperty']; } if ($formRuntime === null) { /** @var RendererInterface $fluidFormRenderer */ $fluidFormRenderer = $renderingContext->getViewHelperVariableContainer()->getView(); $formRuntime = $fluidFormRenderer->getFormRuntime(); } return TranslationService::getInstance()->translateFormElementValue($element, $property, $formRuntime); }
/** * @param \TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface $renderingContext * @return void */ public function setRenderingContext(\TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface $renderingContext) { $this->renderingContext = $renderingContext; $this->templateVariableContainer = $renderingContext->getVariableProvider(); $this->viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer(); if ($renderingContext instanceof \TYPO3\CMS\Fluid\Core\Rendering\RenderingContext) { $this->controllerContext = $renderingContext->getControllerContext(); } }
/** * Evaluate this node and return the correct object. * * Handles each part (denoted by .) in $this->objectPath in the following order: * - call appropriate getter * - call public property, if exists * - fail * * The first part of the object path has to be a variable in the * VariableProvider. * * @param RenderingContextInterface $renderingContext * @return object The evaluated object, can be any object type. */ public function evaluate(RenderingContextInterface $renderingContext) { $variableProvider = $renderingContext->getVariableProvider(); switch (strtolower($this->objectPath)) { case '_all': return $variableProvider->getAll(); case 'true': case 'on': case 'yes': return TRUE; case 'false': case 'off': case 'no': return FALSE; default: return VariableExtractor::extract($variableProvider, $this->objectPath, $this->accessors); } }
/** * Render the URI to the resource. The filename is used from child content. * * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return string The URI to the resource */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $path = $arguments['path']; $extensionName = $arguments['extensionName']; $absolute = $arguments['absolute']; if ($extensionName === null) { $extensionName = $renderingContext->getControllerContext()->getRequest()->getControllerExtensionName(); } $uri = 'EXT:' . GeneralUtility::camelCaseToLowerCaseUnderscored($extensionName) . '/Resources/Public/' . $path; $uri = GeneralUtility::getFileAbsFileName($uri); $uri = \TYPO3\CMS\Core\Utility\PathUtility::stripPathSitePrefix($uri); if (TYPO3_MODE === 'BE' && $absolute === false && $uri !== false) { $uri = '../' . $uri; } if ($absolute === true) { $uri = $renderingContext->getControllerContext()->getRequest()->getBaseUri() . $uri; } return $uri; }
/** * @return ParsingState */ protected function getParsingState() { $rootNode = new RootNode(); $variableProvider = $this->renderingContext->getVariableProvider(); $state = new ParsingState(); $state->setRootNode($rootNode); $state->pushNodeToStack($rootNode); $state->setVariableProvider($variableProvider->getScopeCopy($variableProvider->getAll())); return $state; }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * * @return mixed|string * @throws Exception */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $value = $arguments['value']; $default = $arguments['default']; $viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer(); if ($default !== false) { GeneralUtility::deprecationLog('Argument "default" on f:case is deprecated - use f:defaultCase instead'); } if ($value === null && $default === false) { throw new Exception('The case View helper must have either value or default argument', 1382867521); } $expression = $viewHelperVariableContainer->get(OriginalSwitchViewHelper::class, 'switchExpression'); // non-type-safe comparison by intention if ($default === true || $expression == $value) { $viewHelperVariableContainer->addOrUpdate(OriginalSwitchViewHelper::class, 'break', true); return $renderChildrenClosure(); } return ''; }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * * @return string */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $uid = $arguments['uid']; if (isset(static::$workspaceTitleRuntimeCache[$uid])) { return htmlspecialchars(static::$workspaceTitleRuntimeCache[$uid]); } if ($uid === 0) { static::$workspaceTitleRuntimeCache[$uid] = \TYPO3\CMS\Extbase\Utility\LocalizationUtility::translate('live', $renderingContext->getControllerContext()->getRequest()->getControllerExtensionName()); } elseif (!\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::isLoaded('workspaces')) { static::$workspaceTitleRuntimeCache[$uid] = ''; } else { $objectManager = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(\TYPO3\CMS\Extbase\Object\ObjectManager::class); $workspaceRepository = $objectManager->get(\TYPO3\CMS\Belog\Domain\Repository\WorkspaceRepository::class); /** @var $workspace \TYPO3\CMS\Belog\Domain\Model\Workspace */ $workspace = $workspaceRepository->findByUid($uid); // $workspace may be null, force empty string in this case static::$workspaceTitleRuntimeCache[$uid] = $workspace === null ? '' : $workspace->getTitle(); } return htmlspecialchars(static::$workspaceTitleRuntimeCache[$uid]); }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return string */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $getVars = $arguments['getVars']; $setVars = $arguments['setVars']; $mayMakeShortcut = $GLOBALS['BE_USER']->mayMakeShortcut(); if ($mayMakeShortcut) { $doc = GeneralUtility::makeInstance(DocumentTemplate::class); $currentRequest = $renderingContext->getControllerContext()->getRequest(); $extensionName = $currentRequest->getControllerExtensionName(); $moduleName = $currentRequest->getPluginName(); if (count($getVars) === 0) { $modulePrefix = strtolower('tx_' . $extensionName . '_' . $moduleName); $getVars = array('id', 'M', $modulePrefix); } $getList = implode(',', $getVars); $setList = implode(',', $setVars); return $doc->makeShortcutIcon($getList, $setList, $moduleName); } return ''; }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * @return mixed */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { $values = $arguments['values']; $as = $arguments['as']; if ($values === null) { return $renderChildrenClosure(); } $values = static::initializeValues($values); $index = static::initializeIndex($as, $renderingContext->getViewHelperVariableContainer()); $currentValue = isset($values[$index]) ? $values[$index] : null; $renderingContext->getVariableProvider()->add($as, $currentValue); $output = $renderChildrenClosure(); $renderingContext->getVariableProvider()->remove($as); $index++; if (!isset($values[$index])) { $index = 0; } $renderingContext->getViewHelperVariableContainer()->addOrUpdate(static::class, $as, $index); return $output; }
/** * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * * @return string */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { /** @var \TYPO3\CMS\Extbase\Object\ObjectManager $objectManager */ $objectManager = GeneralUtility::makeInstance(ObjectManager::class); /** @var \TYPO3\CMS\Belog\Domain\Repository\HistoryEntryRepository $historyEntryRepository */ $historyEntryRepository = $objectManager->get(HistoryEntryRepository::class); /** @var \TYPO3\CMS\Belog\Domain\Model\HistoryEntry $historyEntry */ $historyEntry = $historyEntryRepository->findOneBySysLogUid($arguments['uid']); /** @var \TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext $controllerContext */ $controllerContext = $renderingContext->getControllerContext(); /** @var IconFactory $iconFactory */ $iconFactory = GeneralUtility::makeInstance(IconFactory::class); if (!$historyEntry instanceof HistoryEntry) { return ''; } $historyLabel = LocalizationUtility::translate('changesInFields', $controllerContext->getRequest()->getControllerExtensionName(), array($historyEntry->getFieldlist())); $titleLable = LocalizationUtility::translate('showHistory', $controllerContext->getRequest()->getControllerExtensionName()); $historyIcon = $iconFactory->getIcon('actions-document-history-open', Icon::SIZE_SMALL)->render(); $historyHref = BackendUtility::getModuleUrl('record_history', array('sh_uid' => $historyEntry->getUid(), 'returnUrl' => GeneralUtility::getIndpEnv('REQUEST_URI'))); $historyLink = '<a href="' . htmlspecialchars($historyHref) . '" title="' . htmlspecialchars($titleLable) . '">' . $historyIcon . '</a>'; return $historyLabel . ' ' . $historyLink; }
/** * Resolve workspace title from UID. * * @param array $arguments * @param \Closure $renderChildrenClosure * @param RenderingContextInterface $renderingContext * * @return string workspace title or UID * @throws \InvalidArgumentException */ public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext) { if (!$renderingContext instanceof RenderingContext) { throw new \InvalidArgumentException('The given rendering context is not of type "TYPO3\\CMS\\Fluid\\Core\\Rendering\\RenderingContext"', 1468363946); } $uid = $arguments['uid']; if (isset(static::$workspaceTitleRuntimeCache[$uid])) { return static::$workspaceTitleRuntimeCache[$uid]; } if ($uid === 0) { static::$workspaceTitleRuntimeCache[$uid] = LocalizationUtility::translate('live', $renderingContext->getControllerContext()->getRequest()->getControllerExtensionName()); } elseif (!ExtensionManagementUtility::isLoaded('workspaces')) { static::$workspaceTitleRuntimeCache[$uid] = ''; } else { $objectManager = GeneralUtility::makeInstance(ObjectManager::class); $workspaceRepository = $objectManager->get(WorkspaceRepository::class); /** @var \TYPO3\CMS\Belog\Domain\Model\Workspace $workspace */ $workspace = $workspaceRepository->findByUid($uid); // $workspace may be null, force empty string in this case static::$workspaceTitleRuntimeCache[$uid] = $workspace === null ? '' : $workspace->getTitle(); } return static::$workspaceTitleRuntimeCache[$uid]; }
/** * @param RenderingContextInterface $renderingContext * @param string $expression * @param array $matches * @return integer|float */ public static function evaluateExpression(RenderingContextInterface $renderingContext, $expression, array $matches) { // Split the expression on all recognized operators $matches = array(); preg_match_all('/([+\\-*\\^\\/\\%]|[a-z0-9\\.]+)/s', $expression, $matches); $matches[0] = array_map('trim', $matches[0]); // Like the BooleanNode, we dumb down the processing logic to not apply // any special precedence on the priority of operators. We simply process // them in order. $variables = $renderingContext->getVariableProvider()->getAll(); $result = array_shift($matches[0]); $result = parent::getTemplateVariableOrValueItself($result, $renderingContext); $operator = NULL; $operators = array('*', '^', '-', '+', '/', '%'); foreach ($matches[0] as $part) { if (in_array($part, $operators)) { $operator = $part; } else { $part = parent::getTemplateVariableOrValueItself($part, $renderingContext); $result = self::evaluateOperation($result, $operator, $part); } } return $result; }
/** * Renders a partial. * * @param string $partialName * @param string $sectionName * @param array $variables * @param boolean $ignoreUnknown Ignore an unknown section and just return an empty string * @return string */ public function renderPartial($partialName, $sectionName, array $variables, $ignoreUnknown = FALSE) { if (!isset($this->partialIdentifierCache[$partialName])) { $this->partialIdentifierCache[$partialName] = $this->baseRenderingContext->getTemplatePaths()->getPartialIdentifier($partialName); } $partialIdentifier = $this->partialIdentifierCache[$partialName]; $parsedPartial = $this->baseRenderingContext->getTemplateParser()->getOrParseAndStoreTemplate($partialIdentifier, function ($parent, TemplatePaths $paths) use($partialName) { return $paths->getPartialSource($partialName); }); $renderingContext = clone $this->getCurrentRenderingContext(); $renderingContext->setVariableProvider($renderingContext->getVariableProvider()->getScopeCopy($variables)); $this->startRendering(self::RENDERING_PARTIAL, $parsedPartial, $renderingContext); if ($sectionName !== NULL) { $output = $this->renderSection($sectionName, $variables, $ignoreUnknown); } else { $output = $parsedPartial->render($renderingContext); } $this->stopRendering(); return $output; }
/** * @param string $identifier * @param ParsingState $parsingState * @return void */ public function store($identifier, ParsingState $parsingState) { if ($this->isDisabled()) { if ($this->renderingContext->isCacheEnabled()) { // Compiler is disabled but cache is enabled. Flush cache to make sure. $this->renderingContext->getCache()->flush($identifier); } $parsingState->setCompilable(FALSE); return; } $identifier = $this->sanitizeIdentifier($identifier); $this->nodeConverter->setVariableCounter(0); $generatedRenderFunctions = $this->generateSectionCodeFromParsingState($parsingState); $generatedRenderFunctions .= $this->generateCodeForSection($this->nodeConverter->convertListOfSubNodes($parsingState->getRootNode()), 'render', 'Main Render function'); $classDefinition = 'class ' . $identifier . ' extends \\TYPO3Fluid\\Fluid\\Core\\Compiler\\AbstractCompiledTemplate'; $templateCode = <<<EOD <?php %s { public function getLayoutName(\\TYPO3Fluid\\Fluid\\Core\\Rendering\\RenderingContextInterface \$renderingContext) { \$layout = %s; if (!\$layout) { \$layout = '%s'; } return \$layout; } public function hasLayout() { return %s; } public function addCompiledNamespaces(\\TYPO3Fluid\\Fluid\\Core\\Rendering\\RenderingContextInterface \$renderingContext) { \$renderingContext->getViewHelperResolver()->addNamespaces(%s); } %s } EOD; $templateCode = sprintf($templateCode, $classDefinition, '$renderingContext->getVariableProvider()->get(\'layoutName\')', $parsingState->getVariableContainer()->get('layoutName'), $parsingState->hasLayout() ? 'TRUE' : 'FALSE', var_export($this->renderingContext->getViewHelperResolver()->getNamespaces(), TRUE), $generatedRenderFunctions); $this->renderingContext->getCache()->set($identifier, $templateCode); }