andmemasin\language\models\BaseLanguageSetting

Complexity

Total Complexity

14

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	findOneByKey()	0	6	1
A	getSetting()	0	30	5
A	behaviors()	0	7	1
A	rules()	0	8	1
A	getLanguage()	0	3	1
A	getType()	0	5	1
A	init()	0	9	4

<?php
namespace andmemasin\language\models;

use andmemasin\language\interfaces\WithLanguageInterface;
use andmemasin\myabstract\MyActiveRecord;
use andmemasin\myabstract\src\interfaces\SettingInterface;

The type andmemasin\myabstract\src\interfaces\SettingInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use andmemasin\myabstract\TypeInterface;
use yii\base\InvalidConfigException;

/**
 * Class BaseLanguageSetting
 * @property integer $language_id
 * @property integer $is_default
 * @property string $value
 *
 * @property Language $language
 * @property TypeInterface $type
 *
 * @package andmemasin\language\models
 */
class BaseLanguageSetting extends MyActiveRecord implements  SettingInterface {

    /** @var string $typeColumn the column containing setting type id */
    protected static $typeColumn;

    /** @var string $typeClass Class of setting */
    protected  static $typeClass;

    /** @var WithLanguageInterface */
    protected $parent;


    /** {@inheritdoc} */
    public function init()
    {
        parent::init();
        if($this->insert()){
            if(!$this->parent){
                throw new InvalidConfigException('Parent Model must be defined while initiating languages-settings');
            }
            if(!$this->parent instanceof WithLanguageInterface){

$this->parent is always a sub-type of andmemasin\language\interfaces\WithLanguageInterface. If $this->parent can have other possible types, add them to models/BaseLanguageSetting.php:29.

                throw new InvalidConfigException('Parent Model must implement ModelWithLanguages');
            }

        }
    }

    /**
     * {@inheritdoc}
     */
    public function rules()
    {
        return array_merge([
            [['is_default', 'language_id'], 'integer'],
            [['language_id', 'value'], 'required'],
            [['value'], 'string'],
            [['language_id'], 'exist', 'skipOnError' => true, 'targetClass' => Language::class, 'targetAttribute' => ['language_id' => 'language_id']],
        ],  parent::rules());
    }

    /**
     * @param MyActiveRecord $parent
     * @param Language $language
     * @param string $key
     * @return bool|static|array
     */
    public static function getSetting($parent, $language, $key){

        /** @var TypeInterface $typeClass */
        $typeClass = static::$typeClass;
        $type = $typeClass::getByKey($key);

        if(!empty($type)){
            /** @var BaseLanguageSetting $model */
            $query = static::find();
            if(!empty($parent)){
                $query->andWhere([$parent::primaryKeySingle() =>$parent->primaryKey]);
            }
            $model =$query->andWhere(['language_id'=>$language->primaryKey])
                ->andWhere([$typeClass::primaryKeySingle()=>$type->{$typeClass::primaryKeySingle()}])
                ->one();

            if(empty($model)){
                /** @var BaseLanguageSetting $model */
                $model = \Yii::createObject(['class'=>static::class]);
                $model->language_id = $language->primaryKey;
                if(!empty($parent)){
                    $model->{$parent::primaryKeySingle()} = $parent->primaryKey;
                }
                $model->{$typeClass::primaryKeySingle()}=$type->{$typeClass::primaryKeySingle()};

            }
            return $model;
        }

        throw new InvalidConfigException('Undefined type key: ' . $key);

    }


    /**
     * {@inheritdoc}
     */
    public function behaviors()
    {
        return array_merge([
            'actionlog' => [
                'class' => 'andmemasin\actionlog\behaviors\ActionLogBehavior',
            ],
        ], parent::behaviors());
    }

    /**
     * @return \yii\db\ActiveQuery
     */
    public function getLanguage()
    {
        return $this->hasOne(Language::class, ['language_id' => 'language_id']);
    }


    /**
     * @return TypeInterface
     */
    public function getType()
    {
        /** @var TypeInterface $typeClass */
        $typeClass = static::$typeClass;
        return $typeClass::getByKey(static::$typeColumn);
    }

    /**
     * @param $key string
     * @return static
     */
    public function findOneByKey($key){
        /** @var static $model */
        $model = static::find()
            ->andWhere([static::$typeColumn => $key])
            ->one();
        return $model;
    }

}