Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Validation;

use BadMethodCallException;

use Illuminate\Contracts\Container\Container;

use Illuminate\Contracts\Translation\Translator;

use Illuminate\Contracts\Validation\DataAwareRule;

use Illuminate\Contracts\Validation\ImplicitRule;

use Illuminate\Contracts\Validation\Rule as RuleContract;

use Illuminate\Contracts\Validation\Validator as ValidatorContract;

use Illuminate\Contracts\Validation\ValidatorAwareRule;

use Illuminate\Support\Arr;

use Illuminate\Support\Fluent;

use Illuminate\Support\MessageBag;

use Illuminate\Support\Str;

use Illuminate\Support\ValidatedInput;

use InvalidArgumentException;

use RuntimeException;

use stdClass;

use Symfony\Component\HttpFoundation\File\UploadedFile;

class Validator implements ValidatorContract

{

    use Concerns\FormatsMessages,

        Concerns\ValidatesAttributes;

    /**

     * The Translator implementation.

     *

     * @var \Illuminate\Contracts\Translation\Translator

     */

    protected $translator;

    /**

     * The container instance.

     *

     * @var \Illuminate\Contracts\Container\Container

     */

    protected $container;

    /**

     * The Presence Verifier implementation.

     *

     * @var \Illuminate\Validation\PresenceVerifierInterface

     */

    protected $presenceVerifier;

    /**

     * The failed validation rules.

     *

     * @var array

     */

    protected $failedRules = [];

    /**

     * Attributes that should be excluded from the validated data.

     *

     * @var array

     */

    protected $excludeAttributes = [];

    /**

     * The message bag instance.

     *

     * @var \Illuminate\Support\MessageBag

     */

    protected $messages;

    /**

     * The data under validation.

     *

     * @var array

     */

    protected $data;

    /**

     * The initial rules provided.

     *

     * @var array

     */

    protected $initialRules;

    /**

     * The rules to be applied to the data.

     *

     * @var array

     */

    protected $rules;

    /**

     * The current rule that is validating.

     *

     * @var string

     */

    protected $currentRule;

    /**

     * The array of wildcard attributes with their asterisks expanded.

     *

     * @var array

     */

    protected $implicitAttributes = [];

    /**

     * The callback that should be used to format the attribute.

     *

     * @var callable|null

     */

    protected $implicitAttributesFormatter;

    /**

     * The cached data for the "distinct" rule.

     *

     * @var array

     */

    protected $distinctValues = [];

    /**

     * All of the registered "after" callbacks.

     *

     * @var array

     */

    protected $after = [];

    /**

     * The array of custom error messages.

     *

     * @var array

     */

    public $customMessages = [];

    /**

     * The array of fallback error messages.

     *

     * @var array

     */

    public $fallbackMessages = [];

    /**

     * The array of custom attribute names.

     *

     * @var array

     */

    public $customAttributes = [];

    /**

     * The array of custom displayable values.

     *

     * @var array

     */

    public $customValues = [];

    /**

     * Indicates if the validator should stop on the first rule failure.

     *

     * @var bool

     */

    protected $stopOnFirstFailure = false;

    /**

     * Indicates that unvalidated array keys should be excluded, even if the parent array was validated.

     *

     * @var bool

     */

    public $excludeUnvalidatedArrayKeys = false;

    /**

     * All of the custom validator extensions.

     *

     * @var array

     */

    public $extensions = [];

    /**

     * All of the custom replacer extensions.

     *

     * @var array

     */

    public $replacers = [];

    /**

     * The validation rules that may be applied to files.

     *

     * @var string[]

     */

    protected $fileRules = [

        'Between',

        'Dimensions',

        'File',

        'Image',

        'Max',

        'Mimes',

        'Mimetypes',

        'Min',

        'Size',

    ];

    /**

     * The validation rules that imply the field is required.

     *

     * @var string[]

     */

