ValidationBuilder.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\TypoScript\TemplateService;
use TYPO3\CMS\Form\Domain\Model\Configuration;
use TYPO3\CMS\Form\Domain\Validator\AbstractValidator;
use TYPO3\CMS\Form\Utility\FormUtility;

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

    protected $rules = array();

    protected $formPrefix = '';

    protected $objectManager;

    protected $typoScriptRepository;

    protected $formUtility;

    protected $configuration;

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

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

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

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

    public function buildRules(array $rawArgument = array())
    {
        $userConfiguredFormTyposcript = $this->configuration->getTypoScript();
        $rulesTyposcript = isset($userConfiguredFormTyposcript['rules.']) ? $userConfiguredFormTyposcript['rules.'] : null;
        $this->rules[$this->configuration->getPrefix()] = array();
        if (is_array($rulesTyposcript)) {
            $keys = TemplateService::sortedKeyList($rulesTyposcript);
            foreach ($keys as $key) {
                $ruleName = $rulesTyposcript[$key];
                $validatorClassName = $this->typoScriptRepository->getRegisteredClassName($ruleName, 'registeredValidators');
                if ($validatorClassName === null) {
                    throw new \RuntimeException('Class "' . $validatorClassName . '" not registered via typoscript.');
                }
                if (
                    (int)$key
                    && strpos($key, '.') === false
                ) {
                    $ruleArguments = $rulesTyposcript[$key . '.'];
                    $fieldName = $this->formUtility->sanitizeNameAttribute($ruleArguments['element']);
                        // remove unsupported validator options
                    $validatorOptions = $ruleArguments;
                    $validatorOptions['errorMessage'] = array($ruleArguments['error.'], $ruleArguments['error']);
                    $keysToRemove = array_flip(array(
                        'breakOnError',
                        'message',
                        'message.',
                        'error',
                        'error.',
                        'showMessage',
                    ));
                    $validatorOptions = array_diff_key($validatorOptions, $keysToRemove);

                    // Instantiate the validator to check if all required options are assigned
                    // and to use the validator message rendering function to pre-render the mandatory message
                    $validator = $this->objectManager->get($validatorClassName, $validatorOptions);

                    if ($validator instanceof AbstractValidator) {
                        $validator->setRawArgument($rawArgument);
                        $validator->setFormUtility($this->formUtility);
                        $mandatoryMessage = $validator->renderMessage($ruleArguments['message.'], $ruleArguments['message']);

                        $this->rules[$this->configuration->getPrefix()][$fieldName][] = array(
                            'validator' => $validator,
                            'validatorName' => $validatorClassName,
                            'validatorOptions' => $validatorOptions,
                            'mandatoryMessage' => $mandatoryMessage
                        );
                    } else {
                        throw new \RuntimeException('Class "' . $validatorClassName . '" could not be loaded.');
                    }
                }
            }
        }
    }

    public function setRules(array $rules)
    {
        $this->rules = $rules[$this->configuration->getPrefix()];
    }

    public function getRules()
    {
        return $this->rules[$this->configuration->getPrefix()];
    }

    public function setRulesByElementName($key = '', array $rule = array())
    {
        $this->rules[$this->configuration->getPrefix()][$key] = $rule;
    }

    public function getRulesByElementName($key = '')
    {
        if (isset($this->rules[$this->configuration->getPrefix()][$key])) {
            return $this->rules[$this->configuration->getPrefix()][$key];
        }
        return null;
    }

    public function removeRule($key = '')
    {
        unset($this->rules[$this->configuration->getPrefix()][$key]);
    }

    public function getMandatoryValidationMessagesByElementName($key = '')
    {
        $mandatoryMessages = array();
        if ($this->getRulesByElementName($key)) {
            $rules = $this->getRulesByElementName($key);
            foreach ($rules as $rule) {
                $mandatoryMessages[] = $rule['mandatoryMessage'];
            }
        }
        return $mandatoryMessages;
    }
}