Builder.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Validator;

use Magento\Framework\Validator\Constraint\OptionInterface;

class Builder
{
    protected $_constraints;

    protected $_constraintFactory;

    protected $_validatorFactory;

    protected $_oneValidatorFactory;

    public function __construct(
        \Magento\Framework\Validator\ConstraintFactory $constraintFactory,
        \Magento\Framework\ValidatorFactory $validatorFactory,
        \Magento\Framework\Validator\UniversalFactory $oneValidatorFactory,
        array $constraints
    ) {
        foreach ($constraints as $constraint) {
            if (isset($constraint['options']) && is_array($constraint['options'])) {
                $this->_checkConfigurationArguments($constraint['options'], true);
                $this->_checkConfigurationCallback($constraint['options'], true);
            }
        }
        $this->_constraints = $constraints;
        $this->_constraintFactory = $constraintFactory;
        $this->_validatorFactory = $validatorFactory;
        $this->_oneValidatorFactory = $oneValidatorFactory;
    }

    protected function _checkConfigurationArguments(array $configuration, $argumentsIsArray)
    {
        // https://jira.corp.x.com/browse/MAGETWO-10439
        $allowedKeys = ['arguments', 'callback', 'method', 'methods', 'breakChainOnFailure'];
        if (!array_intersect($allowedKeys, array_keys($configuration))) {
            throw new \InvalidArgumentException('Configuration has incorrect format');
        }
        // Check method arguments
        if ($argumentsIsArray) {
            if (array_key_exists('methods', $configuration)) {
                foreach ($configuration['methods'] as $method) {
                    $this->_checkMethodArguments($method);
                }
            }
        } elseif (array_key_exists('method', $configuration)) {
            $this->_checkMethodArguments($configuration);
        }

        // Check constructor arguments
        if (array_key_exists('arguments', $configuration) && !is_array($configuration['arguments'])) {
            throw new \InvalidArgumentException('Arguments must be an array');
        }
    }

    protected function _checkMethodArguments(array $configuration)
    {
        if (!is_string($configuration['method'])) {
            throw new \InvalidArgumentException('Method has to be passed as string');
        }
        if (array_key_exists('arguments', $configuration) && !is_array($configuration['arguments'])) {
            throw new \InvalidArgumentException('Method arguments must be an array');
        }
    }

    protected function _checkConfigurationCallback(array $configuration, $callbackIsArray)
    {
        if (array_key_exists('callback', $configuration)) {
            if ($callbackIsArray) {
                $callbacks = $configuration['callback'];
            } else {
                $callbacks = [$configuration['callback']];
            }
            foreach ($callbacks as $callback) {
                if (!$callback instanceof \Magento\Framework\Validator\Constraint\Option\Callback) {
                    throw new \InvalidArgumentException(
                        'Callback must be instance of \Magento\Framework\Validator\Constraint\Option\Callback'
                    );
                }
            }
        }
    }

    public function createValidator()
    {
        return $this->_createValidatorInstance();
    }

    protected function _createValidatorInstance()
    {
        $validator = $this->_validatorFactory->create();
        foreach ($this->_constraints as $constraintData) {
            // https://jira.corp.x.com/browse/MAGETWO-10439
            $breakChainOnFailure = !empty($constraintData['options']['breakChainOnFailure']);
            $validator->addValidator($this->_createConstraint($constraintData), $breakChainOnFailure);
        }
        return $validator;
    }

    public function addConfiguration($alias, array $configuration)
    {
        $this->_checkConfigurationArguments($configuration, false);
        $this->_checkConfigurationCallback($configuration, false);
        foreach ($this->_constraints as &$constraint) {
            if ($constraint['alias'] != $alias) {
                continue;
            }
            if (!array_key_exists('options', $constraint) || !is_array($constraint['options'])) {
                $constraint['options'] = [];
            }
            if (!array_key_exists('method', $configuration)) {
                if (array_key_exists('arguments', $configuration)) {
                    $constraint['options']['arguments'] = $configuration['arguments'];
                } elseif (array_key_exists('callback', $configuration)) {
                    $constraint = $this->_addConstraintCallback($constraint, $configuration['callback']);
                }
            } else {
                $constraint = $this->_addConstraintMethod($constraint, $configuration);
            }
        }

        return $this;
    }

    protected function _addConstraintCallback(
        array $constraint,
        \Magento\Framework\Validator\Constraint\Option\Callback $callback
    ) {
        if (!array_key_exists('callback', $constraint['options'])) {
            $constraint['options']['callback'] = [];
        }
        $constraint['options']['callback'][] = $callback;
        return $constraint;
    }

    protected function _addConstraintMethod(array $constraint, array $configuration)
    {
        if (!array_key_exists('methods', $constraint['options'])) {
            $constraint['options']['methods'] = [];
        }
        $constraint['options']['methods'][] = $configuration;
        return $constraint;
    }

    public function addConfigurations(array $configurations)
    {
        foreach ($configurations as $alias => $concreteConfigs) {
            foreach ($concreteConfigs as $configuration) {
                $this->addConfiguration($alias, $configuration);
            }
        }
        return $this;
    }

    protected function _createConstraint(array $data)
    {
        // Create validator instance
        $validator = $this->_createConstraintValidator($data);
        if (isset($data['options']) && is_array($data['options'])) {
            $this->_configureConstraintValidator($validator, $data['options']);
        }

        if (\Magento\Framework\Validator\Config::CONSTRAINT_TYPE_PROPERTY == $data['type']) {
            $result = new \Magento\Framework\Validator\Constraint\Property(
                $validator,
                $data['property'],
                $data['alias']
            );
        } else {
            $result = $this->_constraintFactory->create(['validator' => $validator, 'alias' => $data['alias']]);
        }

        return $result;
    }

    protected function _createConstraintValidator(array $data)
    {
        $validator = $this->_oneValidatorFactory->create(
            $data['class'],
            isset(
                $data['options']['arguments']
            ) ? $this->_applyArgumentsCallback(
                $data['options']['arguments']
            ) : []
        );

        // Check validator type
        if (!$validator instanceof \Magento\Framework\Validator\ValidatorInterface) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Constraint class "%s" must implement \Magento\Framework\Validator\ValidatorInterface',
                    $data['class']
                )
            );
        }

        return $validator;
    }

    protected function _configureConstraintValidator(
        \Magento\Framework\Validator\ValidatorInterface $validator,
        array $options
    ) {
        // Call all validator methods according to configuration
        if (isset($options['methods'])) {
            foreach ($options['methods'] as $methodData) {
                $methodName = $methodData['method'];
                if (method_exists($validator, $methodName)) {
                    if (array_key_exists('arguments', $methodData)) {
                        $arguments = $this->_applyArgumentsCallback($methodData['arguments']);
                        call_user_func_array([$validator, $methodName], $arguments);
                    } else {
                        call_user_func([$validator, $methodName]);
                    }
                }
            }
        }

        // Call validator configurators if any
        if (isset($options['callback'])) {
            foreach ($options['callback'] as $callback) {
                $callback->setArguments($validator);
                $callback->getValue();
            }
        }
    }

    protected function _applyArgumentsCallback(array $arguments)
    {
        foreach ($arguments as &$argument) {
            if (is_array($argument)) {
                $argument = $this->_applyArgumentsCallback($argument);
            } elseif ($argument instanceof OptionInterface) {
                $argument = $argument->getValue();
            }
        }
        return $arguments;
    }
}