12929454001

Committed 23 Jan 2025 12:44PM UTC coverage: 92.829% (-0.07%) from 92.901%

Build # 12929454001

Build Type

Pull #2209

github

Committed by

web-flow

Commit Message

Merge 08ed1a548 into cf49f7a79

Pull Request Pull Request #2209: [WIP] Compatibility with TYPO3 v13

Run Details

86 of 112 new or added lines in 31 files covered. (76.79%)

5 existing lines in 3 files now uncovered.

7055 of 7600 relevant lines covered (92.83%)

65.02 hits per line

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

73.85

/Classes/Builder/RequestBuilder.php

<?php
declare(strict_types=1);
namespace FluidTYPO3\Flux\Builder;

/*
 * This file is part of the FluidTYPO3/Flux 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\Flux\Utility\ExtensionNamingUtility;
use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Core\Core\SystemEnvironmentBuilder;
use TYPO3\CMS\Core\Http\NormalizedParams;
use TYPO3\CMS\Core\Http\ServerRequest;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\TypoScript\AST\Node\RootNode;
use TYPO3\CMS\Core\TypoScript\FrontendTypoScript;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Mvc\ExtbaseRequestParameters;
use TYPO3\CMS\Extbase\Mvc\Request;
use TYPO3\CMS\Extbase\Mvc\RequestInterface;

class RequestBuilder implements SingletonInterface
{
    public function buildRequestFor(
        string $extensionIdentity,
        string $controllerName,
        string $controllerActionName,
        string $pluginName,
        array $arguments = []
    ): RequestInterface {
        $serverRequest = $this->getServerRequest();

        $controllerExtensionName = ExtensionNamingUtility::getExtensionName($extensionIdentity);
        if (class_exists(ExtbaseRequestParameters::class)) {
            $expectedControllerClassName = $this->buildControllerClassName($extensionIdentity, $controllerName);
            $extbaseQueryParameters = new ExtbaseRequestParameters($expectedControllerClassName);
            $extbaseQueryParameters->setControllerExtensionName($controllerExtensionName);
            $extbaseQueryParameters->setControllerName($controllerName);
            $extbaseQueryParameters->setControllerActionName($controllerActionName);
            $extbaseQueryParameters->setPluginName($pluginName);
            $extbaseQueryParameters->setArguments($arguments);
            /** @var Request $request */
            $request = GeneralUtility::makeInstance(
                Request::class,
                $serverRequest->withAttribute('extbase', $extbaseQueryParameters)
            );
        } else {
            /** @var Request $request */
            $request = GeneralUtility::makeInstance(Request::class);
            if (method_exists($request, 'setFormat')) {
                $request->setFormat('html');
            }
            if (method_exists($request, 'setControllerName')) {
                $request->setControllerName($controllerName);
            }
            if (method_exists($request, 'setControllerExtensionName')) {
                $request->setControllerExtensionName($controllerExtensionName);
            }
            if (method_exists($request, 'setControllerActionName')) {
                $request->setControllerActionName($controllerActionName);
            }
            if (method_exists($request, 'setArguments')) {
                $request->setArguments($arguments);
            }
            if (method_exists($request, 'setPluginName')) {
                $request->setPluginName($pluginName);
            }
        }

        if (method_exists($request, 'setRequestUri')) {
            $request->setRequestUri($this->getEnvironmentVariable('TYPO3_REQUEST_URL'));
        }
        if (method_exists($request, 'setBaseUri')) {
            $request->setBaseUri($this->getEnvironmentVariable('TYPO3_SITE_URL'));
        }

        return $request;
    }

    public function getServerRequest(): ServerRequestInterface
    {
        /** @var ServerRequestInterface $request */
        $request = $GLOBALS['TYPO3_REQUEST'] ?? (new ServerRequest())->withAttribute(
            'applicationType',
            defined('TYPO3_REQUESTTYPE') ? constant('TYPO3_REQUESTTYPE') : SystemEnvironmentBuilder::REQUESTTYPE_FE
        )->withQueryParams($_GET);

        if (!$request->getAttribute('normalizedParams')) {
            $request = $request->withAttribute('normalizedParams', NormalizedParams::createFromRequest($request));
        }

        if (class_exists(FrontendTypoScript::class) && !$request->getAttribute('frontend.typoscript')) {
            /** @var FrontendTypoScript $frontendTypoScript */
            $frontendTypoScript = GeneralUtility::makeInstance(
                FrontendTypoScript::class,
                GeneralUtility::makeInstance(RootNode::class),
                [],
                [],
                []
            );
            $frontendTypoScript->setSetupArray([]);
            $request = $request->withAttribute('frontend.typoscript', $frontendTypoScript);
        }
        return $request;
    }

    private function buildControllerClassName(string $extensionIdentity, string $controllerName): string
    {
        $controllerExtensionName = ExtensionNamingUtility::getExtensionName($extensionIdentity);
        $controllerVendorName = ExtensionNamingUtility::getVendorName($extensionIdentity);
        $expectedControllerClassName = sprintf(
            '%s\\%s\\Controller\\%sController',
            $controllerVendorName,
            $controllerExtensionName,
            $controllerName
        );
        if (!class_exists($expectedControllerClassName)) {
            $expectedControllerClassName = sprintf(
                '%s\\%s\\Controller\\%sController',
                'FluidTYPO3',
                'Flux',
                $controllerName
            );
        }
        return $expectedControllerClassName;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function getEnvironmentVariable(string $name): string
    {
        $returnValue = GeneralUtility::getIndpEnv($name);
        if (!is_scalar($returnValue)) {
            return '';
        }
        return $returnValue ? (string) $returnValue : '';
    }
}

