30001290505

Committed 23 Jul 2026 10:57AM UTC coverage: 70.309% (-1.7%) from 72.022%

Build # 30001290505

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TER] 8.0.0

Coverage Stats

4819 of 6854 relevant lines covered (70.31%)

6.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

10.09

/Classes/ViewHelpers/Render/RequestViewHelper.php

<?php
namespace FluidTYPO3\Vhs\ViewHelpers\Render;

/*
 * This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use FluidTYPO3\Vhs\Proxy\DispatcherProxy;
use FluidTYPO3\Vhs\Utility\ContentObjectFetcher;
use FluidTYPO3\Vhs\Utility\RequestResolver;
use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\Mvc\ExtbaseRequestParameters;
use TYPO3\CMS\Extbase\Mvc\RequestInterface;
use TYPO3\CMS\Extbase\Mvc\ResponseInterface;
use TYPO3\CMS\Extbase\Mvc\Web\Request;
use TYPO3\CMS\Extbase\Mvc\Web\Response;
use TYPO3\CMS\Fluid\Core\Rendering\RenderingContext;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;

/**
 * ### Render: Request
 *
 * Renders a sub-request to the desired Extension, Plugin,
 * Controller and action with the desired arguments.
 *
 * Note: arguments must not be wrapped with the prefix used
 * in GET/POST parameters but must be provided as if the
 * arguments were sent directly to the Controller action.
 */
class RequestViewHelper extends AbstractRenderViewHelper
{
    /**
     * @var class-string
     */
    protected static string $requestType = Request::class;

    /**
     * @var class-string
     */
    protected static string $responseType = Response::class;

    public function initializeArguments(): void
    {
        parent::initializeArguments();
        $this->registerArgument('action', 'string', 'Controller action to call in request');
        $this->registerArgument('controller', 'string', 'Controller name to call in request');
        $this->registerArgument('extensionName', 'string', 'Extension name scope to use in request');
        $this->registerArgument(
            'vendorName',
            'string',
            'Vendor name scope to use in request. WARNING: only applies to TYPO3 versions below 10.4'
        );
        $this->registerArgument('pluginName', 'string', 'Plugin name scope to use in request');
        $this->registerArgument('arguments', 'array', 'Arguments to use in request');
    }

    /**
     * @return string|ResponseInterface
     */
    public static function renderStatic(
        array $arguments,
        \Closure $renderChildrenClosure,
        RenderingContextInterface $renderingContext
    ) {
        /** @var RenderingContext $renderingContext */
        /** @var string|null $action */
        $action = $arguments['action'];
        /** @var string|null $controller */
        $controller = $arguments['controller'];
        /** @var string|null $extensionName */
        $extensionName = $arguments['extensionName'];
        /** @var string|null $pluginName */
        $pluginName = $arguments['pluginName'];
        $requestArguments = is_array($arguments['arguments']) ? $arguments['arguments'] : [];
        $configurationManager = static::getConfigurationManager();
        $contentObjectBackup = ContentObjectFetcher::resolve($configurationManager);
        $configurationBackup = $configurationManager->getConfiguration(
            ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK
        );

        /** @var ContentObjectRenderer $temporaryContentObject */
        $temporaryContentObject = GeneralUtility::makeInstance(ContentObjectRenderer::class);
        try {
            $targetConfiguration = $configurationManager->getConfiguration(
                ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK,
                $extensionName,
                $pluginName
            );

            /** @var ResponseInterface|\TYPO3\CMS\Core\Http\Response $response */
            $response = GeneralUtility::makeInstance(
                class_exists(static::$responseType)
                    ? static::$responseType
                    : \TYPO3\CMS\Core\Http\Response::class
            );
            if (method_exists($configurationManager, 'setContentObject')) {
                $configurationManager->setContentObject($temporaryContentObject);
            }
            $configurationManager->setConfiguration($targetConfiguration);

            $request = self::loadDefaultValues(
                $renderingContext,
                $extensionName,
                $pluginName,
                $controller,
                $action,
                $requestArguments
            );

            /** @var ResponseInterface|null $possibleResponse */
            $possibleResponse = static::getDispatcher()->dispatch(
                $request instanceof RequestInterface ? $request : new \TYPO3\CMS\Extbase\Mvc\Request($request),
                $response instanceof Response ? $response : null
            );
            if ($possibleResponse) {
                $response = $possibleResponse;
            }
            if ($contentObjectBackup !== null && method_exists($configurationManager, 'setContentObject')) {
                $configurationManager->setContentObject($contentObjectBackup);
            }
            $configurationManager->setConfiguration($configurationBackup);
            if (method_exists($response, 'getBody')) {
                $response->getBody()->rewind();
                return $response->getBody()->getContents();
            }
            if (method_exists($response, 'getContent')) {
                return $response->getContent();
            }
            return '';
        } catch (\Exception $error) {
            if (!$arguments['graceful']) {
                throw $error;
            }
            /** @var string|null $onError */
            $onError = $arguments['onError'];
            if ($onError !== null) {
                return sprintf($onError, $error->getMessage(), $error->getCode());
            }
            return $error->getMessage() . ' (' . $error->getCode() . ')';
        }
    }

