MultipleBlameableTrait::removeAllBlames() - Code Metrics - Inspection of "add basic single relation test cases" - rhosocial/yii2-base-models - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bf148f...113cf9 )

by vistart

created 2017-01-16 09:54 UTC

MultipleBlameableTrait::removeAllBlames() A

↳ Parent: MultipleBlameableTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

/**
 *  _   __ __ _____ _____ ___  ____  _____
 * | | / // // ___//_  _//   ||  __||_   _|
 * | |/ // /(__  )  / / / /| || |     | |
 * |___//_//____/  /_/ /_/ |_||_|     |_|
 * @link https://vistart.me/
 * @copyright Copyright (c) 2016 - 2017 vistart
 * @license https://vistart.me/license/
 */

namespace rhosocial\base\models\traits;

use rhosocial\base\helpers\Number;
use rhosocial\base\models\events\MultipleBlameableEvent;
use rhosocial\base\models\models\BaseUserModel;
use yii\base\ModelEvent;
use yii\base\InvalidCallException;
use yii\base\InvalidConfigException;
use yii\base\InvalidParamException;

/**
 * 一个模型的某个属性可能对应多个责任者，该 trait 用于处理此种情况。此种情况违反
 * 了关系型数据库第一范式，因此此 trait 只适用于责任者属性修改不频繁的场景，在开
 * 发时必须严格测试数据一致性，并同时考量性能。
 * Basic Principles:
 * <ol>
 * <li>when adding blame, it will check whether each of blames including to be
 * added is valid.
 * </li>
 * <li>when removing blame, as well as counting, getting or setting list of them,
 * it will also check whether each of blames is valid.
 * </li>
 * <li>By default, once blame was deleted, the guid of it is not removed from
 * list of blames immediately. It will check blame if valid when adding, removing,
 * counting, getting and setting it. You can define a blame model and attach it
 * events triggered when inserting, updating and deleting a blame, then disable
 * checking the validity of blames.
 * </li>
 * </ol>
 * Notice:
 * <ol>
 * <li>You must specify two properties: $multiBlamesClass and $multiBlamesAttribute.
 * <ul>
 * <li>$multiBlamesClass specify the class name of blame.</li>
 * <li>$multiBlamesAttribute specify the field name of blames.</li>
 * </ul>
 * </li>
 * <li>You should rename the following methods to be needed optionally.</li>
 * </ol>
 * @property-read array $multiBlamesAttributeRules
 * @property string[] $blameGuids
 * @property-read array $allBlames
 * @property-read array $nonBlameds
 * @property-read integer $blamesCount
 * @version 1.0
 * @author vistart <[email protected]>
 */
trait MultipleBlameableTrait
{

    /**
     * @var string class name of multiple blameable class.
     */
    public $multiBlamesClass = '';

    /**
     * @var string name of multiple blameable attribute.
     */
    public $multiBlamesAttribute = 'blames';

    /**
     * @var integer the limit of blames. it should be greater than or equal 1, and
     * less than or equal 10.
     */
    public $blamesLimit = 10;

    /**
     * @var boolean determines whether blames list has been changed.
     */
    public $blamesChanged = false;

    /**
     * @var string event name.
     */
    public static $eventMultipleBlamesChanged = 'multipleBlamesChanged';

    /**
     * Get the rules associated with multiple blameable attribute.
     * @return array rules.
     */
    public function getMultipleBlameableAttributeRules()
    {
        return is_string($this->multiBlamesAttribute) ? [
            [[$this->multiBlamesAttribute], 'string', 'max' => $this->blamesLimit * 16],
            [[$this->multiBlamesAttribute], 'default', 'value' => ''],
            ] : [];
    }

    /**
     * Add specified blame.
     * @param {$this->multiBlamesClass}|string $blame

     * @return false|array
     * @throws InvalidParamException if blame existed.
     * @throws InvalidCallException if blame limit reached.
     */
    public function addBlame($blame)
    {
        if (!is_string($this->multiBlamesAttribute)) {
            return false;
        }
        $blameGuid = '';
        if (is_string($blame)) {
            $blameGuid = $blame;
        }
        if ($blame instanceof $this->multiBlamesClass) {
            $blameGuid = $blame->guid;
        }
        $blameGuids = $this->getBlameGuids(true);
        if (array_search($blameGuid, $blameGuids)) {
            throw new InvalidParamException('the blame has existed.');
        }
        if ($this->getBlamesCount() >= $this->blamesLimit) {
            throw new InvalidCallException("the limit($this->blamesLimit) of blames has been reached.");
        }
        $blameGuids[] = $blameGuid;
        $this->setBlameGuids($blameGuids);
        return $this->getBlameGuids();
    }

    /**
     * Create blame.
     * @param BaseUserModel $user who will own this blame.
     * @param array $config blame class configuration array.
     * @return {$this->multiBlamesClass}

     */
    public static function createBlame($user, $config = [])
    {
        if (!($user instanceof BaseUserModel)) {
            $message = 'the type of user instance must be the extended class of BaseUserModel.';
            throw new InvalidParamException($message);
        }
        $mbClass = static::buildNoInitModel();
        $mbi = $mbClass->multiBlamesClass;
        return $user->create($mbi::className(), $config);
    }

    /**
     * Add specified blame, or create it before adding if doesn't exist.
     * But you should save the blame instance before adding, or the operation
     * will fail.
     * @param {$this->multiBlamesClass}|string|array $blame

     * It will be regarded as blame's guid if it is a string. And assign the
     * reference parameter $blame the instance if it existed, or create one if not
     * found.
     * If it is {$this->multiBlamesClass} instance and existed, then will add it, or
     * false will be given if it is not found in database. So if you want to add
     * blame instance, you should save it before adding.
     * If it is a array, it will be regarded as configuration array of blame.
     * Notice! This parameter passed by reference, so it must be a variable!
     * @param BaseUserModel $user whose blame.
     * If null, it will take this blameable model's user.
     * @return false|array false if blame created failed or not enable this feature.
     * blames guid array if created and added successfully.
     * @throws InvalidConfigException
     * @throws InvalidParamException
     * @see addBlame()
     */
    public function addOrCreateBlame(&$blame = null, $user = null)
    {
        if (!is_string($this->multiBlamesClass)) {
            throw new InvalidConfigException('$multiBlamesClass must be specified if you want to use multiple blameable features.');
        }
        if (is_array($blame)) {
            if ($user == null) {
                $user = $this->user;
class MyClass { }

$x = new MyClass();
$x->foo = true;
            }
            $blame = static::getOrCreateBlame($blame, $user);
            if (!$blame->save()) {
                return false;
            }
            return $this->addBlame($blame->guid);
        }
        $blameGuid = '';
        if (is_string($blame)) {
            $blameGuid = $blame;
        }
        if ($blame instanceof $this->multiBlamesClass) {
            $blameGuid = $blame->guid;
        }
        if (($mbi = static::getBlame($blameGuid)) !== null) {
            return $this->addBlame($mbi);
        }
        return false;
    }

    /**
     * Remove specified blame.
     * @param {$this->multiBlamesClass} $blame

     * @return false|array all guids in json format.
     */
    public function removeBlame($blame)
    {
        if (!is_string($this->multiBlamesAttribute)) {
            return false;
        }
        $blameGuid = '';
        if (is_string($blame)) {
            $blameGuid = $blame;
        }
        if ($blame instanceof $this->multiBlamesClass) {
            $blameGuid = $blame->guid;
        }
        $blameGuids = $this->getBlameGuids(true);
        if (($key = array_search($blameGuid, $blameGuids)) !== false) {
            unset($blameGuids[$key]);
            $this->setBlameGuids($blameGuids);
        }
        return $this->getBlameGuids();
    }

    /**
     * Remove all blames.
     */
    public function removeAllBlames()
    {
        $this->setBlameGuids();
    }

    /**
     * Count the blames.
     * @return integer
     */
    public function getBlamesCount()
    {
        return count($this->getBlameGuids(true));
    }

    /**
     * Get the guid array of blames. it may check all guids if valid before return.
     * @param boolean $checkValid determines whether checking the blame is valid.
     * @return array all guids in json format.
     */
    public function getBlameGuids($checkValid = false)
    {
        $multiBlamesAttribute = $this->multiBlamesAttribute;
        if ($multiBlamesAttribute === false) {
            return [];
        }
        $guids = Number::divide_guid_bin($this->$multiBlamesAttribute);
        if ($checkValid) {
            $guids = $this->unsetInvalidBlames($guids);
        }
        return $guids;
    }

    /**
     * Event triggered when blames list changed.
     * @param MultipleBlameableEvent $event
     */
    public function onBlamesChanged($event)
    {
        $sender = $event->sender;
        $sender->blamesChanged = $event->blamesChanged;
    }

    /**
     * Remove invalid blame guid from provided guid array.
     * @param array $guids guid array of blames.
     * @return array guid array of blames unset invalid.
     */
    protected function unsetInvalidBlames($guids)
    {
        $unchecked = $guids;
        $multiBlamesClass = $this->multiBlamesClass;
        $mbi = $multiBlamesClass::buildNoInitModel();
        foreach ($guids as $key => $guid) {
            $blame = $multiBlamesClass::find()->where([$mbi->guidAttribute => $guid])->exists();
            if (!$blame) {
                unset($guids[$key]);
            }
        }
        $diff = array_diff($unchecked, $guids);
        $eventName = static::$eventMultipleBlamesChanged;
        $this->trigger($eventName, new MultipleBlameableEvent(['blamesChanged' => !empty($diff)]));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        return $guids;
    }

    /**
     * Set the guid array of blames, it may check all guids if valid.
     * @param array $guids guid array of blames.
     * @param boolean $checkValid determines whether checking the blame is valid.
     * @return false|array all guids.
     */
    public function setBlameGuids($guids = [], $checkValid = true)
    {
        if (!is_array($guids) || $this->multiBlamesAttribute === false) {
            return null;
        }
        if ($checkValid) {
            $guids = $this->unsetInvalidBlames($guids);
        }
        $multiBlamesAttribute = $this->multiBlamesAttribute;
        $this->$multiBlamesAttribute = Number::composite_guid($guids);
        return $guids;
    }

    /**
     * Get blame.
     * @param string $blameGuid
     * @return {$this->multiBlamesClass}

     */
    public static function getBlame($blameGuid)
    {
        $self = static::buildNoInitModel();
        if (empty($self->multiBlamesClass) || !is_string($self->multiBlamesClass) || $self->multiBlamesAttribute === false) {
            return null;
        }
        $mbClass = $self->multiBlamesClass;
        return $mbClass::findOne($blameGuid);
    }

    /**
     * Get or create blame.
     * @param string|array $blameGuid
     * @param BaseUserModel $user
     * @return {$this->multiBlamesClass}|null

     */
    public static function getOrCreateBlame($blameGuid, $user = null)
    {
        if (is_string($blameGuid)) {
            $blameGuid = static::getBlame($blameGuid);
            if ($blameGuid !== null) {
                return $blameGuid;
            }
        }
        if (is_array($blameGuid)) {
            return static::createBlame($user, $blameGuid);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
        }
        return null;
    }

    /**
     * Get all ones to be blamed by `$blame`.
     * @param {$this->multiBlamesClass} $blame

     * @return array
     */
    public function getBlameds($blame)
    {
        $blameds = static::getBlame($blame->guid);
        if (empty($blameds)) {
            return null;
        }
        $createdByAttribute = $this->createdByAttribute;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        return static::find()->where([$createdByAttribute => $this->$createdByAttribute])
                ->andWhere(['like', $this->multiBlamesAttribute, $blame->guid])->all();
    }