1	<?php
2	declare(strict_types=1);
3	namespace FluidTYPO3\Flux\Builder;
4
5	/*
6	* This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
7	*
8	* For the full copyright and license information, please read the
9	* LICENSE.md file that was distributed with this source code.
10	*/
11
12	use FluidTYPO3\Flux\Utility\ExtensionNamingUtility;
13	use Psr\Http\Message\ServerRequestInterface;
14	use TYPO3\CMS\Core\Core\SystemEnvironmentBuilder;
15	use TYPO3\CMS\Core\Http\NormalizedParams;
16	use TYPO3\CMS\Core\Http\ServerRequest;
17	use TYPO3\CMS\Core\SingletonInterface;
18	use TYPO3\CMS\Core\TypoScript\AST\Node\RootNode;
19	use TYPO3\CMS\Core\TypoScript\FrontendTypoScript;
20	use TYPO3\CMS\Core\Utility\GeneralUtility;
21	use TYPO3\CMS\Extbase\Mvc\ExtbaseRequestParameters;
22	use TYPO3\CMS\Extbase\Mvc\Request;
23	use TYPO3\CMS\Extbase\Mvc\RequestInterface;
24
25	class RequestBuilder implements SingletonInterface
26	{
27	public function buildRequestFor(
28	string $extensionIdentity,
29	string $controllerName,
30	string $controllerActionName,
31	string $pluginName,
32	array $arguments = []
33	): RequestInterface {
34	$serverRequest = $this->getServerRequest();	7✔
35
36	$controllerExtensionName = ExtensionNamingUtility::getExtensionName($extensionIdentity);	7✔
37	if (class_exists(ExtbaseRequestParameters::class)) {	7✔
38	$expectedControllerClassName = $this->buildControllerClassName($extensionIdentity, $controllerName);	6✔
39	$extbaseQueryParameters = new ExtbaseRequestParameters($expectedControllerClassName);	6✔
40	$extbaseQueryParameters->setControllerExtensionName($controllerExtensionName);	6✔
41	$extbaseQueryParameters->setControllerName($controllerName);	6✔
42	$extbaseQueryParameters->setControllerActionName($controllerActionName);	6✔
43	$extbaseQueryParameters->setPluginName($pluginName);	6✔
44	$extbaseQueryParameters->setArguments($arguments);	6✔
45	/** @var Request $request */
46	$request = GeneralUtility::makeInstance(	6✔
47	Request::class,	6✔
48	$serverRequest->withAttribute('extbase', $extbaseQueryParameters)	6✔
49	);	6✔
50	} else {
51	/** @var Request $request */
52	$request = GeneralUtility::makeInstance(Request::class);	1✔
53	if (method_exists($request, 'setFormat')) {	1✔
54	$request->setFormat('html');	1✔
55	}
56	if (method_exists($request, 'setControllerName')) {	1✔
57	$request->setControllerName($controllerName);	1✔
58	}
59	if (method_exists($request, 'setControllerExtensionName')) {	1✔
60	$request->setControllerExtensionName($controllerExtensionName);	1✔
61	}
62	if (method_exists($request, 'setControllerActionName')) {	1✔
63	$request->setControllerActionName($controllerActionName);	1✔
64	}
65	if (method_exists($request, 'setArguments')) {	1✔
66	$request->setArguments($arguments);	1✔
67	}
68	if (method_exists($request, 'setPluginName')) {	1✔
69	$request->setPluginName($pluginName);	1✔
70	}
71	}
72
73	if (method_exists($request, 'setRequestUri')) {	7✔
74	$request->setRequestUri($this->getEnvironmentVariable('TYPO3_REQUEST_URL'));	1✔
75	}
76	if (method_exists($request, 'setBaseUri')) {	7✔
77	$request->setBaseUri($this->getEnvironmentVariable('TYPO3_SITE_URL'));	1✔
78	}
79
80	return $request;	7✔
81	}
82
83	public function getServerRequest(): ServerRequestInterface
84	{
85	/** @var ServerRequestInterface $request */
86	$request = $GLOBALS['TYPO3_REQUEST'] ?? (new ServerRequest())->withAttribute(	×
87	'applicationType',	×
88	defined('TYPO3_REQUESTTYPE') ? constant('TYPO3_REQUESTTYPE') : SystemEnvironmentBuilder::REQUESTTYPE_FE	×
89	)->withQueryParams($_GET);	×
90
91	if (!$request->getAttribute('normalizedParams')) {	×
92	$request = $request->withAttribute('normalizedParams', NormalizedParams::createFromRequest($request));	×
93	}
94
95	if (class_exists(FrontendTypoScript::class) && !$request->getAttribute('frontend.typoscript')) {	×
96	/** @var FrontendTypoScript $frontendTypoScript */
97	$frontendTypoScript = GeneralUtility::makeInstance(	×
98	FrontendTypoScript::class,	×
99	GeneralUtility::makeInstance(RootNode::class),	×
NEW 100	[],	×
NEW 101	[],	×
102	[]	×
103	);	×
104	$frontendTypoScript->setSetupArray([]);	×
105	$request = $request->withAttribute('frontend.typoscript', $frontendTypoScript);	×
106	}
107	return $request;	×
108	}
109
110	private function buildControllerClassName(string $extensionIdentity, string $controllerName): string
111	{
112	$controllerExtensionName = ExtensionNamingUtility::getExtensionName($extensionIdentity);	6✔
113	$controllerVendorName = ExtensionNamingUtility::getVendorName($extensionIdentity);	6✔
114	$expectedControllerClassName = sprintf(	6✔
115	'%s\\%s\\Controller\\%sController',	6✔
116	$controllerVendorName,	6✔
117	$controllerExtensionName,	6✔
118	$controllerName	6✔
119	);	6✔
120	if (!class_exists($expectedControllerClassName)) {	6✔
121	$expectedControllerClassName = sprintf(	6✔
122	'%s\\%s\\Controller\\%sController',	6✔
123	'FluidTYPO3',	6✔
124	'Flux',	6✔
125	$controllerName	6✔
126	);	6✔
127	}
128	return $expectedControllerClassName;	6✔
129	}
130
131	/**
132	* @codeCoverageIgnore
133	*/
134	protected function getEnvironmentVariable(string $name): string
135	{
136	$returnValue = GeneralUtility::getIndpEnv($name);
137	if (!is_scalar($returnValue)) {
138	return '';
139	}
140	return $returnValue ? (string) $returnValue : '';
141	}
142	}

FluidTYPO3 / flux / 12929454001

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