FormDefinition.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\Model;
 
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Mvc\Request;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\Reflection\ObjectAccess;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
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 ‪$renderables = [];
 
    protected $finishers = [];
 
    protected $processingRules = [];
 
    protected $elementsByIdentifier = [];
 
    protected $elementDefaultValues = [];
 
    protected $rendererClassName = '';
 
    protected $typeDefinitions;
 
    protected $validatorsDefinition;
 
    protected $finishersDefinition;
 
    protected $persistenceIdentifier;
 
    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'] ?? [];
 
        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 = (string)$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'];
 
        $classSchema = GeneralUtility::makeInstance(ReflectionService::class)->getClassSchema($implementationClassName);
        if ($classSchema->hasInjectMethods() || $classSchema->hasInjectProperties() || $classSchema->hasMethod('initializeObject')) {
            // @deprecated since v11, will be removed in v12 - Fallback for Page implementations that have
            // inject* or initializeObject methods, since Page prototype needs manual constructor arguments
            // which can't be mixed with injection in symfony DI. Deprecation is logged by ObjectManager->get().
            // Drop everything except the makeInstance call below in v12.
            $objectManager = GeneralUtility::makeInstance(ObjectManager::class);
            $page = $objectManager->get($implementationClassName, ‪$identifier, $typeName);
        } else {
            $page = GeneralUtility::makeInstance($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);
            }
        }
 
        if (isset($typeDefinition['variants'])) {
            foreach ($typeDefinition['variants'] as $variantConfiguration) {
                $page->createVariant($variantConfiguration);
            }
        }
 
        ‪ArrayUtility::assertAllArrayKeysAreValid(
            $typeDefinition,
            ['implementationClassName', 'label', 'renderingOptions', 'formEditor', 'variants']
        );
 
        $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);
 
            $classSchema = GeneralUtility::makeInstance(ReflectionService::class)->getClassSchema($implementationClassName);
            if (!$classSchema->hasMethod('setFinisherIdentifier')
                || ($classSchema->hasMethod('__construct')
                    && count($classSchema->getMethod('__construct')->getParameters()) >= 1
                    && (string)$classSchema->getMethod('__construct')->getFirstParameter()->getType() === 'string')
            ) {
                // @deprecated since v11, will be removed in v12 - Fallback for Finishers that do not
                // extend AbstractFinisher and have no setFinisherIdentifier() method or still have a
                // constructor argument to set the finisher name: Mixing manual constructor arguments
                // with injection is not allowed by symfony DI, so we dropped the constructor argument
                // for v11 to keep the injection.
                // The above if detects "old" finisher and falls back to ObjectManager, which will log
                // a deprecation.
                // Drop the if with this body in v12, keep else body, clean up
                // AbstractFinisher->setFinisherIdentifier() and enable the method in FinisherInterface.
                $objectManager = GeneralUtility::makeInstance(ObjectManager::class);
                $finisher = $objectManager->get($implementationClassName, $finisherIdentifier);
                if ($classSchema->hasMethod('setFinisherIdentifier')) {
                    $finisher->setFinisherIdentifier($finisherIdentifier);
                }
            } else {
                $finisher = GeneralUtility::makeInstance($implementationClassName);
                $finisher->setFinisherIdentifier($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 getElements(): array
    {
        return $this->elementsByIdentifier;
    }
 
    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): ‪FormRuntime
    {
        $formRuntime = GeneralUtility::makeInstance(FormRuntime::class);
        $formRuntime->setFormDefinition($this);
        $formRuntime->setRequest($request);
        $formRuntime->initialize();
        return $formRuntime;
    }
 
    public function ‪getProcessingRule(string $propertyPath): ‪ProcessingRule
    {
        if (!isset($this->‪processingRules[$propertyPath])) {
            $this->‪processingRules[$propertyPath] = GeneralUtility::makeInstance(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 ‪getPersistenceIdentifier(): string
    {
        return $this->persistenceIdentifier;
    }
 
    public function ‪setRendererClassName(string $rendererClassName)
    {
        $this->rendererClassName = $rendererClassName;
    }
 
    public function ‪getRendererClassName(): string
    {
        return $this->rendererClassName;
    }
}