    protected $implicitRules = [

        'Accepted',

        'AcceptedIf',

        'Declined',

        'DeclinedIf',

        'Filled',

        'Missing',

        'MissingIf',

        'MissingUnless',

        'MissingWith',

        'MissingWithAll',

        'Present',

        'Required',

        'RequiredIf',

        'RequiredIfAccepted',

        'RequiredUnless',

        'RequiredWith',

        'RequiredWithAll',

        'RequiredWithout',

        'RequiredWithoutAll',

    ];

    /**

     * The validation rules which depend on other fields as parameters.

     *

     * @var string[]

     */

    protected $dependentRules = [

        'After',

        'AfterOrEqual',

        'Before',

        'BeforeOrEqual',

        'Confirmed',

        'Different',

        'ExcludeIf',

        'ExcludeUnless',

        'ExcludeWith',

        'ExcludeWithout',

        'Gt',

        'Gte',

        'Lt',

        'Lte',

        'AcceptedIf',

        'DeclinedIf',

        'RequiredIf',

        'RequiredIfAccepted',

        'RequiredUnless',

        'RequiredWith',

        'RequiredWithAll',

        'RequiredWithout',

        'RequiredWithoutAll',

        'Prohibited',

        'ProhibitedIf',

        'ProhibitedUnless',

        'Prohibits',

        'Same',

        'Unique',

    ];

    /**

     * The validation rules that can exclude an attribute.

     *

     * @var string[]

     */

    protected $excludeRules = ['Exclude', 'ExcludeIf', 'ExcludeUnless', 'ExcludeWith', 'ExcludeWithout'];

    /**

     * The size related validation rules.

     *

     * @var string[]

     */

    protected $sizeRules = ['Size', 'Between', 'Min', 'Max', 'Gt', 'Lt', 'Gte', 'Lte'];

    /**

     * The numeric related validation rules.

     *

     * @var string[]

     */

    protected $numericRules = ['Numeric', 'Integer', 'Decimal'];

    /**

     * The current placeholder for dots in rule keys.

     *

     * @var string

     */

    protected $dotPlaceholder;

    /**

     * The exception to throw upon failure.

     *

     * @var string

     */

    protected $exception = ValidationException::class;

    /**

     * Create a new Validator instance.

     *

     * @param  \Illuminate\Contracts\Translation\Translator  $translator

     * @param  array  $data

     * @param  array  $rules

     * @param  array  $messages

     * @param  array  $customAttributes

     * @return void

     */

    public function __construct(Translator $translator, array $data, array $rules,

                                array $messages = [], array $customAttributes = [])

    {

        $this->dotPlaceholder = Str::random();

        $this->initialRules = $rules;

        $this->translator = $translator;

        $this->customMessages = $messages;

        $this->data = $this->parseData($data);

        $this->customAttributes = $customAttributes;

        $this->setRules($rules);

    }

    /**

     * Parse the data array, converting dots and asterisks.

     *

     * @param  array  $data

     * @return array

     */

    public function parseData(array $data)

    {

        $newData = [];

        foreach ($data as $key => $value) {

            if (is_array($value)) {

                $value = $this->parseData($value);

            }

            $key = str_replace(

                ['.', '*'],

                [$this->dotPlaceholder, '__asterisk__'],

                $key

            );

            $newData[$key] = $value;

        }

        return $newData;

    }

    /**

     * Replace the placeholders used in data keys.

     *

     * @param  array  $data

     * @return array

     */

    protected function replacePlaceholders($data)

    {

        $originalData = [];

        foreach ($data as $key => $value) {

            $originalData[$this->replacePlaceholderInString($key)] = is_array($value)

                        ? $this->replacePlaceholders($value)

                        : $value;

        }

        return $originalData;

    }

    /**

     * Replace the placeholders in the given string.

     *

     * @param  string  $value

     * @return string

     */

    protected function replacePlaceholderInString(string $value)

