AttributeIndexValidator::getExcludeByPkCondition() - Code Metrics - herroffizier/yii2-attribute-index-validator - Measure and Improve Code Quality continuously with Scrutinizer

AttributeIndexValidator::getExcludeByPkCondition() A
last analyzed 2016-03-29 13:24 UTC

↳ Parent: AttributeIndexValidator

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	10
ccs	6
cts	6
cp	1
rs	9.4285
cc	2
eloc	6
nc	2
nop	1
crap	2

<?php
/**
 * Yii2 Attribute Index Validator
 *
 * This file contains validator.
 *
 * @author  Martin Stolz <[email protected]>
 */

namespace herroffizier\yii2aiv;

use Closure;
use yii\validators\Validator;
use yii\db\ActiveQueryInterface;
use yii\db\ActiveRecordInterface;

class AttributeIndexValidator extends Validator
{
    /**
     * Separator between base value and index.
     *
     * @var string
     */
    public $separator = '-';

    /**
     * Start index value.
     *
     * @var integer
     */
    public $startIndex = 1;

    /**
     * Additional filter applied to query used to check uniqueness.
     *
     * @var string|array|Closure
     */
    public $filter = null;

    /**
     * Escaped separator.
     *
     * @var string
     */
    protected $escapedSeparator = null;

    /**
     * Escape string for regexp.
     *
     * @param  string $string
     * @return string
     */
    protected function escapeForRegexp($string)
    {
        return addcslashes($string, '[]().?-*^$/:<>');
    }

    /**
     * Get escaped separator for regexps.
     *
     * @return string
     */
    protected function getEscapedSeparator()
    {
        if ($this->escapedSeparator === null) {
            $this->escapedSeparator = $this->escapeForRegexp($this->separator);
        }

        return $this->escapedSeparator;
    }

    /**
     * Add filter to query (if any exists).
     *
     * @param ActiveQueryInterface $query
     */
    protected function addFilterToQuery(ActiveQueryInterface $query)
    {
        if (!$this->filter) {
            return;
        }

        if ($this->filter instanceof Closure) {
            call_user_func_array($this->filter, [$query]);
        } else {
            $query->andWhere($this->filter);
        }
    }

    /**
     * Get condition to exclude current model by it's primay key.
     *
     * If model is new, empty array will be returned.
     *
     * @param  ActiveRecordInterface $model
     * @return array
     */
    protected function getExcludeByPkCondition(ActiveRecordInterface $model)
    {
        if (array_filter($pk = $model->getPrimaryKey(true))) {
            $condition = ['not', $pk];
        } else {
            $condition = [];
        }

        return $condition;
    }

    /**
     * Whether there are an attribute value collision.
     *
     * @param  ActiveRecordInterface $model
     * @param  string                $attribute
     * @return boolean
     */
    protected function hasCollision(ActiveRecordInterface $model, $attribute)
    {
        $query =
            $model->find()->
                andWhere($this->getExcludeByPkCondition($model))->
                andWhere([$attribute => $model->$attribute]);
        $this->addFilterToQuery($query);

        return $query->exists();
    }

    /**
     * Get attribute value common part, e. g. part without index but with separator.
     *
     * For example, common part for 'test' and 'test-1' will be 'test-'.
     *
     * @param  ActiveRecordInterface $model
     * @param  string                $attribute
     * @return string
     */
    protected function getCommonPart(ActiveRecordInterface $model, $attribute)
    {
        $escapedSeparator = $this->getEscapedSeparator();

        return preg_replace('/'.$escapedSeparator.'\d+$/', '', $model->$attribute).$this->separator;
    }

    /**
     * Find max index stored in database.
     *
     * If no index found, startIndex - 1 will be returned.
     *
     * @param  ActiveRecordInterface $model
     * @param  string                $attribute
     * @param  string                $commonPart
     * @return integer
     */
    protected function findMaxIndex(ActiveRecordInterface $model, $attribute, $commonPart)
    {
        // Find all possible max values.
        $db = $model::getDb();
        $indexExpression = 'SUBSTRING('.$db->quoteColumnName($attribute).', :commonPartOffset)';
        $query =
            $model->find()->
                select(['_index' => $indexExpression])->
                andWhere($this->getExcludeByPkCondition($model))->
                andWhere(['like', $attribute, $commonPart])->
                andHaving(['not in', '_index', [0]])->
                orderBy(['CAST('.$db->quoteColumnName('_index').' AS UNSIGNED)' => SORT_DESC])->
                addParams(['commonPartOffset' => mb_strlen($commonPart) + 1])->
                asArray();
        $this->addFilterToQuery($query);
        foreach ($query->each() as $row) {
            $index = $row['_index'];
            if (!preg_match('/^\d+$/', $index)) {
                continue;
            }

            return $index;
        }

        return $this->startIndex - 1;
    }

    /**
     * @inheritdoc
     */
    public function validateAttribute($model, $attribute)
    {
        if (!$this->hasCollision($model, $attribute)) {
            return;
        }

        $commonPart = $this->getCommonPart($model, $attribute);
        $maxIndex = $this->findMaxIndex($model, $attribute, $commonPart);

        $model->$attribute = $commonPart.($maxIndex + 1);
    }
}