    /**
     * Get all the blames of record.
     * @return array all blames.
     */
    public function getAllBlames()
    {
        if (empty($this->multiBlamesClass) ||
            !is_string($this->multiBlamesClass) ||
            $this->multiBlamesAttribute === false) {
            return null;
        }
        $multiBlamesClass = $this->multiBlamesClass;
        $createdByAttribute = $this->createdByAttribute;
        return $multiBlamesClass::findAll([$createdByAttribute => $this->$createdByAttribute]);
    }

    /**
     * Get all records which without any blames.
     * @return array all non-blameds.
     */
    public function getNonBlameds()
    {
        $createdByAttribute = $this->createdByAttribute;
        $cond = [
            $createdByAttribute => $this->$createdByAttribute,
            $this->multiBlamesAttribute => ''
        ];
        return static::find()->where($cond)->all();
    }

    /**
     * Initialize blames limit.
     * @param ModelEvent $event
     */
    public function onInitBlamesLimit($event)
    {
        $sender = $event->sender;
        if (!is_int($sender->blamesLimit) || $sender->blamesLimit < 1 || $sender->blamesLimit > 64) {
            $sender->blamesLimit = 10;
        }
    }
}


1		<?php
2
3		/**
4		* _ __ __ _____ _____ ___ ____ _____
5		* \| \| / // // ___//_ _// \|\| __\|\|_ _\|
6		* \| \|/ // /(__ ) / / / /\| \|\| \| \| \|
7		* \|___//_//____/ /_/ /_/ \|_\|\|_\| \|_\|
8		* @link https://vistart.me/
9		* @copyright Copyright (c) 2016 - 2017 vistart
10		* @license https://vistart.me/license/
11		*/
12
13		namespace rhosocial\base\models\traits;
14
15		use rhosocial\base\helpers\Number;
16		use rhosocial\base\models\events\MultipleBlameableEvent;
17		use rhosocial\base\models\models\BaseUserModel;
18		use yii\base\ModelEvent;
19		use yii\base\InvalidCallException;
20		use yii\base\InvalidConfigException;
21		use yii\base\InvalidParamException;
22
23		/**
24		* 一个模型的某个属性可能对应多个责任者，该 trait 用于处理此种情况。此种情况违反
25		* 了关系型数据库第一范式，因此此 trait 只适用于责任者属性修改不频繁的场景，在开
26		* 发时必须严格测试数据一致性，并同时考量性能。
27		* Basic Principles:
28		* <ol>
29		* <li>when adding blame, it will check whether each of blames including to be
30		* added is valid.
31		* </li>
32		* <li>when removing blame, as well as counting, getting or setting list of them,
33		* it will also check whether each of blames is valid.
34		* </li>
35		* <li>By default, once blame was deleted, the guid of it is not removed from
36		* list of blames immediately. It will check blame if valid when adding, removing,
37		* counting, getting and setting it. You can define a blame model and attach it
38		* events triggered when inserting, updating and deleting a blame, then disable
39		* checking the validity of blames.
40		* </li>
41		* </ol>
42		* Notice:
43		* <ol>
44		* <li>You must specify two properties: $multiBlamesClass and $multiBlamesAttribute.
45		* <ul>
46		* <li>$multiBlamesClass specify the class name of blame.</li>
47		* <li>$multiBlamesAttribute specify the field name of blames.</li>
48		* </ul>
49		* </li>
50		* <li>You should rename the following methods to be needed optionally.</li>
51		* </ol>
52		* @property-read array $multiBlamesAttributeRules
53		* @property string[] $blameGuids
54		* @property-read array $allBlames
55		* @property-read array $nonBlameds
56		* @property-read integer $blamesCount
57		* @version 1.0
58		* @author vistart <[email protected]>
59		*/
60		trait MultipleBlameableTrait
61		{
62
63		/**
64		* @var string class name of multiple blameable class.
65		*/
66		public $multiBlamesClass = '';
67
68		/**
69		* @var string name of multiple blameable attribute.
70		*/
71		public $multiBlamesAttribute = 'blames';
72
73		/**
74		* @var integer the limit of blames. it should be greater than or equal 1, and
75		* less than or equal 10.
76		*/
77		public $blamesLimit = 10;
78
79		/**
80		* @var boolean determines whether blames list has been changed.
81		*/
82		public $blamesChanged = false;
83
84		/**
85		* @var string event name.
86		*/
87		public static $eventMultipleBlamesChanged = 'multipleBlamesChanged';
88
89		/**
90		* Get the rules associated with multiple blameable attribute.
91		* @return array rules.
92		*/
93	15	public function getMultipleBlameableAttributeRules()
94		{
95	15	return is_string($this->multiBlamesAttribute) ? [
96	15	[[$this->multiBlamesAttribute], 'string', 'max' => $this->blamesLimit * 16],
97	15	[[$this->multiBlamesAttribute], 'default', 'value' => ''],
98	15	] : [];
99		}
100
101		/**
102		* Add specified blame.
103		* @param {$this->multiBlamesClass}\|string $blame
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}\|string` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
104		* @return false\|array
105		* @throws InvalidParamException if blame existed.
106		* @throws InvalidCallException if blame limit reached.
107		*/
108		public function addBlame($blame)
109		{
110		if (!is_string($this->multiBlamesAttribute)) {
111		return false;
112		}
113		$blameGuid = '';
114		if (is_string($blame)) {
115		$blameGuid = $blame;
116		}
117		if ($blame instanceof $this->multiBlamesClass) {
118		$blameGuid = $blame->guid;
119		}
120		$blameGuids = $this->getBlameGuids(true);
121		if (array_search($blameGuid, $blameGuids)) {
122		throw new InvalidParamException('the blame has existed.');
123		}
124		if ($this->getBlamesCount() >= $this->blamesLimit) {
125		throw new InvalidCallException("the limit($this->blamesLimit) of blames has been reached.");
126		}
127		$blameGuids[] = $blameGuid;
128		$this->setBlameGuids($blameGuids);
129		return $this->getBlameGuids();
130		}
131
132		/**
133		* Create blame.
134		* @param BaseUserModel $user who will own this blame.
135		* @param array $config blame class configuration array.
136		* @return {$this->multiBlamesClass}
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
137		*/
138		public static function createBlame($user, $config = [])
139		{
140		if (!($user instanceof BaseUserModel)) {
141		$message = 'the type of user instance must be the extended class of BaseUserModel.';
142		throw new InvalidParamException($message);
143		}
144		$mbClass = static::buildNoInitModel();
145		$mbi = $mbClass->multiBlamesClass;
146		return $user->create($mbi::className(), $config);
147		}
148
149		/**
150		* Add specified blame, or create it before adding if doesn't exist.
151		* But you should save the blame instance before adding, or the operation
152		* will fail.
153		* @param {$this->multiBlamesClass}\|string\|array $blame
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}\|string\|array` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
154		* It will be regarded as blame's guid if it is a string. And assign the
155		* reference parameter $blame the instance if it existed, or create one if not
156		* found.
157		* If it is {$this->multiBlamesClass} instance and existed, then will add it, or
158		* false will be given if it is not found in database. So if you want to add
159		* blame instance, you should save it before adding.
160		* If it is a array, it will be regarded as configuration array of blame.
161		* Notice! This parameter passed by reference, so it must be a variable!
162		* @param BaseUserModel $user whose blame.
163		* If null, it will take this blameable model's user.
164		* @return false\|array false if blame created failed or not enable this feature.
165		* blames guid array if created and added successfully.
166		* @throws InvalidConfigException
167		* @throws InvalidParamException
168		* @see addBlame()
169		*/
170		public function addOrCreateBlame(&$blame = null, $user = null)
171		{
172		if (!is_string($this->multiBlamesClass)) {
173		throw new InvalidConfigException('$multiBlamesClass must be specified if you want to use multiple blameable features.');
174		}
175		if (is_array($blame)) {
176		if ($user == null) {
177		$user = $this->user;
		0 ignored issues – show Bug introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The property `user` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
178		}
179		$blame = static::getOrCreateBlame($blame, $user);
180		if (!$blame->save()) {
181		return false;
182		}
183		return $this->addBlame($blame->guid);
184		}
185		$blameGuid = '';
186		if (is_string($blame)) {
187		$blameGuid = $blame;
188		}
189		if ($blame instanceof $this->multiBlamesClass) {
190		$blameGuid = $blame->guid;
191		}
192		if (($mbi = static::getBlame($blameGuid)) !== null) {
193		return $this->addBlame($mbi);
194		}
195		return false;
196		}
197
198		/**
199		* Remove specified blame.
200		* @param {$this->multiBlamesClass} $blame
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
201		* @return false\|array all guids in json format.
202		*/
203		public function removeBlame($blame)
204		{
205		if (!is_string($this->multiBlamesAttribute)) {
206		return false;
207		}
208		$blameGuid = '';
209		if (is_string($blame)) {
210		$blameGuid = $blame;
211		}
212		if ($blame instanceof $this->multiBlamesClass) {
213		$blameGuid = $blame->guid;
214		}
215		$blameGuids = $this->getBlameGuids(true);
216		if (($key = array_search($blameGuid, $blameGuids)) !== false) {
217		unset($blameGuids[$key]);
218		$this->setBlameGuids($blameGuids);
219		}
220		return $this->getBlameGuids();
221		}
222
223		/**
224		* Remove all blames.
225		*/
226	16	public function removeAllBlames()
227		{
228	16	$this->setBlameGuids();
229	16	}
230
231		/**
232		* Count the blames.
233		* @return integer
234		*/
235		public function getBlamesCount()
236		{
237		return count($this->getBlameGuids(true));
238		}
239
240		/**
241		* Get the guid array of blames. it may check all guids if valid before return.
242		* @param boolean $checkValid determines whether checking the blame is valid.
243		* @return array all guids in json format.
244		*/
245		public function getBlameGuids($checkValid = false)
246		{
247		$multiBlamesAttribute = $this->multiBlamesAttribute;
248		if ($multiBlamesAttribute === false) {
249		return [];
250		}
251		$guids = Number::divide_guid_bin($this->$multiBlamesAttribute);
252		if ($checkValid) {
253		$guids = $this->unsetInvalidBlames($guids);
254		}
255		return $guids;
256		}
257
258		/**
259		* Event triggered when blames list changed.
260		* @param MultipleBlameableEvent $event
261		*/
262	16	public function onBlamesChanged($event)
263		{
264	16	$sender = $event->sender;
265	16	$sender->blamesChanged = $event->blamesChanged;
266	16	}
267
268		/**
269		* Remove invalid blame guid from provided guid array.
270		* @param array $guids guid array of blames.
271		* @return array guid array of blames unset invalid.
272		*/
273	16	protected function unsetInvalidBlames($guids)
274		{
275	16	$unchecked = $guids;
276	16	$multiBlamesClass = $this->multiBlamesClass;
277	16	$mbi = $multiBlamesClass::buildNoInitModel();
278	16	foreach ($guids as $key => $guid) {
279		$blame = $multiBlamesClass::find()->where([$mbi->guidAttribute => $guid])->exists();
280		if (!$blame) {
281		unset($guids[$key]);
282		}
283		}
284	16	$diff = array_diff($unchecked, $guids);
285	16	$eventName = static::$eventMultipleBlamesChanged;
286	16	$this->trigger($eventName, new MultipleBlameableEvent(['blamesChanged' => !empty($diff)]));
		0 ignored issues – show Bug introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report It seems like `trigger()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
287	16	return $guids;
288		}
289
290		/**
291		* Set the guid array of blames, it may check all guids if valid.
292		* @param array $guids guid array of blames.
293		* @param boolean $checkValid determines whether checking the blame is valid.
294		* @return false\|array all guids.
295		*/
296	16	public function setBlameGuids($guids = [], $checkValid = true)
297		{
298	16	if (!is_array($guids) \|\| $this->multiBlamesAttribute === false) {
299		return null;
300		}
301	16	if ($checkValid) {
302	16	$guids = $this->unsetInvalidBlames($guids);
303		}
304	16	$multiBlamesAttribute = $this->multiBlamesAttribute;
305	16	$this->$multiBlamesAttribute = Number::composite_guid($guids);
306	16	return $guids;
307		}
308
309		/**
310		* Get blame.
311		* @param string $blameGuid
312		* @return {$this->multiBlamesClass}
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
313		*/
314		public static function getBlame($blameGuid)
315		{
316		$self = static::buildNoInitModel();
317		if (empty($self->multiBlamesClass) \|\| !is_string($self->multiBlamesClass) \|\| $self->multiBlamesAttribute === false) {
318		return null;
319		}
320		$mbClass = $self->multiBlamesClass;
321		return $mbClass::findOne($blameGuid);
322		}
323
324		/**
325		* Get or create blame.
326		* @param string\|array $blameGuid
327		* @param BaseUserModel $user
328		* @return {$this->multiBlamesClass}\|null
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}\|null` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
329		*/
330		public static function getOrCreateBlame($blameGuid, $user = null)
331		{
332		if (is_string($blameGuid)) {
333		$blameGuid = static::getBlame($blameGuid);
334		if ($blameGuid !== null) {
335		return $blameGuid;
336		}
337		}
338		if (is_array($blameGuid)) {
339		return static::createBlame($user, $blameGuid);
		0 ignored issues – show Bug introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report It seems like `$user` defined by parameter `$user` on line `330` can be `null`; however, `rhosocial\base\models\tr...bleTrait::createBlame()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
340		}
341		return null;
342		}
343
344		/**
345		* Get all ones to be blamed by `$blame`.
346		* @param {$this->multiBlamesClass} $blame
		0 ignored issues – show Documentation introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The doc-type `{$this->multiBlamesClass}` could not be parsed: Unknown type name "{$this-" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
347		* @return array
348		*/
349		public function getBlameds($blame)
350		{
351		$blameds = static::getBlame($blame->guid);
352		if (empty($blameds)) {
353		return null;
354		}
355		$createdByAttribute = $this->createdByAttribute;
		0 ignored issues – show Bug introduced 2017-01-12 08:52 UTC by Report Bug Copy Issue Report The property `createdByAttribute` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
356		return static::find()->where([$createdByAttribute => $this->$createdByAttribute])
357		->andWhere(['like', $this->multiBlamesAttribute, $blame->guid])->all();
358		}
359
360		/**
361		* Get all the blames of record.
362		* @return array all blames.
363		*/
364		public function getAllBlames()
365		{
366		if (empty($this->multiBlamesClass) \|\|
367		!is_string($this->multiBlamesClass) \|\|
368		$this->multiBlamesAttribute === false) {
369		return null;
370		}
371		$multiBlamesClass = $this->multiBlamesClass;
372		$createdByAttribute = $this->createdByAttribute;
373		return $multiBlamesClass::findAll([$createdByAttribute => $this->$createdByAttribute]);
374		}
375
376		/**
377		* Get all records which without any blames.
378		* @return array all non-blameds.
379		*/
380		public function getNonBlameds()
381		{
382		$createdByAttribute = $this->createdByAttribute;
383		$cond = [
384		$createdByAttribute => $this->$createdByAttribute,
385		$this->multiBlamesAttribute => ''
386		];
387		return static::find()->where($cond)->all();
388		}
389
390		/**
391		* Initialize blames limit.
392		* @param ModelEvent $event
393		*/
394	16	public function onInitBlamesLimit($event)
395		{
396	16	$sender = $event->sender;
397	16	if (!is_int($sender->blamesLimit) \|\| $sender->blamesLimit < 1 \|\| $sender->blamesLimit > 64) {
398		$sender->blamesLimit = 10;
399		}
400	16	}
401		}
402

rhosocial / yii2-base-models

Push — master ( bf148f...113cf9 )

MultipleBlameableTrait::removeAllBlames() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like