FormRuntime.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
/*
 * Inspired by and partially taken from the Neos.Form package (www.neos.io)
 */
 
namespace ‪TYPO3\CMS\Form\Domain\Runtime;
 
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Error\Http\BadRequestException;
use ‪TYPO3\CMS\Core\ExpressionLanguage\Resolver;
use ‪TYPO3\CMS\Core\Http\ApplicationType;
use ‪TYPO3\CMS\Core\Http\Response;
use ‪TYPO3\CMS\Core\Http\ServerRequest;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\Entity\SiteLanguage;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\Exception\MissingArrayPathException;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\Error\Result;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\Arguments;
use ‪TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext;
use ‪TYPO3\CMS\Extbase\Mvc\Request;
use ‪TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;
use ‪TYPO3\CMS\Extbase\Object\ObjectManagerInterface;
use ‪TYPO3\CMS\Extbase\Property\Exception as ‪PropertyException;
use ‪TYPO3\CMS\Extbase\Security\Cryptography\HashService;
use ‪TYPO3\CMS\Extbase\Security\Exception\InvalidArgumentForHashGenerationException;
use ‪TYPO3\CMS\Extbase\Security\Exception\InvalidHashException;
use ‪TYPO3\CMS\Form\Domain\Exception\RenderingException;
use ‪TYPO3\CMS\Form\Domain\Finishers\FinisherContext;
use ‪TYPO3\CMS\Form\Domain\Finishers\FinisherInterface;
use ‪TYPO3\CMS\Form\Domain\Model\FormDefinition;
use ‪TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;
use ‪TYPO3\CMS\Form\Domain\Model\FormElements\Page;
use ‪TYPO3\CMS\Form\Domain\Model\Renderable\RootRenderableInterface;
use ‪TYPO3\CMS\Form\Domain\Model\Renderable\VariableRenderableInterface;
use ‪TYPO3\CMS\Form\Domain\Renderer\RendererInterface;
use ‪TYPO3\CMS\Form\Domain\Runtime\Exception\PropertyMappingException;
use ‪TYPO3\CMS\Form\Domain\Runtime\FormRuntime\FormSession;
use ‪TYPO3\CMS\Form\Domain\Runtime\FormRuntime\Lifecycle\AfterFormStateInitializedInterface;
use ‪TYPO3\CMS\Form\Exception as FormException;
use ‪TYPO3\CMS\Form\Mvc\Validation\EmptyValidator;
use ‪TYPO3\CMS\Frontend\Authentication\FrontendUserAuthentication;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
 
class ‪FormRuntime implements ‪RootRenderableInterface, \ArrayAccess
{
    public const ‪HONEYPOT_NAME_SESSION_IDENTIFIER = 'tx_form_honeypot_name_';
 
    protected ContainerInterface ‪$container;
    // @deprecated since v11, will be removed in v12
    protected ‪ObjectManagerInterface ‪$objectManager;
    protected ?‪FormDefinition ‪$formDefinition = null;
    protected ?‪Request ‪$request = null;
    protected ResponseInterface ‪$response;
    protected ‪HashService ‪$hashService;
    protected ‪ConfigurationManagerInterface ‪$configurationManager;
 
    protected ‪$formState;
 
    protected ‪$formSession;
 
    protected ‪$currentPage;
 
    protected ‪$lastDisplayedPage;
 
    protected ‪$currentSiteLanguage;
 
    protected ‪$currentFinisher;
 
    public function ‪__construct(
        ContainerInterface ‪$container,
        ‪ObjectManagerInterface ‪$objectManager,
        ‪ConfigurationManagerInterface ‪$configurationManager,
        ‪HashService ‪$hashService
    ) {
        $this->container = ‪$container;
        // @deprecated since v11, will be removed in v12
        $this->objectManager = ‪$objectManager;
        $this->configurationManager = ‪$configurationManager;
        $this->hashService = ‪$hashService;
        $this->response = new ‪Response();
    }
 