    protected static function getDispatcher(): DispatcherProxy
    {
        /** @var DispatcherProxy $dispatcher */
        $dispatcher = GeneralUtility::makeInstance(DispatcherProxy::class);
        return $dispatcher;
    }

    protected static function getConfigurationManager(): ConfigurationManagerInterface
    {
        /** @var ConfigurationManagerInterface $configurationManager */
        $configurationManager = GeneralUtility::makeInstance(ConfigurationManagerInterface::class);
        return $configurationManager;
    }

    /**
     * @return RequestInterface|ServerRequestInterface
     * @see \TYPO3\CMS\Extbase\Core\Bootstrap::initializeConfiguration
     */
    protected static function loadDefaultValues(
        RenderingContextInterface $renderingContext,
        ?string $extensionName,
        ?string $pluginName,
        ?string $controllerName,
        ?string $actionName,
        array $arguments
    ) {
        $configurationManager = static::getConfigurationManager();
        $configuration = $configurationManager->getConfiguration(
            ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK,
            $extensionName,
            $pluginName
        );
        /** @var string $defaultActionName */
        $defaultActionName = reset(reset($configuration['controllerConfiguration'])['actions']);

        $firstControllerName = null;
        $controllerAliasToClassMapping = [];
        $controllerClassToAliasMapping = [];
        foreach ($configuration['controllerConfiguration'] as $controllerClassName => $controllerConfiguration) {
            $firstControllerName = $firstControllerName ?? $controllerClassName;
            $controllerAliasToClassMapping[$controllerConfiguration['alias']] = $controllerConfiguration['className'];
            $controllerClassToAliasMapping[$controllerConfiguration['className']] = $controllerConfiguration['alias'];
        }

        if (class_exists(ExtbaseRequestParameters::class)) {
            /** @var ExtbaseRequestParameters $parameters */
            $parameters = GeneralUtility::makeInstance(ExtbaseRequestParameters::class);

            $parameters->setControllerAliasToClassNameMapping($controllerAliasToClassMapping);
            if ($pluginName !== null) {
                $parameters->setPluginName($pluginName);
            }
            if ($extensionName !== null) {
                $parameters->setControllerExtensionName($extensionName);
            }
            $parameters->setControllerName($controllerName ?? $controllerClassToAliasMapping[$firstControllerName]);
            $parameters->setControllerActionName($actionName ?? $defaultActionName);

            if (!empty($configuration['format'])) {
                $parameters->setFormat($configuration['format']);
            }

            foreach ($arguments as $argumentName => $argumentValue) {
                $parameters->setArgument($argumentName, $argumentValue);
            }

            return $GLOBALS['TYPO3_REQUEST']->withAttribute('extbase', $parameters);
        }

        $request = RequestResolver::resolveRequestFromRenderingContext($renderingContext);

        if (method_exists($request, 'setControllerAliasToClassNameMapping')) {
            $request->setControllerAliasToClassNameMapping($controllerAliasToClassMapping);
        }

        if ($pluginName !== null && method_exists($request, 'setPluginName')) {
            $request->setPluginName($pluginName);
        }

        if ($extensionName !== null && method_exists($request, 'setControllerExtensionName')) {
            $request->setControllerExtensionName($extensionName);
        }

        if (method_exists($request, 'setControllerName')) {
            $request->setControllerName($controllerName ?? $controllerClassToAliasMapping[$firstControllerName]);
        }

        if (method_exists($request, 'setControllerActionName')) {
            $request->setControllerActionName($actionName ?? $defaultActionName);
        }

        return $request;
    }
}