    {

        return str_replace(

            [$this->dotPlaceholder, '__asterisk__'],

            ['.', '*'],

            $value

        );

    }

    /**

     * Add an after validation callback.

     *

     * @param  callable|string  $callback

     * @return $this

     */

    public function after($callback)

    {

        $this->after[] = fn () => $callback($this);

        return $this;

    }

    /**

     * Determine if the data passes the validation rules.

     *

     * @return bool

     */

    public function passes()

    {

        $this->messages = new MessageBag;

        [$this->distinctValues, $this->failedRules] = [[], []];

        // We'll spin through each rule, validating the attributes attached to that

        // rule. Any error messages will be added to the containers with each of

        // the other error messages, returning true if we don't have messages.

        foreach ($this->rules as $attribute => $rules) {

            if ($this->shouldBeExcluded($attribute)) {

                $this->removeAttribute($attribute);

                continue;

            }

            if ($this->stopOnFirstFailure && $this->messages->isNotEmpty()) {

                break;

            }

            foreach ($rules as $rule) {

                $this->validateAttribute($attribute, $rule);

                if ($this->shouldBeExcluded($attribute)) {

                    $this->removeAttribute($attribute);

                    break;

                }

                if ($this->shouldStopValidating($attribute)) {

                    break;

                }

            }

        }

        // Here we will spin through all of the "after" hooks on this validator and

        // fire them off. This gives the callbacks a chance to perform all kinds

        // of other validation that needs to get wrapped up in this operation.

        foreach ($this->after as $after) {

            $after();

        }

        return $this->messages->isEmpty();

    }

    /**

     * Determine if the data fails the validation rules.

     *

     * @return bool

     */

    public function fails()

    {

        return ! $this->passes();

    }

    /**

     * Determine if the attribute should be excluded.

     *

     * @param  string  $attribute

     * @return bool

     */

    protected function shouldBeExcluded($attribute)

    {

        foreach ($this->excludeAttributes as $excludeAttribute) {

            if ($attribute === $excludeAttribute ||

                Str::startsWith($attribute, $excludeAttribute.'.')) {

                return true;

            }

        }

        return false;

    }

    /**

     * Remove the given attribute.

     *

     * @param  string  $attribute

     * @return void

     */

    protected function removeAttribute($attribute)

    {

        Arr::forget($this->data, $attribute);

        Arr::forget($this->rules, $attribute);

    }

    /**

     * Run the validator's rules against its data.

     *

     * @return array

     *

     * @throws \Illuminate\Validation\ValidationException

     */

    public function validate()

    {

        throw_if($this->fails(), $this->exception, $this);

        return $this->validated();

    }

    /**

     * Run the validator's rules against its data.

     *

     * @param  string  $errorBag

     * @return array

     *

     * @throws \Illuminate\Validation\ValidationException

     */

    public function validateWithBag(string $errorBag)

    {

        try {

            return $this->validate();

        } catch (ValidationException $e) {

            $e->errorBag = $errorBag;

            throw $e;

        }

    }

    /**

     * Get a validated input container for the validated input.

     *

     * @param  array|null  $keys

     * @return \Illuminate\Support\ValidatedInput|array

     */

    public function safe(array $keys = null)

    {

        return is_array($keys)

                ? (new ValidatedInput($this->validated()))->only($keys)

                : new ValidatedInput($this->validated());

    }

    /**

     * Get the attributes and values that were validated.

     *

     * @return array

     *

     * @throws \Illuminate\Validation\ValidationException

     */

    public function validated()

    {

        throw_if($this->invalid(), $this->exception, $this);

        $results = [];

        $missingValue = new stdClass;

        foreach ($this->getRules() as $key => $rules) {

            if ($this->excludeUnvalidatedArrayKeys &&

                in_array('array', $rules) &&

                ! empty(preg_grep('/^'.preg_quote($key, '/').'\.+/', array_keys($this->getRules())))) {

                continue;

            }

            $value = data_get($this->getData(), $key, $missingValue);

            if ($value !== $missingValue) {

                Arr::set($results, $key, $value);

            }

        }

        return $this->replacePlaceholders($results);

    }