    public function ‪setFormDefinition(‪FormDefinition ‪$formDefinition)
    {
        $this->formDefinition = ‪$formDefinition;
    }
 
    public function ‪setRequest(‪Request ‪$request)
    {
        $this->request = clone ‪$request;
    }
 
    public function ‪initialize()
    {
        $arguments = $this->request->getArguments();
        $formIdentifier = $this->formDefinition->getIdentifier();
        if (isset($arguments[$formIdentifier])) {
            $this->request->setArguments($arguments[$formIdentifier]);
        }
 
        $this->‪initializeCurrentSiteLanguage();
        $this->‪initializeFormSessionFromRequest();
        $this->‪initializeFormStateFromRequest();
        $this->‪triggerAfterFormStateInitialized();
        $this->‪processVariants();
        $this->‪initializeCurrentPageFromRequest();
        $this->‪initializeHoneypotFromRequest();
 
        // Only validate and set form values within the form state
        // if the current request is not the very first request
        // and the current request can be processed (POST request and uncached).
        if (!$this->‪isFirstRequest() && $this->‪canProcessFormSubmission()) {
            $this->‪processSubmittedFormValues();
        }
 
        $this->‪renderHoneypot();
    }
 
    protected function ‪initializeFormSessionFromRequest(): void
    {
        // Initialize the form session only if the current request can be processed
        // (POST request and uncached) to ensure unique sessions for each form submitter.
        if (!$this->‪canProcessFormSubmission()) {
            return;
        }
 
        $sessionIdentifierFromRequest = $this->request->getInternalArgument('__session');
        $this->formSession = GeneralUtility::makeInstance(FormSession::class, $sessionIdentifierFromRequest);
    }
 
    protected function ‪initializeFormStateFromRequest()
    {
        // Only try to reconstitute the form state if the current request
        // is not the very first request and if the current request can
        // be processed (POST request and uncached).
        $serializedFormStateWithHmac = $this->request->getInternalArgument('__state');
        if ($serializedFormStateWithHmac === null || !$this->‪canProcessFormSubmission()) {
            $this->formState = GeneralUtility::makeInstance(FormState::class);
        } else {
            try {
                $serializedFormState = $this->hashService->validateAndStripHmac($serializedFormStateWithHmac);
            } catch (InvalidHashException | InvalidArgumentForHashGenerationException $e) {
                throw new ‪BadRequestException('The HMAC of the form state could not be validated.', 1581862823);
            }
            $this->formState = unserialize(base64_decode($serializedFormState));
        }
    }
 