1	<?php
2	namespace FluidTYPO3\Vhs\ViewHelpers\Render;
3
4	/*
5	* This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
6	*
7	* For the full copyright and license information, please read the
8	* LICENSE.md file that was distributed with this source code.
9	*/
10
11	use FluidTYPO3\Vhs\Proxy\DispatcherProxy;
12	use FluidTYPO3\Vhs\Utility\ContentObjectFetcher;
13	use FluidTYPO3\Vhs\Utility\RequestResolver;
14	use Psr\Http\Message\ServerRequestInterface;
15	use TYPO3\CMS\Core\Utility\GeneralUtility;
16	use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
17	use TYPO3\CMS\Extbase\Mvc\ExtbaseRequestParameters;
18	use TYPO3\CMS\Extbase\Mvc\RequestInterface;
19	use TYPO3\CMS\Extbase\Mvc\ResponseInterface;
20	use TYPO3\CMS\Extbase\Mvc\Web\Request;
21	use TYPO3\CMS\Extbase\Mvc\Web\Response;
22	use TYPO3\CMS\Fluid\Core\Rendering\RenderingContext;
23	use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
24	use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;
25
26	/**
27	* ### Render: Request
28	*
29	* Renders a sub-request to the desired Extension, Plugin,
30	* Controller and action with the desired arguments.
31	*
32	* Note: arguments must not be wrapped with the prefix used
33	* in GET/POST parameters but must be provided as if the
34	* arguments were sent directly to the Controller action.
35	*/
36	class RequestViewHelper extends AbstractRenderViewHelper
37	{
38	/**
39	* @var class-string
40	*/
41	protected static string $requestType = Request::class;
42
43	/**
44	* @var class-string
45	*/
46	protected static string $responseType = Response::class;
47
48	public function initializeArguments(): void
49	{
50	parent::initializeArguments();	3✔
51	$this->registerArgument('action', 'string', 'Controller action to call in request');	3✔
52	$this->registerArgument('controller', 'string', 'Controller name to call in request');	3✔
53	$this->registerArgument('extensionName', 'string', 'Extension name scope to use in request');	3✔
54	$this->registerArgument(	3✔
55	'vendorName',	3✔
56	'string',	3✔
57	'Vendor name scope to use in request. WARNING: only applies to TYPO3 versions below 10.4'	3✔
58	);	3✔
59	$this->registerArgument('pluginName', 'string', 'Plugin name scope to use in request');	3✔
60	$this->registerArgument('arguments', 'array', 'Arguments to use in request');	3✔
61	}
62
63	/**
64	* @return string\|ResponseInterface
65	*/
66	public static function renderStatic(
67	array $arguments,
68	\Closure $renderChildrenClosure,
69	RenderingContextInterface $renderingContext
70	) {
71	/** @var RenderingContext $renderingContext */
72	/** @var string\|null $action */
73	$action = $arguments['action'];	×
74	/** @var string\|null $controller */
75	$controller = $arguments['controller'];	×
76	/** @var string\|null $extensionName */
77	$extensionName = $arguments['extensionName'];	×
78	/** @var string\|null $pluginName */
79	$pluginName = $arguments['pluginName'];	×
80	$requestArguments = is_array($arguments['arguments']) ? $arguments['arguments'] : [];	×
81	$configurationManager = static::getConfigurationManager();	×
82	$contentObjectBackup = ContentObjectFetcher::resolve($configurationManager);	×
83	$configurationBackup = $configurationManager->getConfiguration(	×
84	ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK	×
85	);	×
86
87	/** @var ContentObjectRenderer $temporaryContentObject */
88	$temporaryContentObject = GeneralUtility::makeInstance(ContentObjectRenderer::class);	×
89	try {
90	$targetConfiguration = $configurationManager->getConfiguration(	×
91	ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK,	×
92	$extensionName,	×
93	$pluginName	×
94	);	×
95
96	/** @var ResponseInterface\|\TYPO3\CMS\Core\Http\Response $response */
97	$response = GeneralUtility::makeInstance(	×
98	class_exists(static::$responseType)	×
99	? static::$responseType	×
100	: \TYPO3\CMS\Core\Http\Response::class	×
101	);	×
102	if (method_exists($configurationManager, 'setContentObject')) {	×
103	$configurationManager->setContentObject($temporaryContentObject);	×
104	}
105	$configurationManager->setConfiguration($targetConfiguration);	×
106
107	$request = self::loadDefaultValues(	×
108	$renderingContext,	×
109	$extensionName,	×
110	$pluginName,	×
111	$controller,	×
112	$action,	×
113	$requestArguments	×
114	);	×
115
116	/** @var ResponseInterface\|null $possibleResponse */
117	$possibleResponse = static::getDispatcher()->dispatch(	×
118	$request instanceof RequestInterface ? $request : new \TYPO3\CMS\Extbase\Mvc\Request($request),	×
119	$response instanceof Response ? $response : null	×
120	);	×
121	if ($possibleResponse) {	×
122	$response = $possibleResponse;	×
123	}
124	if ($contentObjectBackup !== null && method_exists($configurationManager, 'setContentObject')) {	×
125	$configurationManager->setContentObject($contentObjectBackup);	×
126	}
127	$configurationManager->setConfiguration($configurationBackup);	×
128	if (method_exists($response, 'getBody')) {	×
129	$response->getBody()->rewind();	×
130	return $response->getBody()->getContents();	×
131	}
132	if (method_exists($response, 'getContent')) {	×
133	return $response->getContent();	×
134	}
135	return '';	×
136	} catch (\Exception $error) {	×
137	if (!$arguments['graceful']) {	×
138	throw $error;	×
139	}
140	/** @var string\|null $onError */
141	$onError = $arguments['onError'];	×
142	if ($onError !== null) {	×
143	return sprintf($onError, $error->getMessage(), $error->getCode());	×
144	}
145	return $error->getMessage() . ' (' . $error->getCode() . ')';	×
146	}
147	}
148
149	protected static function getDispatcher(): DispatcherProxy
150	{
151	/** @var DispatcherProxy $dispatcher */
152	$dispatcher = GeneralUtility::makeInstance(DispatcherProxy::class);	×
153	return $dispatcher;	×
154	}
155
156	protected static function getConfigurationManager(): ConfigurationManagerInterface
157	{
158	/** @var ConfigurationManagerInterface $configurationManager */
159	$configurationManager = GeneralUtility::makeInstance(ConfigurationManagerInterface::class);	×
160	return $configurationManager;	×
161	}
162
163	/**
164	* @return RequestInterface\|ServerRequestInterface
165	* @see \TYPO3\CMS\Extbase\Core\Bootstrap::initializeConfiguration
166	*/
167	protected static function loadDefaultValues(
168	RenderingContextInterface $renderingContext,
169	?string $extensionName,
170	?string $pluginName,
171	?string $controllerName,
172	?string $actionName,
173	array $arguments
174	) {
175	$configurationManager = static::getConfigurationManager();	×
176	$configuration = $configurationManager->getConfiguration(	×
177	ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK,	×
178	$extensionName,	×
179	$pluginName	×
180	);	×
181	/** @var string $defaultActionName */
182	$defaultActionName = reset(reset($configuration['controllerConfiguration'])['actions']);	×
183
184	$firstControllerName = null;	×
185	$controllerAliasToClassMapping = [];	×
186	$controllerClassToAliasMapping = [];	×
187	foreach ($configuration['controllerConfiguration'] as $controllerClassName => $controllerConfiguration) {	×
188	$firstControllerName = $firstControllerName ?? $controllerClassName;	×
189	$controllerAliasToClassMapping[$controllerConfiguration['alias']] = $controllerConfiguration['className'];	×
190	$controllerClassToAliasMapping[$controllerConfiguration['className']] = $controllerConfiguration['alias'];	×
191	}
192
193	if (class_exists(ExtbaseRequestParameters::class)) {	×
194	/** @var ExtbaseRequestParameters $parameters */
195	$parameters = GeneralUtility::makeInstance(ExtbaseRequestParameters::class);	×
196
197	$parameters->setControllerAliasToClassNameMapping($controllerAliasToClassMapping);	×
198	if ($pluginName !== null) {	×
199	$parameters->setPluginName($pluginName);	×
200	}
201	if ($extensionName !== null) {	×
202	$parameters->setControllerExtensionName($extensionName);	×
203	}
204	$parameters->setControllerName($controllerName ?? $controllerClassToAliasMapping[$firstControllerName]);	×
205	$parameters->setControllerActionName($actionName ?? $defaultActionName);	×
206
207	if (!empty($configuration['format'])) {	×
208	$parameters->setFormat($configuration['format']);	×
209	}
210
211	foreach ($arguments as $argumentName => $argumentValue) {	×
212	$parameters->setArgument($argumentName, $argumentValue);	×
213	}
214
215	return $GLOBALS['TYPO3_REQUEST']->withAttribute('extbase', $parameters);	×
216	}
217
218	$request = RequestResolver::resolveRequestFromRenderingContext($renderingContext);	×
219
220	if (method_exists($request, 'setControllerAliasToClassNameMapping')) {	×
221	$request->setControllerAliasToClassNameMapping($controllerAliasToClassMapping);	×
222	}
223
224	if ($pluginName !== null && method_exists($request, 'setPluginName')) {	×
225	$request->setPluginName($pluginName);	×
226	}
227
228	if ($extensionName !== null && method_exists($request, 'setControllerExtensionName')) {	×
229	$request->setControllerExtensionName($extensionName);	×
230	}
231
232	if (method_exists($request, 'setControllerName')) {	×
233	$request->setControllerName($controllerName ?? $controllerClassToAliasMapping[$firstControllerName]);	×
234	}
235
236	if (method_exists($request, 'setControllerActionName')) {	×
237	$request->setControllerActionName($actionName ?? $defaultActionName);	×
238	}
239
240	return $request;	×
241	}
242	}

FluidTYPO3 / vhs / 30001290505

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous