FormBuilder.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Form\Domain\Builder;

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

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\TypoScript\TemplateService;
use TYPO3\CMS\Form\Domain\Model\Element;
use TYPO3\CMS\Form\Domain\Model\ValidationElement;
use TYPO3\CMS\Form\Utility\CompatibilityLayerUtility;
use TYPO3\CMS\Form\Utility\FormUtility;
use TYPO3\CMS\Form\Mvc\Controller\ControllerContext;
use TYPO3\CMS\Form\Domain\Model\Configuration;

class FormBuilder
{
    const COMPATIBILITY_THEME_NAME = 'Compatibility';

    public static function create(Configuration $configuration)
    {
        $formBuilder = \TYPO3\CMS\Form\Utility\FormUtility::getObjectManager()->get(FormBuilder::class);
        $formBuilder->setConfiguration($configuration);
        return $formBuilder;
    }

    protected $formUtility;

    protected $typoScriptService;

    protected $compatibilityService;

    protected $validationBuilder;

    protected $typoScriptRepository;

    protected $signalSlotDispatcher;

    protected $sessionUtility;

    protected $objectManager;

    protected $elementCounter;

    protected $validationErrors = null;

    protected $configuration;

    protected $controllerContext;

    public function injectTypoScriptService(\TYPO3\CMS\Extbase\Service\TypoScriptService $typoScriptService)
    {
        $this->typoScriptService = $typoScriptService;
    }

    public function injectTypoScriptRepository(\TYPO3\CMS\Form\Domain\Repository\TypoScriptRepository $typoScriptRepository)
    {
        $this->typoScriptRepository = $typoScriptRepository;
    }

    public function injectSignalSlotDispatcher(\TYPO3\CMS\Extbase\SignalSlot\Dispatcher $signalSlotDispatcher)
    {
        $this->signalSlotDispatcher = $signalSlotDispatcher;
    }

    public function injectSessionUtility(\TYPO3\CMS\Form\Utility\SessionUtility $sessionUtility)
    {
        $this->sessionUtility = $sessionUtility;
    }

    public function injectElementCounter(\TYPO3\CMS\Form\Utility\ElementCounter $elementCounter)
    {
        $this->elementCounter = $elementCounter;
    }

    public function injectObjectManager(\TYPO3\CMS\Extbase\Object\ObjectManager $objectManager)
    {
        $this->objectManager = $objectManager;
    }

    public function __construct()
    {
        $this->compatibilityService = CompatibilityLayerUtility::create($this);
    }

    public function getConfiguration()
    {
        return $this->configuration;
    }

    public function setConfiguration(Configuration $configuration)
    {
        $this->configuration = $configuration;
    }

    public function getControllerContext()
    {
        return $this->controllerContext;
    }

    public function setControllerContext(ControllerContext $controllerContext)
    {
        $this->controllerContext = $controllerContext;
    }

    public function getCompatibilityService()
    {
        return $this->compatibilityService;
    }

    public function setCompatibilityService(CompatibilityLayerUtility $compatibilityService)
    {
        $this->compatibilityService = $compatibilityService;
    }

    public function getFormUtility()
    {
        return $this->formUtility;
    }

    public function setFormUtility(FormUtility $formUtility)
    {
        $this->formUtility = $formUtility;
    }

    public function getValidationBuilder()
    {
        return $this->validationBuilder;
    }

    public function setValidationBuilder(ValidationBuilder $validationBuilder)
    {
        $this->validationBuilder = $validationBuilder;
    }

    public function buildModel()
    {
        $userConfiguredFormTypoScript = $this->configuration->getTypoScript();

        if ($this->configuration->getCompatibility()) {
            $layout = array();
            if (isset($userConfiguredFormTypoScript['layout.'])) {
                $layout = $userConfiguredFormTypoScript['layout.'];
                /* use the compatibility theme whenever if a layout is defined */
                $this->configuration->setThemeName(static::COMPATIBILITY_THEME_NAME);
                unset($userConfiguredFormTypoScript['layout.']);
            }

            switch ($this->getControllerAction()) {
                case 'show':
                    $actionLayoutKey = 'form.';
                    break;
                case 'confirmation':
                    $actionLayoutKey = 'confirmation.';
                    break;
                case 'process':
                    $actionLayoutKey = 'postProcessor.';
                    break;
                default:
                    $actionLayoutKey = '';
                    break;
            }
            if ($actionLayoutKey && isset($userConfiguredFormTypoScript[$actionLayoutKey]['layout.'])) {
                $actionLayout = $userConfiguredFormTypoScript[$actionLayoutKey]['layout.'];
                $this->configuration->setThemeName(static::COMPATIBILITY_THEME_NAME);
                unset($userConfiguredFormTypoScript[$actionLayoutKey]['layout.']);
                $layout = array_replace_recursive($layout, $actionLayout);
            }

            if (!empty($layout)) {
                $this->compatibilityService->setGlobalLayoutConfiguration($layout);
            }
        }

        $form = $this->createElementObject();
        $this->reviveElement($form, $userConfiguredFormTypoScript, 'FORM');
        $form->setThemeName($this->configuration->getThemeName());
        return $form;
    }

    protected function createElementObject()
    {
        $element = GeneralUtility::makeInstance(Element::class);
        return $element;
    }

    protected function reviveElement(Element $element, array $userConfiguredElementTypoScript, $elementType = '')
    {
        // @todo Check $userConfiguredElementTypoScript

        if ($elementType === 'IMAGEBUTTON') {
            GeneralUtility::deprecationLog('EXT:form: The element IMAGEBUTTON is deprecated since TYPO3 CMS 7, will be removed with TYPO3 CMS 8.');
        }

        $element->setElementType($elementType);
        $element->setElementCounter($this->elementCounter->getElementId());

        $elementBuilder = ElementBuilder::create($this, $element, $userConfiguredElementTypoScript);
        $elementBuilder->setPartialPaths();
        $elementBuilder->setVisibility();

        if ($element->getElementType() == 'CONTENTELEMENT') {
            $attributeValue = '';
            if ($this->configuration->getContentElementRendering()) {
                $attributeValue = $this->formUtility->renderItem(
                    $userConfiguredElementTypoScript['cObj.'],
                    $userConfiguredElementTypoScript['cObj']
                );
            }
            $element->setAdditionalArguments(array(
                'content' => $attributeValue,
            ));
            /* use the compatibility theme whenever if a layout is defined */
            if ($this->configuration->getCompatibility()) {
                $this->compatibilityService->setElementLayouts($element, $userConfiguredElementTypoScript);
                if (isset($userConfiguredElementTypoScript['layout'])) {
                    $this->configuration->setThemeName(static::COMPATIBILITY_THEME_NAME);
                    unset($userConfiguredElementTypoScript['layout']);
                }
            }
        } else {
            $this->setAttributes($elementBuilder, $element, $userConfiguredElementTypoScript);
            $userConfiguredElementTypoScript = $elementBuilder->getUserConfiguredElementTypoScript();
            $this->setValidationMessages($element);
            /* use the compatibility theme whenever if a layout is defined */
            if ($this->configuration->getCompatibility()) {
                $this->compatibilityService->setElementLayouts($element, $userConfiguredElementTypoScript);
                if (isset($userConfiguredElementTypoScript['layout'])) {
                    $this->configuration->setThemeName(static::COMPATIBILITY_THEME_NAME);
                    unset($userConfiguredElementTypoScript['layout']);
                }
            }
            $this->signalSlotDispatcher->dispatch(
                __CLASS__,
                'txFormAfterElementCreation',
                array($element, $this)
            );
                // create all child elements
            $this->setChildElementsByIntegerKey($element, $userConfiguredElementTypoScript);
        }
    }

    protected function setChildElementsByIntegerKey(Element $element, array $userConfiguredElementTypoScript)
    {
        if (is_array($userConfiguredElementTypoScript)) {
            $keys = TemplateService::sortedKeyList($userConfiguredElementTypoScript);
            foreach ($keys as $key) {
                if (
                    (int)$key
                    && strpos($key, '.') === false
                ) {
                    $elementType = $userConfiguredElementTypoScript[$key];
                    if (isset($userConfiguredElementTypoScript[$key . '.'])) {
                        $concreteChildElementTypoScript = $userConfiguredElementTypoScript[$key . '.'];
                    } else {
                        $concreteChildElementTypoScript = array();
                    }
                    $this->distinguishElementType($element, $concreteChildElementTypoScript, $elementType);
                }
            }
        } else {
            throw new \InvalidArgumentException('Container element with id=' . $element->getElementCounter() . ' has no configuration which means no children.', 1333754854);
        }
    }

    protected function distinguishElementType(Element $element, array $userConfiguredElementTypoScript, $elementType = '')
    {
        if (in_array($elementType, $this->typoScriptRepository->getRegisteredElementTypes())) {
            $this->addChildElement($element, $userConfiguredElementTypoScript, $elementType);
        } elseif ($this->configuration->getContentElementRendering()) {
            $contentObject = array(
                'cObj' => $elementType,
                'cObj.' => $userConfiguredElementTypoScript
            );
            $this->addChildElement($element, $contentObject, 'CONTENTELEMENT');
        }
    }

    protected function addChildElement(Element $element, array $userConfiguredElementTypoScript, $elementType = '')
    {
        $childElement = $this->createElementObject();
        $childElement->setParentElement($element);
        $element->addChildElement($childElement);
        $this->reviveElement($childElement, $userConfiguredElementTypoScript, $elementType);
    }

    protected function setAttributes(ElementBuilder $elementBuilder, Element $element)
    {
        $htmlAttributes = $this->typoScriptRepository->getModelDefinedHtmlAttributes($element->getElementType());
        $elementBuilder->setHtmlAttributes($htmlAttributes);
        $elementBuilder->setHtmlAttributeWildcards();
        $elementBuilder->overlayUserdefinedHtmlAttributeValues();
        $elementBuilder->setNameAndId();
        $elementBuilder->overlayFixedHtmlAttributeValues();
        // remove all NULL values
        $htmlAttributes = array_filter($elementBuilder->getHtmlAttributes());

        $elementBuilder->setHtmlAttributes($htmlAttributes);
        $elementBuilder->moveHtmlAttributesToAdditionalArguments();
        $elementBuilder->setViewHelperDefaulArgumentsToAdditionalArguments();
        $elementBuilder->moveAllOtherUserdefinedPropertiesToAdditionalArguments();
        $htmlAttributes = $elementBuilder->getHtmlAttributes();
        $userConfiguredElementTypoScript = $elementBuilder->getUserConfiguredElementTypoScript();
        $additionalArguments = $elementBuilder->getAdditionalArguments();
        $element->setHtmlAttributes($htmlAttributes);
        $additionalArguments = $this->typoScriptService->convertTypoScriptArrayToPlainArray($additionalArguments);
        $additionalArguments['prefix'] = $this->configuration->getPrefix();
        $element->setAdditionalArguments($additionalArguments);
        $this->handleIncomingValues($element, $userConfiguredElementTypoScript);

        if (
            $element->getElementType() === 'FORM'
            && $this->getControllerAction() === 'show'
        ) {
            if (empty($element->getHtmlAttribute('action'))) {
                if (
                    $element->getAdditionalArgument('confirmation')
                    && (int)$element->getAdditionalArgument('confirmation') === 1
                ) {
                    $element->setAdditionalArgument('action', 'confirmation');
                } else {
                    $element->setAdditionalArgument('action', 'process');
                }
            } else {
                $element->setAdditionalArgument('pageUid', $element->getHtmlAttribute('action'));
                $element->setAdditionalArgument('action', null);
            }
        }

        // needed if confirmation page is enabled
        if (
            $this->sessionUtility->getSessionData($element->getName())
            && $element->getAdditionalArgument('uploadedFiles') === null
        ) {
            $element->setAdditionalArgument('uploadedFiles', $this->sessionUtility->getSessionData($element->getName()));
        }
    }

