NwLaravel\Validation\BaseValidator

Complexity

Total Complexity

27

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

98.61%

Importance

Changes	3
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	makeRules()	0	4	1
A	makeMessages()	0	4	1
A	makeAttributes()	0	4	1
A	getMessages()	0	4	1
A	getAttributes()	0	4	1
A	getValidator()	0	4	1
A	setKeyName()	0	4	1
A	getRules()	0	10	2
A	passes()	0	14	2
C	parserValidationRules()	0	50	13
A	getValue()	0	6	2

<?php
namespace NwLaravel\Validation;

use Illuminate\Validation\Factory;
use Prettus\Validator\AbstractValidator;

/**
 * Class BaseValidator
 * @abstract
 */
abstract class BaseValidator extends AbstractValidator
{
    /**
     * Validator
     *
     * @var \Illuminate\Validation\Factory
     */
    protected $validator;

    /**
     * @var string
     */
    protected $keyName;

    /**
     * @var array
     */
    protected $messages = [];

    /**
     * @var array
     */
    protected $attributes = [];

    /**
     * Construct
     *
     * @param \Illuminate\Validation\Factory $validator
     */
    public function __construct(Factory $validator)
    {
        $this->validator = $validator;
        $this->rules = array_merge_recursive((array) $this->rules, $this->makeRules());
        $this->messages = array_merge_recursive((array) $this->messages, $this->makeMessages());
        $this->attributes = array_merge_recursive((array) $this->attributes, $this->makeAttributes());
    }

    /**
     * MakeRules
     *
     * @return array
     */
    protected function makeRules()
    {
        return [];
    }

    /**
     * Make Messages
     *
     * @return array
     */
    protected function makeMessages()
    {
        return [];
    }

    /**
     * Make Attributes
     *
     * @return array
     */
    protected function makeAttributes()
    {
        return [];
    }

    /**
     * Get Messages
     *
     * @param array $messages

There is no parameter named $messages. Was it maybe removed?

     *
     * @return array
     */
    public function getMessages()
    {
        return $this->messages;
    }

    /**
     * Get Attributes
     *
     * @param array $attributes

There is no parameter named $attributes. Was it maybe removed?

     *
     * @return array
     */
    public function getAttributes()
    {
        return $this->attributes;
    }

    /**
     * Get Validator
     *
     * @return \Illuminate\Validation\Factory
     */
    public function getValidator()
    {
        return $this->validator;
    }

    /**
     * Set Key Name
     *
     * @param string $keyName
     *
     * @return BaseValidator
     */
    public function setKeyName($keyName)
    {
        $this->keyName = $keyName;
    }

    /**
     * Get rule for validation by action ValidatorInterface::RULE_CREATE or ValidatorInterface::RULE_UPDATE
     *
     * Default rule: ValidatorInterface::RULE_CREATE
     *
     * @param string|null $action
     *
     * @return array
     */
    public function getRules($action = null)
    {
        $rules = [];

        if (isset($this->rules[$action])) {
            $rules = $this->rules[$action];
        }

        return $this->parserValidationRules($rules, $this->id);
    }

    /**
     * Pass the data and the rules to the validator
     *
     * @param string $action
     * @return bool
     */
    public function passes($action = null)
    {
        $rules      = $this->getRules($action);
        $messages   = $this->getMessages();
        $attributes = $this->getAttributes();
        $validator  = $this->validator->make($this->data, $rules, $messages, $attributes);

        if ($validator->fails()) {
            $this->errors = $validator->messages();
            return false;
        }

        return true;
    }

    /**
     * Parser Validation Rules
     *
     * @param array    $rules
     * @param int|null $id
     *
     * @return array
     */
    protected function parserValidationRules($rules, $id = null)
    {

        if ($id === null) {
            return $rules;
        }

        array_walk($rules, function (&$rules, $field) use ($id) {
            if (!is_array($rules)) {
                $rules = explode("|", $rules);
            }

            foreach ($rules as $ruleIdx => $rule) {
                // get name and parameters
                list($name, $params) = array_pad(explode(":", $rule), 2, null);

                // only do someting for the unique rule
                if (strtolower($name) != "unique") {
                    if (preg_match('/\[(.*)\]/', $params, $matches)) {
                        if (array_key_exists($matches[1], $this->data)) {
                            $params = str_replace("[".$matches[1]."]", $this->getValue($matches[1]), $params);
                            $rules[$ruleIdx] = $name.":".$params;
                        }
                    }
                    continue; // continue in foreach loop, nothing left to do here
                }

                $p = array_map("trim", explode(",", $params));

                // set field name to rules key ($field) (laravel convention)
                if (!isset($p[1])) {
                    $p[1] = $field;
                }

                // set 3rd parameter to id given to getValidationRules()
                if (!isset($p[2]) || empty($p[2])) {
                    $p[2] = $id;
                }

                if ($this->keyName && (!isset($p[3]) || empty($p[3]))) {
                    $p[3] = $this->keyName;
                }

                $params = implode(",", $p);
                $rules[$ruleIdx] = $name.":".$params;
            }
        });

        return $rules;
    }

    /**
     * Get the value of a given attribute.
     *
     * @param  string  $attribute
     * @return mixed
     */
    protected function getValue($attribute)
    {
        if (! is_null($value = array_get($this->data, $attribute))) {
            return $value;
        }
    }
}