9.5/_form_runtime_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Form\Domain\Runtime;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It originated from the Neos.Form package (www.neos.io)

 *

 * 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!

 */


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\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\Web\Request;

use ‪TYPO3\CMS\Extbase\Mvc\Web\Response;

use ‪TYPO3\CMS\Extbase\Mvc\Web\Routing\UriBuilder;

use ‪TYPO3\CMS\Extbase\Property\Exception as ‪PropertyException;

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

{

    const ‪HONEYPOT_NAME_SESSION_IDENTIFIER = 'tx_form_honeypot_name_';


    protected ‪$objectManager;


    protected ‪$formDefinition;


    protected ‪$request;


    protected ‪$response;


    protected ‪$formState;


    protected ‪$formSession;


    protected ‪$currentPage;


    protected ‪$lastDisplayedPage;


    protected ‪$hashService;


    protected ‪$currentSiteLanguage = null;


    protected ‪$currentFinisher = null;


    protected ‪$configurationManager;


    public function ‪injectHashService(\‪TYPO3\CMS\‪Extbase\Security\Cryptography\HashService ‪$hashService)

    {

        $this->hashService = ‪$hashService;

    }


    public function ‪injectObjectManager(\‪TYPO3\CMS\‪Extbase\Object\ObjectManagerInterface ‪$objectManager)

    {

        $this->objectManager = ‪$objectManager;

    }


    public function ‪injectConfigurationManager(ConfigurationManagerInterface ‪$configurationManager)

    {

        $this->configurationManager = ‪$configurationManager;

    }


    public function ‪__construct(FormDefinition ‪$formDefinition, Request ‪$request, Response ‪$response)

    {

        $this->formDefinition = ‪$formDefinition;

        $arguments = ‪$request->‪getArguments();

        $this->request = clone ‪$request;

        $formIdentifier = $this->formDefinition->getIdentifier();

        if (isset($arguments[$formIdentifier])) {

            $this->request->‪setArguments($arguments[$formIdentifier]);

        }


        $this->response = ‪$response;

    }


    public function ‪initializeObject()

    {

        $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);

            $renderingOptions = $this->currentPage->getRenderingOptions();


            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);

            $renderingOptions = $this->currentPage->getRenderingOptions();


            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 || TYPO3_MODE === 'BE') {

            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 = $this->objectManager->get(EmptyValidator::class);

                $honeypotElement->addValidator(‪$validator);

            }

        }

    }


    protected function ‪renderHoneypot()

    {

        $renderingOptions = $this->formDefinition->getRenderingOptions();

        if (!isset($renderingOptions['honeypot']['enable']) || $renderingOptions['honeypot']['enable'] === false || TYPO3_MODE === 'BE') {

            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 = mt_rand(0, $elementsCount - 1);

            $honeypotName = substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), 0, mt_rand(5, 26));


            $referenceElement = $this->currentPage->getElements()[$randomElementNumber];

            $honeypotElement = $this->currentPage->createElement($honeypotName, $renderingOptions['honeypot']['formElementToUse']);

            ‪$validator = $this->objectManager->get(EmptyValidator::class);


            $honeypotElement->addValidator(‪$validator);

            if (mt_rand(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 = $this->objectManager->get(Result::class);

        $requestArguments = $this->request->getArguments();


        $propertyPathsForWhichPropertyMappingShouldHappen = [];

        $registerPropertyPaths = 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, 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();

        $renderer = $this->objectManager->get($rendererClassName);

        if (!($renderer instanceof RendererInterface)) {

            throw new RenderingException(sprintf('The renderer "%s" des not implement RendererInterface', $rendererClassName), 1326096024);

        }


        $controllerContext = $this->‪getControllerContext();


        $renderer->setControllerContext($controllerContext);

        $renderer->setFormRuntime($this);

        return $renderer->render();

    }


    protected function ‪invokeFinishers(): string

    {

        $finisherContext = $this->objectManager->get(

            FinisherContext::class,

            $this,

            $this->‪getControllerContext()

        );


        ‪$output = '';

        $originalContent = $this->response->getContent();

        $this->response->setContent(null);

        foreach ($this->formDefinition->getFinishers() as $finisher) {

            $this->currentFinisher = $finisher;

            $this->‪processVariants();


            $finisherOutput = $finisher->execute($finisherContext);

            if (is_string($finisherOutput) && !empty($finisherOutput)) {

                ‪$output .= $finisherOutput;

            } else {

                ‪$output .= $this->response->getContent();

                $this->response->setContent(null);

            }


            if ($finisherContext->isCancelled()) {

                break;

            }

        }

        $this->response->setContent($originalContent);


        return ‪$output;

    }


    public function ‪getIdentifier(): string

    {

        return $this->formDefinition->getIdentifier();

    }


    public function ‪getRequest(): ‪Request

    {

        return ‪$this->request;

    }


    public function ‪getResponse(): ‪Response

    {

        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 = $this->objectManager->get(UriBuilder::class);

        $uriBuilder->setRequest($this->request);

        $controllerContext = $this->objectManager->get(ControllerContext::class);

        $controllerContext->setRequest($this->request);

        $controllerContext->setResponse($this->response);

        $controllerContext->setArguments($this->objectManager->get(Arguments::class, []));

        $controllerContext->setUriBuilder($uriBuilder);

        return $controllerContext;

    }


    public function ‪getType(): string

    {

        return $this->formDefinition->getType();

    }


    public function ‪offsetExists($identifier)

    {

        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;

    }


    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)

    {

        $this->formState->setFormValue($identifier, $value);

    }


    public function ‪offsetUnset($identifier)

    {

        $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 (TYPO3_MODE === 'FE') {

                $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);

            }

        }


        return GeneralUtility::makeInstance(

            Resolver::class,

            'form',

            [

                // some shortcuts

                'formRuntime' => $this,

                'formValues' => $formValues,

                'stepIdentifier' => $page->getIdentifier(),

                'stepType' => $page->getType(),

                'finisherIdentifier' => $finisherIdentifier,

            ],

            ‪$GLOBALS['TYPO3_REQUEST'] ?? GeneralUtility::makeInstance(ServerRequest::class)

        );

    }


    protected function ‪getFrontendUser(): ‪FrontendUserAuthentication

    {

        return $this->‪getTypoScriptFrontendController()->fe_user;

    }


    protected function ‪getTypoScriptFrontendController(): ‪TypoScriptFrontendController

    {

        return ‪$GLOBALS['TSFE'];

    }

}