1		<?php
2		/**
3		* Yii2 Attribute Index Validator
4		*
5		* This file contains validator.
6		*
7		* @author Martin Stolz <[email protected]>
8		*/
9
10		namespace herroffizier\yii2aiv;
11
12		use Closure;
13		use yii\validators\Validator;
14		use yii\db\ActiveQueryInterface;
15		use yii\db\ActiveRecordInterface;
16
17		class AttributeIndexValidator extends Validator
18		{
19		/**
20		* Separator between base value and index.
21		*
22		* @var string
23		*/
24		public $separator = '-';
25
26		/**
27		* Start index value.
28		*
29		* @var integer
30		*/
31		public $startIndex = 1;
32
33		/**
34		* Additional filter applied to query used to check uniqueness.
35		*
36		* @var string\|array\|Closure
37		*/
38		public $filter = null;
39
40		/**
41		* Escaped separator.
42		*
43		* @var string
44		*/
45		protected $escapedSeparator = null;
46
47		/**
48		* Escape string for regexp.
49		*
50		* @param string $string
51		* @return string
52		*/
53	32	protected function escapeForRegexp($string)
54		{
55	32	return addcslashes($string, '[]().?-*^$/:<>');
56		}
57
58		/**
59		* Get escaped separator for regexps.
60		*
61		* @return string
62		*/
63	32	protected function getEscapedSeparator()
64		{
65	32	if ($this->escapedSeparator === null) {
66	32	$this->escapedSeparator = $this->escapeForRegexp($this->separator);
67	24	}
68
69	32	return $this->escapedSeparator;
70		}
71
72		/**
73		* Add filter to query (if any exists).
74		*
75		* @param ActiveQueryInterface $query
76		*/
77	32	protected function addFilterToQuery(ActiveQueryInterface $query)
78		{
79	32	if (!$this->filter) {
80	28	return;
81		}
82
83	4	if ($this->filter instanceof Closure) {
84	4	call_user_func_array($this->filter, [$query]);
85	3	} else {
86	4	$query->andWhere($this->filter);
87		}
88	4	}
89
90		/**
91		* Get condition to exclude current model by it's primay key.
92		*
93		* If model is new, empty array will be returned.
94		*
95		* @param ActiveRecordInterface $model
96		* @return array
97		*/
98	32	protected function getExcludeByPkCondition(ActiveRecordInterface $model)
99		{
100	32	if (array_filter($pk = $model->getPrimaryKey(true))) {
101	4	$condition = ['not', $pk];
102	3	} else {
103	28	$condition = [];
104		}
105
106	32	return $condition;
107		}
108
109		/**
110		* Whether there are an attribute value collision.
111		*
112		* @param ActiveRecordInterface $model
113		* @param string $attribute
114		* @return boolean
115		*/
116	32	protected function hasCollision(ActiveRecordInterface $model, $attribute)
117		{
118		$query =
119	32	$model->find()->
120	32	andWhere($this->getExcludeByPkCondition($model))->
121	32	andWhere([$attribute => $model->$attribute]);
122	32	$this->addFilterToQuery($query);
123
124	32	return $query->exists();
125		}
126
127		/**
128		* Get attribute value common part, e. g. part without index but with separator.
129		*
130		* For example, common part for 'test' and 'test-1' will be 'test-'.
131		*
132		* @param ActiveRecordInterface $model
133		* @param string $attribute
134		* @return string
135		*/
136	32	protected function getCommonPart(ActiveRecordInterface $model, $attribute)
137		{
138	32	$escapedSeparator = $this->getEscapedSeparator();
139
140	32	return preg_replace('/'.$escapedSeparator.'\d+$/', '', $model->$attribute).$this->separator;
141		}
142
143		/**
144		* Find max index stored in database.
145		*
146		* If no index found, startIndex - 1 will be returned.
147		*
148		* @param ActiveRecordInterface $model
149		* @param string $attribute
150		* @param string $commonPart
151		* @return integer
152		*/
153	32	protected function findMaxIndex(ActiveRecordInterface $model, $attribute, $commonPart)
154		{
155		// Find all possible max values.
156	32	$db = $model::getDb();
157	32	$indexExpression = 'SUBSTRING('.$db->quoteColumnName($attribute).', :commonPartOffset)';
158		$query =
159	32	$model->find()->
160	32	select(['_index' => $indexExpression])->
161	32	andWhere($this->getExcludeByPkCondition($model))->
162	32	andWhere(['like', $attribute, $commonPart])->
163	32	andHaving(['not in', '_index', [0]])->
164	32	orderBy(['CAST('.$db->quoteColumnName('_index').' AS UNSIGNED)' => SORT_DESC])->
165	32	addParams(['commonPartOffset' => mb_strlen($commonPart) + 1])->
166	32	asArray();
167	32	$this->addFilterToQuery($query);
168	32	foreach ($query->each() as $row) {
169	20	$index = $row['_index'];
170	20	if (!preg_match('/^\d+$/', $index)) {
171	4	continue;
172		}
173
174	20	return $index;
175	21	}
176
177	28	return $this->startIndex - 1;
178		}
179
180		/**
181		* @inheritdoc
182		*/
183	32	public function validateAttribute($model, $attribute)
184		{
185	32	if (!$this->hasCollision($model, $attribute)) {
186	12	return;
187		}
188
189	32	$commonPart = $this->getCommonPart($model, $attribute);
190	32	$maxIndex = $this->findMaxIndex($model, $attribute, $commonPart);
191
192	32	$model->$attribute = $commonPart.($maxIndex + 1);
193	32	}
194		}
195

herroffizier / yii2-attribute-index-validator

AttributeIndexValidator::getExcludeByPkCondition() A last analyzed 2016-03-29 13:24 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AttributeIndexValidator::getExcludeByPkCondition() A
last analyzed 2016-03-29 13:24 UTC