9.5/_form_definition_8php_source.html

<?php

declare(strict_types = 1);

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


/*

 * 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 ‪TYPO3\CMS\Core\Utility\ArrayUtility;

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

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

use ‪TYPO3\CMS\Extbase\Reflection\ObjectAccess;

use ‪TYPO3\CMS\Form\Domain\Exception\IdentifierNotValidException;

use ‪TYPO3\CMS\Form\Domain\Exception\TypeDefinitionNotFoundException;

use ‪TYPO3\CMS\Form\Domain\Finishers\FinisherInterface;

use ‪TYPO3\CMS\Form\Domain\Model\Exception\DuplicateFormElementException;

use ‪TYPO3\CMS\Form\Domain\Model\Exception\FinisherPresetNotFoundException;

use ‪TYPO3\CMS\Form\Domain\Model\Exception\FormDefinitionConsistencyException;

use ‪TYPO3\CMS\Form\Domain\Model\FormElements\FormElementInterface;

use ‪TYPO3\CMS\Form\Domain\Model\FormElements\Page;

use ‪TYPO3\CMS\Form\Domain\Model\Renderable\AbstractCompositeRenderable;

use ‪TYPO3\CMS\Form\Domain\Model\Renderable\RenderableInterface;

use ‪TYPO3\CMS\Form\Domain\Model\Renderable\VariableRenderableInterface;

use ‪TYPO3\CMS\Form\Domain\Runtime\FormRuntime;

use ‪TYPO3\CMS\Form\Exception as FormException;

use ‪TYPO3\CMS\Form\Mvc\ProcessingRule;


class ‪FormDefinition extends ‪AbstractCompositeRenderable implements ‪VariableRenderableInterface

{


    protected ‪$objectManager;


    protected ‪$finishers = [];


    protected ‪$processingRules = [];


    protected ‪$elementsByIdentifier = [];


    protected ‪$elementDefaultValues = [];


    protected ‪$rendererClassName = '';


    protected ‪$typeDefinitions;


    protected ‪$validatorsDefinition;


    protected ‪$finishersDefinition;


    protected ‪$conditionContextDefinition;


    protected ‪$persistenceIdentifier;


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

    {

        $this->objectManager = ‪$objectManager;

    }


    public function ‪__construct(

        string ‪$identifier,

        array $prototypeConfiguration = [],

        string ‪$type = 'Form',

        string ‪$persistenceIdentifier = null

    ) {

        $this->typeDefinitions = $prototypeConfiguration['formElementsDefinition'] ?? [];

        $this->validatorsDefinition = $prototypeConfiguration['validatorsDefinition'] ?? [];

        $this->finishersDefinition = $prototypeConfiguration['finishersDefinition'] ?? [];

        $this->conditionContextDefinition = $prototypeConfiguration['conditionContextDefinition'] ?? [];


        if (!is_string(‪$identifier) || strlen(‪$identifier) === 0) {

            throw new ‪IdentifierNotValidException('The given identifier was not a string or the string was empty.', 1477082503);

        }


        $this->identifier = ‪$identifier;

        $this->type = ‪$type;

        $this->persistenceIdentifier = ‪$persistenceIdentifier;


        if ($prototypeConfiguration !== []) {

            $this->‪initializeFromFormDefaults();

        }

    }


    protected function ‪initializeFromFormDefaults()

    {

        if (!isset($this->typeDefinitions[$this->type])) {

            throw new TypeDefinitionNotFoundException(sprintf('Type "%s" not found. Probably some configuration is missing.', $this->type), 1474905835);

        }

        $typeDefinition = $this->typeDefinitions[‪$this->type];

        $this->‪setOptions($typeDefinition);

    }


    public function ‪setOptions(array $options, bool $resetFinishers = false)

    {

        if (isset($options['rendererClassName'])) {

            $this->‪setRendererClassName($options['rendererClassName']);

        }

        if (isset($options['label'])) {

            $this->‪setLabel($options['label']);

        }

        if (isset($options['renderingOptions'])) {

            foreach ($options['renderingOptions'] as $key => $value) {

                $this->‪setRenderingOption($key, $value);

            }

        }

        if (isset($options['finishers'])) {

            if ($resetFinishers) {

                $this->finishers = [];

            }

            foreach ($options['finishers'] as $finisherConfiguration) {

                $this->‪createFinisher($finisherConfiguration['identifier'], $finisherConfiguration['options'] ?? []);

            }

        }


        if (isset($options['variants'])) {

            foreach ($options['variants'] as $variantConfiguration) {

                $this->‪createVariant($variantConfiguration);

            }

        }


        ‪ArrayUtility::assertAllArrayKeysAreValid(

            $options,

            ['rendererClassName', 'renderingOptions', 'finishers', 'formEditor', 'label', 'variants']

        );

    }


    public function ‪createPage(string ‪$identifier, string $typeName = 'Page'): Page

    {

        if (!isset($this->typeDefinitions[$typeName])) {

            throw new TypeDefinitionNotFoundException(sprintf('Type "%s" not found. Probably some configuration is missing.', $typeName), 1474905953);

        }


        $typeDefinition = $this->typeDefinitions[$typeName];


        if (!isset($typeDefinition['implementationClassName'])) {

            throw new TypeDefinitionNotFoundException(sprintf('The "implementationClassName" was not set in type definition "%s".', $typeName), 1477083126);

        }

        $implementationClassName = $typeDefinition['implementationClassName'];

        $page = $this->objectManager->get($implementationClassName, ‪$identifier, $typeName);


        if (isset($typeDefinition['label'])) {

            $page->setLabel($typeDefinition['label']);

        }


        if (isset($typeDefinition['renderingOptions'])) {

            foreach ($typeDefinition['renderingOptions'] as $key => $value) {

                $page->setRenderingOption($key, $value);

            }

        }


        ‪ArrayUtility::assertAllArrayKeysAreValid(

            $typeDefinition,

            ['implementationClassName', 'label', 'renderingOptions', 'formEditor']

        );


        $this->‪addPage($page);

        return $page;

    }


    public function ‪addPage(‪Page $page)

    {

        $this->‪addRenderable($page);

    }


    public function ‪getPages(): array

    {

        return ‪$this->renderables;

    }


    public function ‪hasPageWithIndex(int ‪$index): bool

    {

        return isset($this->renderables[‪$index]);

    }


    public function ‪getPageByIndex(int ‪$index)

    {

        if (!$this->‪hasPageWithIndex($index)) {

            throw new FormException(sprintf('There is no page with an index of %d', ‪$index), 1329233627);

        }

        return $this->renderables[‪$index];

    }


    public function ‪addFinisher(‪FinisherInterface $finisher)

    {

        $this->finishers[] = $finisher;

    }


    public function ‪createFinisher(string $finisherIdentifier, array $options = []): ‪FinisherInterface

    {

        if (isset($this->finishersDefinition[$finisherIdentifier]) && is_array($this->finishersDefinition[$finisherIdentifier]) && isset($this->finishersDefinition[$finisherIdentifier]['implementationClassName'])) {

            $implementationClassName = $this->finishersDefinition[$finisherIdentifier]['implementationClassName'];

            $defaultOptions = $this->finishersDefinition[$finisherIdentifier]['options'] ?? [];

            ‪ArrayUtility::mergeRecursiveWithOverrule($defaultOptions, $options);


            $finisher = $this->objectManager->get($implementationClassName, $finisherIdentifier);

            $finisher->setOptions($defaultOptions);

            $this->‪addFinisher($finisher);

            return $finisher;

        }

        throw new ‪FinisherPresetNotFoundException('The finisher preset identified by "' . $finisherIdentifier . '" could not be found, or the implementationClassName was not specified.', 1328709784);

    }


    public function ‪getFinishers(): array

    {

        return ‪$this->finishers;

    }


    public function ‪registerRenderable(‪RenderableInterface $renderable)

    {

        if ($renderable instanceof ‪FormElementInterface) {

            if (isset($this->elementsByIdentifier[$renderable->‪getIdentifier()])) {

                throw new ‪DuplicateFormElementException(sprintf('A form element with identifier "%s" is already part of the form.', $renderable->‪getIdentifier()), 1325663761);

            }

            $this->elementsByIdentifier[$renderable->‪getIdentifier()] = $renderable;

        }

    }


    public function ‪unregisterRenderable(RenderableInterface $renderable)

    {

        if ($renderable instanceof FormElementInterface) {

            unset($this->elementsByIdentifier[$renderable->getIdentifier()]);

        }

    }


    public function ‪getElementByIdentifier(string $elementIdentifier)

    {

        return $this->elementsByIdentifier[$elementIdentifier] ?? null;

    }


    public function ‪addElementDefaultValue(string $elementIdentifier, $defaultValue)

    {

        $this->elementDefaultValues = ‪ArrayUtility::setValueByPath(

            $this->elementDefaultValues,

            $elementIdentifier,

            $defaultValue,

            '.'

        );

    }


    public function ‪getElementDefaultValueByIdentifier(string $elementIdentifier)

    {

        return ‪ObjectAccess::getPropertyPath($this->elementDefaultValues, $elementIdentifier);

    }


    public function ‪movePageBefore(‪Page $pageToMove, ‪Page $referencePage)

    {

        $this->‪moveRenderableBefore($pageToMove, $referencePage);

    }


    public function ‪movePageAfter(‪Page $pageToMove, ‪Page $referencePage)

    {

        $this->‪moveRenderableAfter($pageToMove, $referencePage);

    }


    public function ‪removePage(Page $pageToRemove)

    {

        $this->‪removeRenderable($pageToRemove);

    }


    public function ‪bind(‪Request $request, ‪Response $response): ‪FormRuntime

    {

        return $this->objectManager->get(FormRuntime::class, $this, $request, $response);

    }


    public function ‪getProcessingRule(string $propertyPath): ProcessingRule

    {

        if (!isset($this->processingRules[$propertyPath])) {

            $this->processingRules[$propertyPath] = $this->objectManager->get(ProcessingRule::class);

        }

        return $this->processingRules[$propertyPath];

    }


    public function ‪getProcessingRules(): array

    {

        return ‪$this->processingRules;

    }


    public function ‪getTypeDefinitions(): array

    {

        return ‪$this->typeDefinitions;

    }


    public function ‪getValidatorsDefinition(): array

    {

        return ‪$this->validatorsDefinition;

    }


    public function ‪getConditionContextDefinition(): array

    {

        return ‪$this->conditionContextDefinition;

    }


    public function ‪getPersistenceIdentifier(): string

    {

        return ‪$this->persistenceIdentifier;

    }


    public function ‪setRendererClassName(string ‪$rendererClassName)

    {

        $this->rendererClassName = ‪$rendererClassName;

    }


    public function ‪getRendererClassName(): string

    {

        return ‪$this->rendererClassName;

    }

}