    /**

     * Validate a given attribute against a rule.

     *

     * @param  string  $attribute

     * @param  string  $rule

     * @return void

     */

    protected function validateAttribute($attribute, $rule)

    {

        $this->currentRule = $rule;

        [$rule, $parameters] = ValidationRuleParser::parse($rule);

        if ($rule === '') {

            return;

        }

        // First we will get the correct keys for the given attribute in case the field is nested in

        // an array. Then we determine if the given rule accepts other field names as parameters.

        // If so, we will replace any asterisks found in the parameters with the correct keys.

        if ($this->dependsOnOtherFields($rule)) {

            $parameters = $this->replaceDotInParameters($parameters);

            if ($keys = $this->getExplicitKeys($attribute)) {

                $parameters = $this->replaceAsterisksInParameters($parameters, $keys);

            }

        }

        $value = $this->getValue($attribute);

        // If the attribute is a file, we will verify that the file upload was actually successful

        // and if it wasn't we will add a failure for the attribute. Files may not successfully

        // upload if they are too large based on PHP's settings so we will bail in this case.

        if ($value instanceof UploadedFile && ! $value->isValid() &&

            $this->hasRule($attribute, array_merge($this->fileRules, $this->implicitRules))

        ) {

            return $this->addFailure($attribute, 'uploaded', []);

        }

        // If we have made it this far we will make sure the attribute is validatable and if it is

        // we will call the validation method with the attribute. If a method returns false the

        // attribute is invalid and we will add a failure message for this failing attribute.

        $validatable = $this->isValidatable($rule, $attribute, $value);

        if ($rule instanceof RuleContract) {

            return $validatable

                    ? $this->validateUsingCustomRule($attribute, $value, $rule)

                    : null;

        }

        $method = "validate{$rule}";

        if ($validatable && ! $this->$method($attribute, $value, $parameters, $this)) {

            $this->addFailure($attribute, $rule, $parameters);

        }

    }

    /**

     * Determine if the given rule depends on other fields.

     *

     * @param  string  $rule

     * @return bool

     */

    protected function dependsOnOtherFields($rule)

    {

        return in_array($rule, $this->dependentRules);

    }

    /**

     * Get the explicit keys from an attribute flattened with dot notation.

     *

     * E.g. 'foo.1.bar.spark.baz' -> [1, 'spark'] for 'foo.*.bar.*.baz'

     *

     * @param  string  $attribute

     * @return array

     */

    protected function getExplicitKeys($attribute)

    {

        $pattern = str_replace('\*', '([^\.]+)', preg_quote($this->getPrimaryAttribute($attribute), '/'));

        if (preg_match('/^'.$pattern.'/', $attribute, $keys)) {

            array_shift($keys);

            return $keys;

        }

        return [];

    }

    /**

     * Get the primary attribute name.

     *

     * For example, if "name.0" is given, "name.*" will be returned.

     *

     * @param  string  $attribute

     * @return string

     */

    protected function getPrimaryAttribute($attribute)

    {

        foreach ($this->implicitAttributes as $unparsed => $parsed) {

            if (in_array($attribute, $parsed, true)) {

                return $unparsed;

            }

        }

        return $attribute;

    }

    /**

     * Replace each field parameter which has an escaped dot with the dot placeholder.

     *

     * @param  array  $parameters

     * @return array

     */

    protected function replaceDotInParameters(array $parameters)

    {

        return array_map(function ($field) {

            return str_replace('\.', $this->dotPlaceholder, $field);

        }, $parameters);

    }

    /**

     * Replace each field parameter which has asterisks with the given keys.

     *

     * @param  array  $parameters

     * @param  array  $keys

     * @return array

     */

