AbstractFormFieldViewHelper.php

Go to the documentation of this file.

<?php

namespace TYPO3\CMS\Fluid\ViewHelpers\Form;

/*                                                                        *
 * This script is backported from the TYPO3 Flow package "TYPO3.Fluid".   *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 *  of the License, or (at your option) any later version.                *
 *                                                                        *
 *                                                                        *
 * This script is distributed in the hope that it will be useful, but     *
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-    *
 * TABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser       *
 * General Public License for more details.                               *
 *                                                                        *
 * You should have received a copy of the GNU Lesser General Public       *
 * License along with the script.                                         *
 * If not, see http://www.gnu.org/licenses/lgpl.html                      *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Reflection\ObjectAccess;

abstract class AbstractFormFieldViewHelper extends AbstractFormViewHelper
{
    protected $configurationManager;

    protected $respectSubmittedDataValue = false;

    public function initializeArguments()
    {
        parent::initializeArguments();
        $this->registerArgument('name', 'string', 'Name of input tag');
        $this->registerArgument('value', 'mixed', 'Value of input tag');
        $this->registerArgument(
            'property', 'string',
            'Name of Object Property. If used in conjunction with <f:form object="...">, "name" and "value" properties will be ignored.'
        );
    }

    public function getRespectSubmittedDataValue()
    {
        return $this->respectSubmittedDataValue;
    }

    public function setRespectSubmittedDataValue($respectSubmittedDataValue)
    {
        $this->respectSubmittedDataValue = $respectSubmittedDataValue;
    }

    protected function getName()
    {
        $name = $this->getNameWithoutPrefix();
        return $this->prefixFieldName($name);
    }

    protected function getRequest()
    {
        return $this->controllerContext->getRequest();
    }

    protected function getNameWithoutPrefix()
    {
        if ($this->isObjectAccessorMode()) {
            $formObjectName = $this->viewHelperVariableContainer->get(
                \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObjectName'
            );
            if (!empty($formObjectName)) {
                $propertySegments = explode('.', $this->arguments['property']);
                $propertyPath = '';
                foreach ($propertySegments as $segment) {
                    $propertyPath .= '[' . $segment . ']';
                }
                $name = $formObjectName . $propertyPath;
            } else {
                $name = $this->arguments['property'];
            }
        } else {
            $name = $this->arguments['name'];
        }
        if ($this->hasArgument('value') && is_object($this->arguments['value'])) {
            // @todo Use  $this->persistenceManager->isNewObject() once it is implemented
            if (null !== $this->persistenceManager->getIdentifierByObject($this->arguments['value'])) {
                $name .= '[__identity]';
            }
        }
        return $name;
    }

    protected function getValue($convertObjects = true)
    {
        $value = null;
        GeneralUtility::logDeprecatedFunction();

        if ($this->hasArgument('value')) {
            $value = $this->arguments['value'];
        } elseif ($this->isObjectAccessorMode()) {
            if ($this->hasMappingErrorOccurred()) {
                $value = $this->getLastSubmittedFormData();
            } else {
                $value = $this->getPropertyValue();
            }
            $this->addAdditionalIdentityPropertiesIfNeeded();
        }

        if ($convertObjects) {
            $value = $this->convertToPlainValue($value);
        }
        return $value;
    }

    protected function getValueAttribute()
    {
        $value = null;

        if ($this->respectSubmittedDataValue) {
            $value = $this->getValueFromSubmittedFormData($value);
        } elseif ($this->hasArgument('value')) {
            $value = $this->arguments['value'];
        } elseif ($this->isObjectAccessorMode()) {
            $value = $this->getPropertyValue();
        }

        $value = $this->convertToPlainValue($value);
        return $value;
    }

    protected function getValueFromSubmittedFormData($value)
    {
        $submittedFormData = null;
        if ($this->hasMappingErrorOccurred()) {
            $submittedFormData = $this->getLastSubmittedFormData();
        }
        if ($submittedFormData !== null) {
            $value = $submittedFormData;
        } elseif ($this->hasArgument('value')) {
            $value = $this->arguments['value'];
        } elseif ($this->isObjectAccessorMode()) {
            $value = $this->getPropertyValue();
        }

        return $value;
    }

    protected function convertToPlainValue($value)
    {
        if (is_object($value)) {
            $identifier = $this->persistenceManager->getIdentifierByObject($value);
            if ($identifier !== null) {
                $value = $identifier;
            }
        }
        return $value;
    }

    protected function hasMappingErrorOccurred()
    {
        return $this->getRequest()->getOriginalRequest() !== null;
    }

    protected function getLastSubmittedFormData()
    {
        $propertyPath = rtrim(preg_replace('/(\\]\\[|\\[|\\])/', '.', $this->getNameWithoutPrefix()), '.');
        $value = ObjectAccess::getPropertyPath(
            $this->controllerContext->getRequest()->getOriginalRequest()->getArguments(), $propertyPath
        );
        return $value;
    }

    protected function addAdditionalIdentityPropertiesIfNeeded()
    {
        if (!$this->isObjectAccessorMode()) {
            return;
        }

        if (!$this->viewHelperVariableContainer->exists(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObject'
        )
        ) {
            return;
        }
        $propertySegments = explode('.', $this->arguments['property']);
        // hierarchical property. If there is no "." inside (thus $propertySegments == 1), we do not need to do anything
        if (count($propertySegments) < 2) {
            return;
        }
        $formObject = $this->viewHelperVariableContainer->get(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObject'
        );
        $objectName = $this->viewHelperVariableContainer->get(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObjectName'
        );
        // If count == 2 -> we need to go through the for-loop exactly once
        for ($i = 1; $i < count($propertySegments); $i++) {
            $object = ObjectAccess::getPropertyPath($formObject, implode('.', array_slice($propertySegments, 0, $i)));
            $objectName .= '[' . $propertySegments[($i - 1)] . ']';
            $hiddenIdentityField = $this->renderHiddenIdentityField($object, $objectName);
            // Add the hidden identity field to the ViewHelperVariableContainer
            $additionalIdentityProperties = $this->viewHelperVariableContainer->get(
                \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'additionalIdentityProperties'
            );
            $additionalIdentityProperties[$objectName] = $hiddenIdentityField;
            $this->viewHelperVariableContainer->addOrUpdate(
                \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'additionalIdentityProperties',
                $additionalIdentityProperties
            );
        }
    }

    protected function getPropertyValue()
    {
        if (!$this->viewHelperVariableContainer->exists(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObject'
        )
        ) {
            return null;
        }
        $formObject = $this->viewHelperVariableContainer->get(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObject'
        );
        $propertyName = $this->arguments['property'];
        if (is_array($formObject)) {
            return isset($formObject[$propertyName]) ? $formObject[$propertyName] : null;
        }
        return ObjectAccess::getPropertyPath($formObject, $propertyName);
    }

    protected function isObjectAccessorMode()
    {
        return $this->hasArgument('property') && $this->viewHelperVariableContainer->exists(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObjectName'
        );
    }

    protected function setErrorClassAttribute()
    {
        if ($this->hasArgument('class')) {
            $cssClass = $this->arguments['class'] . ' ';
        } else {
            $cssClass = '';
        }

        $mappingResultsForProperty = $this->getMappingResultsForProperty();
        if ($mappingResultsForProperty->hasErrors()) {
            if ($this->hasArgument('errorClass')) {
                $cssClass .= $this->arguments['errorClass'];
            } else {
                $cssClass .= 'error';
            }
            $this->tag->addAttribute('class', $cssClass);
        }
    }

    protected function getMappingResultsForProperty()
    {
        if (!$this->isObjectAccessorMode()) {
            return new \TYPO3\CMS\Extbase\Error\Result();
        }
        $originalRequestMappingResults = $this->getRequest()->getOriginalRequestMappingResults();
        $formObjectName = $this->viewHelperVariableContainer->get(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'formObjectName'
        );
        return $originalRequestMappingResults->forProperty($formObjectName)->forProperty($this->arguments['property']);
    }

    protected function renderHiddenFieldForEmptyValue()
    {
        $hiddenFieldNames = [];
        if ($this->viewHelperVariableContainer->exists(
            \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'renderedHiddenFields'
        )
        ) {
            $hiddenFieldNames = $this->viewHelperVariableContainer->get(
                \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'renderedHiddenFields'
            );
        }
        $fieldName = $this->getName();
        if (substr($fieldName, -2) === '[]') {
            $fieldName = substr($fieldName, 0, -2);
        }
        if (!in_array($fieldName, $hiddenFieldNames)) {
            $hiddenFieldNames[] = $fieldName;
            $this->viewHelperVariableContainer->addOrUpdate(
                \TYPO3\CMS\Fluid\ViewHelpers\FormViewHelper::class, 'renderedHiddenFields', $hiddenFieldNames
            );
            return '<input type="hidden" name="' . htmlspecialchars($fieldName) . '" value="" />';
        }
        return '';
    }
}