    protected function ‪triggerAfterFormStateInitialized(): void
    {
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterFormStateInitialized'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if ($hookObj instanceof AfterFormStateInitializedInterface) {
                $hookObj->afterFormStateInitialized($this);
            }
        }
    }
 
    protected function ‪initializeCurrentPageFromRequest()
    {
        // If there was no previous form submissions or if the current request
        // can't be processed (no POST request and/or cached) then display the first
        // form step
        if (!$this->formState->isFormSubmitted() || !$this->canProcessFormSubmission()) {
            $this->currentPage = $this->formDefinition->getPageByIndex(0);
 
            if (!$this->currentPage->isEnabled()) {
                throw new FormException('Disabling the first page is not allowed', 1527186844);
            }
 
            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterInitializeCurrentPage'] ?? [] as $className) {
                $hookObj = GeneralUtility::makeInstance($className);
                if (method_exists($hookObj, 'afterInitializeCurrentPage')) {
                    $this->currentPage = $hookObj->afterInitializeCurrentPage(
                        $this,
                        $this->currentPage,
                        null,
                        $this->request->getArguments()
                    );
                }
            }
            return;
        }
 
        $this->lastDisplayedPage = $this->formDefinition->getPageByIndex($this->formState->getLastDisplayedPageIndex());
        $currentPageIndex = (int)$this->request->getInternalArgument('__currentPage');
 
        if ($this->‪userWentBackToPreviousStep()) {
            if ($currentPageIndex < $this->lastDisplayedPage->getIndex()) {
                $currentPageIndex = $this->lastDisplayedPage->getIndex();
            }
        } else {
            if ($currentPageIndex > $this->lastDisplayedPage->getIndex() + 1) {
                $currentPageIndex = $this->lastDisplayedPage->getIndex() + 1;
            }
        }
 
        if ($currentPageIndex >= count($this->formDefinition->getPages())) {
            // Last Page
            $this->currentPage = null;
        } else {
            $this->currentPage = $this->formDefinition->getPageByIndex($currentPageIndex);
 
            if (!$this->currentPage->isEnabled()) {
                if ($currentPageIndex === 0) {
                    throw new FormException('Disabling the first page is not allowed', 1527186845);
                }
 
                if ($this->‪userWentBackToPreviousStep()) {
                    $this->currentPage = $this->‪getPreviousEnabledPage();
                } else {
                    $this->currentPage = $this->‪getNextEnabledPage();
                }
            }
        }
 
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterInitializeCurrentPage'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'afterInitializeCurrentPage')) {
                $this->currentPage = $hookObj->afterInitializeCurrentPage(
                    $this,
                    $this->currentPage,
                    $this->lastDisplayedPage,
                    $this->request->getArguments()
                );
            }
        }
    }
 
    protected function ‪initializeHoneypotFromRequest()
    {
        $renderingOptions = $this->formDefinition->getRenderingOptions();
        if (!isset($renderingOptions['honeypot']['enable'])
            || $renderingOptions['honeypot']['enable'] === false
            || ((‪$GLOBALS['TYPO3_REQUEST'] ?? null) instanceof ServerRequestInterface
                && ‪ApplicationType::fromRequest(‪$GLOBALS['TYPO3_REQUEST'])->isBackend())
        ) {
            return;
        }
 
        ‪ArrayUtility::assertAllArrayKeysAreValid($renderingOptions['honeypot'], ['enable', 'formElementToUse']);
 
        if (!$this->‪isFirstRequest()) {
            $elementsCount = count($this->lastDisplayedPage->getElements());
            if ($elementsCount === 0) {
                return;
            }
 
            $honeypotNameFromSession = $this->‪getHoneypotNameFromSession($this->lastDisplayedPage);
            if ($honeypotNameFromSession) {
                $honeypotElement = $this->lastDisplayedPage->createElement($honeypotNameFromSession, $renderingOptions['honeypot']['formElementToUse']);
                ‪$validator = GeneralUtility::makeInstance(EmptyValidator::class);
                $honeypotElement->addValidator(‪$validator);
            }
        }
    }
 
    protected function ‪renderHoneypot()
    {
        $renderingOptions = $this->formDefinition->getRenderingOptions();
        if (!isset($renderingOptions['honeypot']['enable'])
            || $this->currentPage === null
            || $renderingOptions['honeypot']['enable'] === false
            || ((‪$GLOBALS['TYPO3_REQUEST'] ?? null) instanceof ServerRequestInterface
                && ‪ApplicationType::fromRequest(‪$GLOBALS['TYPO3_REQUEST'])->isBackend())
        ) {
            return;
        }
 
        ‪ArrayUtility::assertAllArrayKeysAreValid($renderingOptions['honeypot'], ['enable', 'formElementToUse']);
 
        if (!$this->‪isAfterLastPage()) {
            $elementsCount = count($this->currentPage->getElements());
            if ($elementsCount === 0) {
                return;
            }
 
            if (!$this->‪isFirstRequest()) {
                $honeypotNameFromSession = $this->‪getHoneypotNameFromSession($this->lastDisplayedPage);
                if ($honeypotNameFromSession) {
                    $honeypotElement = $this->formDefinition->getElementByIdentifier($honeypotNameFromSession);
                    if ($honeypotElement instanceof FormElementInterface) {
                        $this->lastDisplayedPage->removeElement($honeypotElement);
                    }
                }
            }
 
            $elementsCount = count($this->currentPage->getElements());
            $randomElementNumber = random_int(0, $elementsCount - 1);
            $honeypotName = substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), 0, random_int(5, 26));
 
            $referenceElement = $this->currentPage->getElements()[$randomElementNumber];
            $honeypotElement = $this->currentPage->createElement($honeypotName, $renderingOptions['honeypot']['formElementToUse']);
            ‪$validator = GeneralUtility::makeInstance(EmptyValidator::class);
 
            $honeypotElement->addValidator(‪$validator);
            if (random_int(0, 1) === 1) {
                $this->currentPage->moveElementAfter($honeypotElement, $referenceElement);
            } else {
                $this->currentPage->moveElementBefore($honeypotElement, $referenceElement);
            }
            $this->‪setHoneypotNameInSession($this->currentPage, $honeypotName);
        }
    }
 
    protected function ‪getHoneypotNameFromSession(‪Page $page)
    {
        if ($this->‪isFrontendUserAuthenticated()) {
            $honeypotNameFromSession = $this->‪getFrontendUser()->‪getKey(
                'user',
                self::HONEYPOT_NAME_SESSION_IDENTIFIER . $this->‪getIdentifier() . $page->‪getIdentifier()
            );
        } else {
            $honeypotNameFromSession = $this->‪getFrontendUser()->‪getKey(
                'ses',
                self::HONEYPOT_NAME_SESSION_IDENTIFIER . $this->‪getIdentifier() . $page->‪getIdentifier()
            );
        }
        return $honeypotNameFromSession;
    }
 
    protected function ‪setHoneypotNameInSession(‪Page $page, string $honeypotName)
    {
        if ($this->‪isFrontendUserAuthenticated()) {
            $this->‪getFrontendUser()->‪setKey(
                'user',
                self::HONEYPOT_NAME_SESSION_IDENTIFIER . $this->‪getIdentifier() . $page->‪getIdentifier(),
                $honeypotName
            );
        } else {
            $this->‪getFrontendUser()->‪setKey(
                'ses',
                self::HONEYPOT_NAME_SESSION_IDENTIFIER . $this->‪getIdentifier() . $page->‪getIdentifier(),
                $honeypotName
            );
        }
    }
 
    protected function ‪isFrontendUserAuthenticated(): bool
    {
        return (bool)GeneralUtility::makeInstance(Context::class)
            ->getPropertyFromAspect('frontend.user', 'isLoggedIn', false);
    }
 
    protected function ‪processVariants()
    {
        $conditionResolver = $this->‪getConditionResolver();
 
        $renderables = array_merge([$this->formDefinition], $this->formDefinition->getRenderablesRecursively());
        foreach ($renderables as $renderable) {
            if ($renderable instanceof ‪VariableRenderableInterface) {
                $variants = $renderable->getVariants();
                foreach ($variants as $variant) {
                    if ($variant->conditionMatches($conditionResolver)) {
                        $variant->apply();
                    }
                }
            }
        }
    }
 
    protected function ‪isAfterLastPage(): bool
    {
        return $this->currentPage === null;
    }
 
    protected function ‪isFirstRequest(): bool
    {
        return $this->lastDisplayedPage === null;
    }
 
    protected function ‪isPostRequest(): bool
    {
        return $this->‪getRequest()->‪getMethod() === 'POST';
    }
 
    protected function ‪isRenderedCached(): bool
    {
        $contentObject = $this->configurationManager->getContentObject();
        return $contentObject === null
            ? true
            // @todo this does not work when rendering a cached `FLUIDTEMPLATE` (not nested in `COA_INT`)
            : $contentObject->getUserObjectType() === ContentObjectRenderer::OBJECTTYPE_USER;
    }
 
    protected function ‪processSubmittedFormValues()
    {
        $result = $this->‪mapAndValidatePage($this->lastDisplayedPage);
        if ($result->hasErrors() && !$this->userWentBackToPreviousStep()) {
            $this->currentPage = ‪$this->lastDisplayedPage;
            $this->request->setOriginalRequestMappingResults($result);
        }
    }
 
    protected function ‪userWentBackToPreviousStep(): bool
    {
        return !$this->‪isAfterLastPage() && !$this->‪isFirstRequest() && $this->currentPage->getIndex() < $this->lastDisplayedPage->getIndex();
    }
 
    protected function ‪mapAndValidatePage(‪Page $page): ‪Result
    {
        $result = GeneralUtility::makeInstance(Result::class);
        $requestArguments = $this->request->getArguments();
 
        $propertyPathsForWhichPropertyMappingShouldHappen = [];
        $registerPropertyPaths = static function ($propertyPath) use (&$propertyPathsForWhichPropertyMappingShouldHappen) {
            $propertyPathParts = explode('.', $propertyPath);
            $accumulatedPropertyPathParts = [];
            foreach ($propertyPathParts as $propertyPathPart) {
                $accumulatedPropertyPathParts[] = $propertyPathPart;
                $temporaryPropertyPath = implode('.', $accumulatedPropertyPathParts);
                $propertyPathsForWhichPropertyMappingShouldHappen[$temporaryPropertyPath] = $temporaryPropertyPath;
            }
        };
 
        $value = null;
 
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterSubmit'] ?? [] as $className) {
            $hookObj = GeneralUtility::makeInstance($className);
            if (method_exists($hookObj, 'afterSubmit')) {
                $value = $hookObj->afterSubmit(
                    $this,
                    $page,
                    $value,
                    $requestArguments
                );
            }
        }
 
        foreach ($page->‪getElementsRecursively() as $element) {
            if (!$element->isEnabled()) {
                continue;
            }
 
            try {
                $value = ‪ArrayUtility::getValueByPath($requestArguments, $element->getIdentifier(), '.');
            } catch (‪MissingArrayPathException $exception) {
                $value = null;
            }
 
            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/form']['afterSubmit'] ?? [] as $className) {
                $hookObj = GeneralUtility::makeInstance($className);
                if (method_exists($hookObj, 'afterSubmit')) {
                    $value = $hookObj->afterSubmit(
                        $this,
                        $element,
                        $value,
                        $requestArguments
                    );
                }
            }
 
            $this->formState->setFormValue($element->getIdentifier(), $value);
            $registerPropertyPaths($element->getIdentifier());
        }
 
        // The more parts the path has, the more early it is processed
        usort($propertyPathsForWhichPropertyMappingShouldHappen, static function ($a, $b) {
            return substr_count($b, '.') - substr_count($a, '.');
        });
 
        $processingRules = $this->formDefinition->getProcessingRules();
 
        foreach ($propertyPathsForWhichPropertyMappingShouldHappen as $propertyPath) {
            if (isset($processingRules[$propertyPath])) {
                $processingRule = $processingRules[$propertyPath];
                $value = $this->formState->getFormValue($propertyPath);
                try {
                    $value = $processingRule->process($value);
                } catch (‪PropertyException $exception) {
                    throw new ‪PropertyMappingException(
                        'Failed to process FormValue at "' . $propertyPath . '" from "' . gettype($value) . '" to "' . $processingRule->getDataType() . '"',
                        1480024933,
                        $exception
                    );
                }
                $result->forProperty($this->‪getIdentifier() . '.' . $propertyPath)->merge($processingRule->getProcessingMessages());
                $this->formState->setFormValue($propertyPath, $value);
            }
        }
 
        return $result;
    }
 
    public function ‪overrideCurrentPage(int $pageIndex)
    {
        $this->currentPage = $this->formDefinition->getPageByIndex($pageIndex);
    }
 
    public function ‪render()
    {
        if ($this->‪isAfterLastPage()) {
            return $this->‪invokeFinishers();
        }
        $this->‪processVariants();
 
        $this->formState->setLastDisplayedPageIndex($this->currentPage->getIndex());
 
        if ($this->formDefinition->getRendererClassName() === '') {
            throw new RenderingException(sprintf('The form definition "%s" does not have a rendererClassName set.', $this->formDefinition->getIdentifier()), 1326095912);
        }
        $rendererClassName = $this->formDefinition->getRendererClassName();
        if ($this->container->has($rendererClassName)) {
            $renderer = $this->container->get($rendererClassName);
        } else {
            // @deprecated since v11, will be removed in v12.
            $renderer = $this->objectManager->get($rendererClassName);
        }
        if (!($renderer instanceof RendererInterface)) {
            throw new RenderingException(sprintf('The renderer "%s" des not implement RendererInterface', $rendererClassName), 1326096024);
        }
 
        // @deprecated since v11, will be removed with v12.
        $controllerContext = $this->‪getControllerContext();
        $renderer->setControllerContext($controllerContext);
 
        $renderer->setFormRuntime($this);
        return $renderer->render();
    }
 
    protected function ‪invokeFinishers(): string
    {
        $finisherContext = GeneralUtility::makeInstance(
            FinisherContext::class,
            $this,
            $this->‪getControllerContext(), // @deprecated since v11, will be removed with v12.
            $this->request
        );
 
        ‪$output = '';
        $this->response->getBody()->rewind();
        $originalContent = $this->response->getBody()->getContents();
        $this->response->getBody()->write('');
        foreach ($this->formDefinition->getFinishers() as $finisher) {
            $this->currentFinisher = $finisher;
            $this->‪processVariants();
 
            $finisherOutput = $finisher->execute($finisherContext);
            if (is_string($finisherOutput) && !empty($finisherOutput)) {
                ‪$output .= $finisherOutput;
            } else {
                $this->response->getBody()->rewind();
                ‪$output .= $this->response->getBody()->getContents();
                $this->response->getBody()->write('');
            }
 
            if ($finisherContext->isCancelled()) {
                break;
            }
        }
        $this->response->getBody()->rewind();
        $this->response->getBody()->write($originalContent);
 
        return ‪$output;
    }
 
    public function ‪getIdentifier(): string
    {
        return $this->formDefinition->getIdentifier();
    }
 
    public function ‪getRequest(): Request
    {
        return ‪$this->request;
    }
 
    public function ‪getResponse(): ResponseInterface
    {
        return ‪$this->response;
    }
 
    public function ‪canProcessFormSubmission(): bool
    {
        return $this->‪isPostRequest() && !$this->‪isRenderedCached();
    }
 
    public function ‪getFormSession(): ?‪FormSession
    {
        return ‪$this->formSession;
    }
 
    public function ‪getCurrentPage(): ?‪Page
    {
        return ‪$this->currentPage;
    }
 
    public function ‪getPreviousPage(): ?‪Page
    {
        $previousPageIndex = $this->currentPage->‪getIndex() - 1;
        if ($this->formDefinition->hasPageWithIndex($previousPageIndex)) {
            return $this->formDefinition->getPageByIndex($previousPageIndex);
        }
        return null;
    }
 
    public function ‪getNextPage(): ?‪Page
    {
        $nextPageIndex = $this->currentPage->‪getIndex() + 1;
        if ($this->formDefinition->hasPageWithIndex($nextPageIndex)) {
            return $this->formDefinition->getPageByIndex($nextPageIndex);
        }
        return null;
    }
 
    public function ‪getPreviousEnabledPage(): ?‪Page
    {
        $previousPage = null;
        $previousPageIndex = $this->currentPage->‪getIndex() - 1;
        while ($previousPageIndex >= 0) {
            if ($this->formDefinition->hasPageWithIndex($previousPageIndex)) {
                $previousPage = $this->formDefinition->getPageByIndex($previousPageIndex);
 
                if ($previousPage->isEnabled()) {
                    break;
                }
 
                $previousPage = null;
                $previousPageIndex--;
            } else {
                $previousPage = null;
                break;
            }
        }
 
        return $previousPage;
    }
 
    public function ‪getNextEnabledPage(): ?Page
    {
        $nextPage = null;
        $pageCount = count($this->formDefinition->getPages());
        $nextPageIndex = $this->currentPage->getIndex() + 1;
 
        while ($nextPageIndex < $pageCount) {
            if ($this->formDefinition->hasPageWithIndex($nextPageIndex)) {
                $nextPage = $this->formDefinition->getPageByIndex($nextPageIndex);
                $renderingOptions = $nextPage->getRenderingOptions();
                if (
                    !isset($renderingOptions['enabled'])
                    || (bool)$renderingOptions['enabled']
                ) {
                    break;
                }
                $nextPage = null;
                $nextPageIndex++;
            } else {
                $nextPage = null;
                break;
            }
        }
 
        return $nextPage;
    }
 
    protected function ‪getControllerContext(): ‪ControllerContext
    {
        $uriBuilder = GeneralUtility::makeInstance(UriBuilder::class);
        $uriBuilder->setRequest($this->request);
        $controllerContext = GeneralUtility::makeInstance(ControllerContext::class);
        $controllerContext->setRequest($this->request);
        $controllerContext->setArguments(GeneralUtility::makeInstance(Arguments::class));
        $controllerContext->setUriBuilder($uriBuilder);
        return $controllerContext;
    }
 
    public function ‪getType(): string
    {
        return $this->formDefinition->getType();
    }
 
    public function ‪offsetExists($identifier): bool
    {
        if ($this->‪getElementValue($identifier) !== null) {
            return true;
        }
 
        if (is_callable([$this, 'get' . ucfirst($identifier)])) {
            return true;
        }
        if (is_callable([$this, 'has' . ucfirst($identifier)])) {
            return true;
        }
        if (is_callable([$this, 'is' . ucfirst($identifier)])) {
            return true;
        }
        if (property_exists($this, $identifier)) {
            $propertyReflection = new \ReflectionProperty($this, $identifier);
            return $propertyReflection->isPublic();
        }
 
        return false;
    }
 
    #[\ReturnTypeWillChange]
    public function ‪offsetGet($identifier)
    {
        if ($this->‪getElementValue($identifier) !== null) {
            return $this->‪getElementValue($identifier);
        }
        $getterMethodName = 'get' . ucfirst($identifier);
        if (is_callable([$this, $getterMethodName])) {
            return $this->{$getterMethodName}();
        }
        return null;
    }
 
    public function ‪offsetSet($identifier, $value): void
    {
        $this->formState->setFormValue($identifier, $value);
    }
 
    public function ‪offsetUnset($identifier): void
    {
        $this->formState->setFormValue($identifier, null);
    }
 
    public function ‪getElementValue(string $identifier)
    {
        $formValue = $this->formState->getFormValue($identifier);
        if ($formValue !== null) {
            return $formValue;
        }
        return $this->formDefinition->getElementDefaultValueByIdentifier($identifier);
    }
 
    public function ‪getPages(): array
    {
        return $this->formDefinition->getPages();
    }
 
    public function ‪getFormState(): ?‪FormState
    {
        return ‪$this->formState;
    }
 
    public function ‪getRenderingOptions(): array
    {
        return $this->formDefinition->getRenderingOptions();
    }
 
    public function ‪getRendererClassName(): string
    {
        return $this->formDefinition->getRendererClassName();
    }
 
    public function ‪getLabel(): string
    {
        return $this->formDefinition->getLabel();
    }
 
    public function ‪getTemplateName(): string
    {
        return $this->formDefinition->getTemplateName();
    }
 
    public function ‪getFormDefinition(): ‪FormDefinition
    {
        return ‪$this->formDefinition;
    }
 
    public function ‪getCurrentSiteLanguage(): ?‪SiteLanguage
    {
        return ‪$this->currentSiteLanguage;
    }
 
    public function ‪setCurrentSiteLanguage(‪SiteLanguage ‪$currentSiteLanguage): void
    {
        $this->currentSiteLanguage = ‪$currentSiteLanguage;
    }
 
    protected function ‪initializeCurrentSiteLanguage(): void
    {
        if (
            ‪$GLOBALS['TYPO3_REQUEST'] instanceof ServerRequestInterface
            && ‪$GLOBALS['TYPO3_REQUEST']->getAttribute('language') instanceof ‪SiteLanguage
        ) {
            $this->currentSiteLanguage = ‪$GLOBALS['TYPO3_REQUEST']->getAttribute('language');
        } else {
            $pageId = 0;
            $languageId = (int)GeneralUtility::makeInstance(Context::class)->getPropertyFromAspect('language', 'id', 0);
 
            if ($this->‪getTypoScriptFrontendController() !== null) {
                $pageId = $this->‪getTypoScriptFrontendController()->id;
            }
 
            $fakeSiteConfiguration = [
                'languages' => [
                    [
                        'languageId' => $languageId,
                        'title' => 'Dummy',
                        'navigationTitle' => '',
                        'typo3Language' => '',
                        'flag' => '',
                        'locale' => '',
                        'iso-639-1' => '',
                        'hreflang' => '',
                        'direction' => '',
                    ],
                ],
            ];
 
            $this->currentSiteLanguage = GeneralUtility::makeInstance(Site::class, 'form-dummy', $pageId, $fakeSiteConfiguration)
                ->getLanguageById($languageId);
        }
    }
 
    public function ‪getCurrentFinisher(): ?‪FinisherInterface
    {
        return ‪$this->currentFinisher;
    }
 
    protected function ‪getConditionResolver(): ‪Resolver
    {
        $formValues = array_replace_recursive(
            $this->‪getFormState()->getFormValues(),
            $this->‪getRequest()->getArguments()
        );
        $page = $this->‪getCurrentPage() ?? $this->‪getFormDefinition()->‪getPageByIndex(0);
 
        $finisherIdentifier = '';
        if ($this->‪getCurrentFinisher() !== null) {
            if (method_exists($this->‪getCurrentFinisher(), 'getFinisherIdentifier')) {
                $finisherIdentifier = $this->‪getCurrentFinisher()->getFinisherIdentifier();
            } else {
                $finisherIdentifier = (new \ReflectionClass($this->‪getCurrentFinisher()))->getShortName();
                $finisherIdentifier = preg_replace('/Finisher$/', '', $finisherIdentifier);
            }
        }
 
        $contentObjectData = [];
        if ($this->configurationManager->getContentObject() instanceof ContentObjectRenderer) {
            $contentObjectData = $this->configurationManager->getContentObject()->data;
        }
 
        return GeneralUtility::makeInstance(
            Resolver::class,
            'form',
            [
                'formRuntime' => $this,
                'formValues' => $formValues,
                'stepIdentifier' => $page->‪getIdentifier(),
                'stepType' => $page->‪getType(),
                'finisherIdentifier' => $finisherIdentifier,
                'contentObject' => $contentObjectData,
            ],
            ‪$GLOBALS['TYPO3_REQUEST'] ?? GeneralUtility::makeInstance(ServerRequest::class)
        );
    }
 
    protected function ‪getFrontendUser(): ‪FrontendUserAuthentication
    {
        return $this->‪getTypoScriptFrontendController()->fe_user;
    }
 
    protected function ‪getTypoScriptFrontendController(): ?‪TypoScriptFrontendController
    {
        return ‪$GLOBALS['TSFE'] ?? null;
    }
}