FormDefinition.php

Go to the documentation of this file.

<?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;
    }
}