HasValidationTrait::getErrors() - Code Metrics - ronanchilvers/orm - Measure and Improve Code Quality continuously with Scrutinizer

HasValidationTrait::getErrors() A
last analyzed 2023-04-19 17:01 UTC

↳ Parent: HasValidationTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
<?php

namespace Ronanchilvers\Orm\Traits;

use Respect\Validation\Exceptions\NestedValidationException;
use RuntimeException;

/**
 * Trait that adds validation support to models
 *
 * NB: This trait expects the class to use the respect/validation library.
 *
 * @author Ronan Chilvers <[email protected]>
 */
trait HasValidationTrait
{
    /**
     * Array of arrays of rule objects per field grouped by scenario
     *
     * @var array
     */
    protected $rules = [];

    /**
     * The errors found by the last validation run
     *
     * @var array
     */
    protected $errors = [];

    /**
     * Setup method for creating and registering rules
     *
     * This method is intended to be overriden by sub classes to set up their
     * validation rules.
     *
     * @author Ronan Chilvers <[email protected]>
     */
    protected function setupValidation()
    {
    }

    /**
     * Add a rule to this model
     *
     * @param array $rules      An array of rule objects
     * @param string $scenario  The validation scenario these rules apply to
     * @author Ronan Chilvers <[email protected]>
     */
    protected function registerRules(array $rules, $scenario = 'default')
    {
        if (!isset($this->rules[$scenario])) {
            $this->rules[$scenario] = [];
        }
        $this->rules[$scenario] = $rules;
    }

    /**
     * Clear the errors for this model
     *
     * @author Ronan Chilvers <[email protected]>
     */
    public function clearErrors()
    {
        $this->errors = [];
    }

    /**
     * Get the current error array for this model
     *
     * @return array
     * @author Ronan Chilvers <[email protected]>
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Does a given field have an error?
     *
     * @param string $field
     * @return boolean
     * @author Ronan Chilvers <[email protected]>
     */
    public function hasError($field)
    {
        $field = static::prefix($field);

        return isset($this->errors[$field]);
    }

    /**
     * Add an error to the errors array
     *
     * @param string $field
     * @param string $message
     * @author Ronan Chilvers <[email protected]>
     */
    protected function addError(string $field, string $message)
    {
        $field = static::prefix($field);
        if (!isset($this->errors[$field])) {
            $this->errors[$field] = [];
        }
        $this->errors[$field][] = $message;
    }

    /**
     * Get the error for a field
     *
     * @param string $field
     * @return string|null
     * @author Ronan Chilvers <[email protected]>
     */
    public function getError($field)
    {
        $field = static::prefix($field);
        if (isset($this->errors[$field])) {
            return $this->errors[$field];
        }

        return null;
    }

    /**
     * Validate this model with its current data
     *
     * @param string $scenario  The validation scenario to validate against
     * @return boolean
     * @author Ronan Chilvers <[email protected]>
     */
    public function validate($scenario = 'default')
    {
        $this->setupValidation();
        if (!isset($this->rules[$scenario])) {
            throw new RuntimeException(
                sprintf('Unable to validate non-existent scenario %s', $scenario)
            );
        }
        $rules        = $this->rules[$scenario];
        foreach ($rules as $field => $validator) {
            $field = static::prefix($field);
            $value = null;
            if (isset($this->data[$field])) {
                $value = $this->data[$field];
            }
            $name = ucwords(str_replace('_', ' ', strtolower(static::unprefix($field))));
            try {
                $validator
                    ->setName($name)
                    ->assert($value);
            } catch (NestedValidationException $ex) {
                foreach ($ex->getMessages() as $message) {
                    $this->addError($field, $message);
                }
            }
        }

        return 0 == count($this->errors);
    }

    /**
     * Save this model
     *
     * This method either inserts or updates the model row based on the presence
     * of an ID. It will return false if the save fails.
     *
     * @param string $scenario  The validation scenario to validate against
     * @return boolean
     * @author Ronan Chilvers <[email protected]>
     */
    public function saveWithValidation($scenario = 'default')
    {
        $this->clearErrors();
        if (false === $this->beforeSave()) {
        if (false === $this->/** @scrutinizer ignore-call */ beforeSave()) {
            return false;
        }
        if (true === $this->isLoaded()) {
        if (true === $this->/** @scrutinizer ignore-call */ isLoaded()) {
            if (false === $this->beforeUpdate()) {
            if (false === $this->/** @scrutinizer ignore-call */ beforeUpdate()) {
                return false;
            }
            if ($this->useTimestamps()) {
            if ($this->/** @scrutinizer ignore-call */ useTimestamps()) {
                $this->updateTimestamps();
                       updateTimestamps();
            }
            if (false === $this->validate($scenario)) {
                return false;
            }
            if (true !== $this->persistUpdate()) {
            if (true !== $this->/** @scrutinizer ignore-call */ persistUpdate()) {
                return false;
            }
            $this->afterUpdate();
                   afterUpdate();
            $this->afterSave();
                   afterSave();

            return true;
        }
        if (false === $this->beforeCreate()) {
        if (false === $this->/** @scrutinizer ignore-call */ beforeCreate()) {
            return false;
        }
        if ($this->useTimestamps()) {
            $this->updateTimestamps();
        }
        if (false === $this->validate($scenario)) {
            return false;
        }
        if (true !== $this->persistInsert()) {
        if (true !== $this->/** @scrutinizer ignore-call */ persistInsert()) {
            return false;
        }
        $this->afterCreate();
               afterCreate();
        $this->afterSave();

        return true;
    }
}

ronanchilvers / orm

HasValidationTrait::getErrors() A last analyzed 2023-04-19 17:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

HasValidationTrait::getErrors() A
last analyzed 2023-04-19 17:01 UTC