    protected function handleIncomingValues(Element $element, array $userConfiguredElementTypoScript)
    {
        if (!$this->getIncomingData()) {
            return;
        }
        $elementName = $element->getName();
        if ($element->getHtmlAttribute('value') !== null) {
            $modelValue = $element->getHtmlAttribute('value');
        } else {
            $modelValue = $element->getAdditionalArgument('value');
        }

        if ($this->getIncomingData()->getIncomingField($elementName) !== null) {
            /* filter values and set it back to incoming fields */
                /* remove xss every time */
            $userConfiguredElementTypoScript['filters.'][-1] = 'removexss';
            $keys = TemplateService::sortedKeyList($userConfiguredElementTypoScript['filters.']);
            foreach ($keys as $key) {
                $class = $userConfiguredElementTypoScript['filters.'][$key];
                if (
                    (int)$key
                    && strpos($key, '.') === false
                ) {
                    $filterArguments = $userConfiguredElementTypoScript['filters.'][$key . '.'];
                    $filterClassName = $this->typoScriptRepository->getRegisteredClassName((string)$class, 'registeredFilters');
                    if ($filterClassName !== null) {
                        // toDo: handel array values
                        if (is_string($this->getIncomingData()->getIncomingField($elementName))) {
                            if (is_null($filterArguments)) {
                                $filter = $this->objectManager->get($filterClassName);
                            } else {
                                $filter = $this->objectManager->get($filterClassName, $filterArguments);
                            }
                            if ($filter) {
                                $value = $filter->filter($this->getIncomingData()->getIncomingField($elementName));
                                $this->getIncomingData()->setIncomingField($elementName, $value);
                            } else {
                                throw new \RuntimeException('Class "' . $filterClassName . '" could not be loaded.');
                            }
                        }
                    } else {
                        throw new \RuntimeException('Class "' . $filterClassName . '" not registered via TypoScript.');
                    }
                }
            }

            if ($element->getHtmlAttribute('value') !== null) {
                $element->setHtmlAttribute('value', $this->getIncomingData()->getIncomingField($elementName));
            } else {
                $element->setAdditionalArgument('value', $this->getIncomingData()->getIncomingField($elementName));
            }
        }
        $this->signalSlotDispatcher->dispatch(
            __CLASS__,
            'txFormHandleIncomingValues',
            array(
                $element,
                $this->getIncomingData(),
                $modelValue,
                $this
            )
        );
    }

    protected function setValidationMessages(Element $element)
    {
        $elementName = $element->getName();
        $mandatoryMessages = $this->validationBuilder->getMandatoryValidationMessagesByElementName($elementName);
        $element->setMandatoryValidationMessages($mandatoryMessages);
        if (
            $this->getValidationErrors()
            && $this->getValidationErrors()->forProperty($elementName)->hasErrors()
        ) {
            $errors = $this->getValidationErrors()->forProperty($elementName)->getErrors();
            $errorMessages = array();
            foreach ($errors as $error) {
                $errorMessages[] = $error->getMessage();
            }
            $element->setValidationErrorMessages($errorMessages);
        }
    }

    public function getFormPrefix()
    {
        return $this->configuration->getPrefix();
    }

    public function getDisableContentElementRendering()
    {
        return !$this->configuration->getContentElementRendering();
    }

    public function getControllerAction()
    {
        return $this->controllerContext->getRequest()->getControllerActionName();
    }

    public function getCompatibilityMode()
    {
        return $this->configuration->getCompatibility();
    }

    public function getIncomingData()
    {
        return $this->controllerContext->getValidationElement();
    }

    public function setValidationErrors(\TYPO3\CMS\Extbase\Error\Result $validationErrors)
    {
        $this->validationErrors = $validationErrors;
    }

    public function getValidationErrors()
    {
        return $this->validationErrors;
    }
}