andmemasin / language

src/models/BaseLanguageSetting.php

<?php
namespace andmemasin\language\models;

use andmemasin\language\interfaces\WithLanguageInterface;
use andmemasin\myabstract\MyActiveRecord;
use andmemasin\myabstract\interfaces\SettingInterface;
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  = "key";

    /** @var string  */
    public $keyColumn = "key";

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

    /** @var WithLanguageInterface */
    public $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.

                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;
        /** @var TypeInterface $type */
        $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([$type->primaryKeySingle()=>$type->{$type->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->{$type->primaryKeySingle()}=$type->{$type->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);

The expression return $typeClass::getByKey(static::typeColumn) returns the type yii\base\Model which is incompatible with the documented return type andmemasin\myabstract\TypeInterface.

    }

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

}