app\core\models\Rule

Complexity

Total Complexity

15

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	behaviors()	0	6	1
B	beforeSave()	0	18	8
A	rules()	0	11	1
A	tableName()	0	3	1
A	getThenCategory()	0	3	1
A	attributeLabels()	0	18	1
A	fields()	0	45	2

<?php

namespace app\core\models;

use app\core\exceptions\InvalidArgumentException;
use app\core\types\ReimbursementStatus;
use app\core\types\RuleStatus;
use app\core\types\TransactionStatus;
use app\core\types\TransactionType;
use Yii;
use yii\behaviors\TimestampBehavior;
use yiier\helpers\DateHelper;
use yiier\validators\ArrayValidator;

/**
 * This is the model class for table "{{%rule}}".
 *
 * @property int $id
 * @property int $user_id
 * @property string $name
 * @property string|array $if_keywords Multiple choice use,
 * @property int $then_transaction_type
 * @property int|null $then_category_id
 * @property int|null $then_from_account_id
 * @property int|null $then_to_account_id
 * @property int|null $then_transaction_status
 * @property int|null $then_reimbursement_status
 * @property string|null|array $then_tags Multiple choice use,
 * @property int|string $status
 * @property int|null $sort
 * @property string|null $created_at
 * @property string|null $updated_at
 *
 * @property-read Category $thenCategory
 */
class Rule extends \yii\db\ActiveRecord
{
    /**
     * {@inheritdoc}
     */
    public static function tableName()
    {
        return '{{%rule}}';
    }

    /**
     * @inheritdoc
     * @throws \yii\base\InvalidConfigException
     */
    public function behaviors()
    {
        return [
            [
                'class' => TimestampBehavior::class,
                'value' => Yii::$app->formatter->asDatetime('now')
            ],
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function rules()
    {
        return [
            [['name', 'if_keywords', 'then_transaction_type'], 'required'],
            [['user_id', 'then_category_id', 'then_from_account_id', 'then_to_account_id', 'sort'], 'integer'],
            ['status', 'in', 'range' => RuleStatus::names()],
            ['then_transaction_type', 'in', 'range' => TransactionType::names()],
            ['then_reimbursement_status', 'in', 'range' => ReimbursementStatus::names()],
            ['then_transaction_status', 'in', 'range' => TransactionStatus::names()],
            [['if_keywords', 'then_tags'], ArrayValidator::class],
            [['name'], 'string', 'max' => 255],
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function attributeLabels()
    {
        return [
            'id' => Yii::t('app', 'ID'),
            'user_id' => Yii::t('app', 'User ID'),
            'name' => Yii::t('app', 'Name'),
            'if_keywords' => Yii::t('app', 'If Keywords'),
            'then_transaction_type' => Yii::t('app', 'Then Transaction Type'),
            'then_category_id' => Yii::t('app', 'Then Category ID'),
            'then_from_account_id' => Yii::t('app', 'Then From Account ID'),
            'then_to_account_id' => Yii::t('app', 'Then To Account ID'),
            'then_transaction_status' => Yii::t('app', 'Then Transaction Status'),
            'then_reimbursement_status' => Yii::t('app', 'Then Reimbursement Status'),
            'then_tags' => Yii::t('app', 'Then Tags'),
            'status' => Yii::t('app', 'Status'),
            'sort' => Yii::t('app', 'Sort'),
            'created_at' => Yii::t('app', 'Created At'),
            'updated_at' => Yii::t('app', 'Updated At'),
        ];
    }

    /**
     * @param bool $insert
     * @return bool
     * @throws InvalidArgumentException
     */
    public function beforeSave($insert)
    {
        if (parent::beforeSave($insert)) {
            if ($insert) {
                $this->user_id = Yii::$app->user->id;

It seems like Yii::app->user->id can also be of type string. However, the property $user_id is declared as type integer. Maybe add an additional type check?

            }
            $this->then_reimbursement_status = is_null($this->then_reimbursement_status) ?
                ReimbursementStatus::NONE : ReimbursementStatus::toEnumValue($this->then_reimbursement_status);
            $this->then_transaction_status = is_null($this->then_transaction_status) ?
                TransactionStatus::DONE : TransactionStatus::toEnumValue($this->then_transaction_status);

            $this->status = is_null($this->status) ? RuleStatus::ACTIVE : RuleStatus::toEnumValue($this->status);

The condition is_null($this->status) is always false.

            $this->then_transaction_type = TransactionType::toEnumValue($this->then_transaction_type);
            $this->if_keywords = $this->if_keywords ? implode(',', $this->if_keywords) : null;

It seems like $this->if_keywords can also be of type string; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

            $this->then_tags = $this->then_tags ? implode(',', $this->then_tags) : null;
            return true;
        } else {
            return false;
        }
    }

    public function getThenCategory()
    {
        return $this->hasOne(Category::class, ['id' => 'then_category_id']);
    }

    /**
     * @return array
     */
    public function fields()
    {
        $fields = parent::fields();
        unset($fields['user_id']);

        $fields['then_transaction_type'] = function (self $model) {
            return TransactionType::getName($model->then_transaction_type);
        };

        $fields['then_transaction_type_text'] = function (self $model) {
            return data_get(TransactionType::texts(), $model->then_transaction_type);
        };

        $fields['then_tags'] = function (self $model) {
            return $model->then_tags ? explode(',', $model->then_tags) : [];

It seems like $model->then_tags can also be of type array; however, parameter $string of explode() does only seem to accept string, maybe add an additional type check?

        };
        $fields['thenCategory'] = function (self $model) {
            return $model->thenCategory;
        };

        $fields['if_keywords'] = function (self $model) {
            return explode(',', $model->if_keywords);

It seems like $model->if_keywords can also be of type array; however, parameter $string of explode() does only seem to accept string, maybe add an additional type check?

        };

        $fields['status'] = function (self $model) {
            return RuleStatus::getName($model->status);

It seems like $model->status can also be of type string; however, parameter $v of app\core\types\BaseType::getName() does only seem to accept integer, maybe add an additional type check?

        };

        $fields['then_reimbursement_status'] = function (self $model) {
            return ReimbursementStatus::getName($model->then_reimbursement_status);

It seems like $model->then_reimbursement_status can also be of type null; however, parameter $v of app\core\types\BaseType::getName() does only seem to accept integer, maybe add an additional type check?

        };

        $fields['then_transaction_status'] = function (self $model) {
            return TransactionStatus::getName($model->then_transaction_status);

It seems like $model->then_transaction_status can also be of type null; however, parameter $v of app\core\types\BaseType::getName() does only seem to accept integer, maybe add an additional type check?

        };

        $fields['created_at'] = function (self $model) {
            return DateHelper::datetimeToIso8601($model->created_at);

It seems like $model->created_at can also be of type null; however, parameter $dateStr of yiier\helpers\DateHelper::datetimeToIso8601() does only seem to accept string, maybe add an additional type check?

        };

        $fields['updated_at'] = function (self $model) {
            return DateHelper::datetimeToIso8601($model->updated_at);

It seems like $model->updated_at can also be of type null; however, parameter $dateStr of yiier\helpers\DateHelper::datetimeToIso8601() does only seem to accept string, maybe add an additional type check?

        };

        return $fields;
    }
}