    protected function replaceAsterisksInParameters(array $parameters, array $keys)

    {

        return array_map(function ($field) use ($keys) {

            return vsprintf(str_replace('*', '%s', $field), $keys);

        }, $parameters);

    }

    /**

     * Determine if the attribute is validatable.

     *

     * @param  object|string  $rule

     * @param  string  $attribute

     * @param  mixed  $value

     * @return bool

     */

    protected function isValidatable($rule, $attribute, $value)

    {

        if (in_array($rule, $this->excludeRules)) {

            return true;

        }

        return $this->presentOrRuleIsImplicit($rule, $attribute, $value) &&

               $this->passesOptionalCheck($attribute) &&

               $this->isNotNullIfMarkedAsNullable($rule, $attribute) &&

               $this->hasNotFailedPreviousRuleIfPresenceRule($rule, $attribute);

    }

    /**

     * Determine if the field is present, or the rule implies required.

     *

     * @param  object|string  $rule

     * @param  string  $attribute

     * @param  mixed  $value

     * @return bool

     */

    protected function presentOrRuleIsImplicit($rule, $attribute, $value)

    {

        if (is_string($value) && trim($value) === '') {

            return $this->isImplicit($rule);

        }

        return $this->validatePresent($attribute, $value) ||

               $this->isImplicit($rule);

    }

    /**

     * Determine if a given rule implies the attribute is required.

     *

     * @param  object|string  $rule

     * @return bool

     */

    protected function isImplicit($rule)

    {

        return $rule instanceof ImplicitRule ||

               in_array($rule, $this->implicitRules);

    }

    /**

     * Determine if the attribute passes any optional check.

     *

     * @param  string  $attribute

     * @return bool

     */

    protected function passesOptionalCheck($attribute)

    {

        if (! $this->hasRule($attribute, ['Sometimes'])) {

            return true;

        }

        $data = ValidationData::initializeAndGatherData($attribute, $this->data);

        return array_key_exists($attribute, $data)

            || array_key_exists($attribute, $this->data);

    }

    /**

     * Determine if the attribute fails the nullable check.

     *

     * @param  string  $rule

     * @param  string  $attribute

     * @return bool

     */

    protected function isNotNullIfMarkedAsNullable($rule, $attribute)

    {

        if ($this->isImplicit($rule) || ! $this->hasRule($attribute, ['Nullable'])) {

            return true;

        }

        return ! is_null(Arr::get($this->data, $attribute, 0));

    }

    /**

     * Determine if it's a necessary presence validation.

     *

     * This is to avoid possible database type comparison errors.

     *

     * @param  string  $rule

     * @param  string  $attribute

     * @return bool

     */

    protected function hasNotFailedPreviousRuleIfPresenceRule($rule, $attribute)

    {

        return in_array($rule, ['Unique', 'Exists']) ? ! $this->messages->has($attribute) : true;

    }

    /**

     * Validate an attribute using a custom rule object.

     *

     * @param  string  $attribute

     * @param  mixed  $value

     * @param  \Illuminate\Contracts\Validation\Rule  $rule

     * @return void

     */

    protected function validateUsingCustomRule($attribute, $value, $rule)

    {

        $attribute = $this->replacePlaceholderInString($attribute);

        $value = is_array($value) ? $this->replacePlaceholders($value) : $value;

        if ($rule instanceof ValidatorAwareRule) {

            $rule->setValidator($this);

        }

        if ($rule instanceof DataAwareRule) {

            $rule->setData($this->data);

        }

        if (! $rule->passes($attribute, $value)) {

            $ruleClass = $rule instanceof InvokableValidationRule ?

                get_class($rule->invokable()) :

                get_class($rule);

            $this->failedRules[$attribute][$ruleClass] = [];

            $messages = $this->getFromLocalArray($attribute, $ruleClass) ?? $rule->message();

            $messages = $messages ? (array) $messages : [$ruleClass];

            foreach ($messages as $key => $message) {

                $key = is_string($key) ? $key : $attribute;

                $this->messages->add($key, $this->makeReplacements(

                    $message, $key, $ruleClass, []

                ));

            }

        }

    }

    /**

     * Check if we should stop further validations on a given attribute.

     *

     * @param  string  $attribute

     * @return bool

     */

    protected function shouldStopValidating($attribute)

    {

        $cleanedAttribute = $this->replacePlaceholderInString($attribute);

        if ($this->hasRule($attribute, ['Bail'])) {

            return $this->messages->has($cleanedAttribute);

        }

        if (isset($this->failedRules[$cleanedAttribute]) &&

            array_key_exists('uploaded', $this->failedRules[$cleanedAttribute])) {

            return true;

        }

        // In case the attribute has any rule that indicates that the field is required

        // and that rule already failed then we should stop validation at this point

        // as now there is no point in calling other rules with this field empty.

        return $this->hasRule($attribute, $this->implicitRules) &&

               isset($this->failedRules[$cleanedAttribute]) &&

               array_intersect(array_keys($this->failedRules[$cleanedAttribute]), $this->implicitRules);

    }

    /**

     * Add a failed rule and error message to the collection.

     *

     * @param  string  $attribute

     * @param  string  $rule

     * @param  array  $parameters

     * @return void

     */

    public function addFailure($attribute, $rule, $parameters = [])

    {

        if (! $this->messages) {

            $this->passes();

        }

        $attributeWithPlaceholders = $attribute;

        $attribute = $this->replacePlaceholderInString($attribute);

        if (in_array($rule, $this->excludeRules)) {

            return $this->excludeAttribute($attribute);

        }

        $this->messages->add($attribute, $this->makeReplacements(

            $this->getMessage($attributeWithPlaceholders, $rule), $attribute, $rule, $parameters

        ));

        $this->failedRules[$attribute][$rule] = $parameters;

    }

    /**

     * Add the given attribute to the list of excluded attributes.

     *

     * @param  string  $attribute

     * @return void

     */

    protected function excludeAttribute(string $attribute)

    {

        $this->excludeAttributes[] = $attribute;

        $this->excludeAttributes = array_unique($this->excludeAttributes);

    }

    /**

     * Returns the data which was valid.

     *

     * @return array

     */

    public function valid()

    {

        if (! $this->messages) {

            $this->passes();

        }

        return array_diff_key(

            $this->data, $this->attributesThatHaveMessages()

        );

    }

    /**

     * Returns the data which was invalid.

     *

     * @return array

     */

    public function invalid()

    {

        if (! $this->messages) {

            $this->passes();

        }

        $invalid = array_intersect_key(

            $this->data, $this->attributesThatHaveMessages()

        );

        $result = [];

        $failed = Arr::only(Arr::dot($invalid), array_keys($this->failed()));

        foreach ($failed as $key => $failure) {

            Arr::set($result, $key, $failure);

        }

        return $result;

    }

    /**

     * Generate an array of all attributes that have messages.

     *

     * @return array

     */

    protected function attributesThatHaveMessages()

    {

        return collect($this->messages()->toArray())->map(function ($message, $key) {

            return explode('.', $key)[0];

        })->unique()->flip()->all();

    }

    /**

     * Get the failed validation rules.

     *

     * @return array

     */

    public function failed()

    {

        return $this->failedRules;

    }

    /**

     * Get the message container for the validator.

     *

     * @return \Illuminate\Support\MessageBag

     */

    public function messages()

    {

        if (! $this->messages) {

            $this->passes();

        }

        return $this->messages;

    }

    /**

     * An alternative more semantic shortcut to the message container.

     *

     * @return \Illuminate\Support\MessageBag

     */

    public function errors()

    {

        return $this->messages();

    }

    /**

     * Get the messages for the instance.

     *

     * @return \Illuminate\Support\MessageBag

     */

    public function getMessageBag()