injitools / cms-Inji

system/Inji/Model.php

<?php
/**
 * Model
 *
 * @author Alexey Krupskiy <admin@inji.ru>
 * @link http://inji.ru/
 * @copyright 2015 Alexey Krupskiy
 * @license https://github.com/injitools/cms-Inji/blob/master/LICENSE
 */

namespace Inji;

use Inji\Model\Builder;

/**
 * Class Model
 * @package Inji
 *
 * @method static Model\Builder connection($connectionName)
 */
class Model {

    public static $loaded = [];

    /**
     * Object storage type
     *
     * @var array
     */
    public static $storage = ['type' => 'db'];

    /**
     * Object name
     *
     * @var string
     */
    public static $objectName = '';

    /**
     * Object current params
     *
     * @var array
     */
    public $_params = [];

    /**
     * List of changed params in current instance
     *
     * @var array
     */
    public $_changedParams = [];

    /**
     * Loaded relations
     *
     * @var array
     */
    public $loadedRelations = [];

    /**
     * Model name where this model uses as category
     *
     * @var string
     */
    public static $treeCategory = '';

    /**
     * Model name who uses as category in this model
     *
     * @var string
     */
    public static $categoryModel = '';

    /**
     * Col labels
     *
     * @var array
     */
    public static $labels = [];

    /**
     * Model forms
     *
     * @var array
     */
    public static $forms = [];

    /**
     * Model cols
     *
     * @var array
     */
    public static $cols = [];

    /**
     * Options group for display inforamtion from model
     *
     * @var array
     */
    public static $view = [];

    /**
     * List of relations need loaded with item
     *
     * @var array
     */
    public static $needJoin = [];

    /**
     * List of joins who need to laod
     *
     * @var array
     */
    public static $relJoins = [];

    public $connectionName = 'default';
    public $dbOptions = [];
    public $app;

    /**
     * Set params when model create
     *
     * @param array $params
     * @param App $app
     */
    public function __construct($params = [], $app = null) {
        $this->setParams($params);
        if (!$app) {
            $this->app = App::$primary;
        } else {
            $this->app = $app;
        }
    }

    public static function create($params = [], $app = null) {
        return new static($params, $app);
    }

    public static function __callStatic($name, $arguments) {
        if (method_exists('Inji\Model\Builder', $name)) {
            return call_user_func_array([new Model\Builder(get_called_class()), $name], $arguments);
        }
        trigger_error('Undefined method ' . $name . ' in Inji\Model', E_USER_ERROR);
    }

    public static $logging = true;

    /**
     * return object name
     *
     * @return string
     */
    public static function objectName() {
        return static::$objectName;
    }

    /**
     * Retrn col value with col params and relations path
     *
     * @param Model $object
     * @param string $valuePath
     * @param boolean $convert
     * @param boolean $manageHref
     * @return string
     */
    public static function getColValue($object, $valuePath, $convert = false, $manageHref = false) {
        if (is_array($object)) {
            $object = array_shift($object);
        }
        if (strpos($valuePath, ':')) {
            $rel = substr($valuePath, 0, strpos($valuePath, ':'));
            $param = substr($valuePath, strpos($valuePath, ':') + 1);
            if (!$object->$rel) {
                $modelName = get_class($object);
                $relations = $modelName::relations();
                if (empty($relations[$rel]['type']) || $relations[$rel]['type'] == 'one') {
                    return $object->{$relations[$rel]['col']};
                }
                return 0;
            }
            if (strpos($valuePath, ':')) {
                return self::getColValue($object->$rel, $param, $convert, $manageHref);
            } else {
                return $convert ? Model::resloveTypeValue($object->$rel, $param, $manageHref) : $object->$rel->$param;
            }
        } else {
            return $convert ? Model::resloveTypeValue($object, $valuePath, $manageHref) : $object->$valuePath;
        }
    }

    /**
     * Retrun value for view
     *
     * @param Model $item
     * @param string $colName
     * @param boolean $manageHref
     * @param array $params
     * @return string
     */
    public static function resloveTypeValue($item, $colName, $manageHref = false, $colInfo = []) {
        $modelName = get_class($item);
        if (!$colInfo) {
            $colInfo = $modelName::getColInfo($colName);
        }
        $type = !empty($colInfo['colParams']['type']) ? $colInfo['colParams']['type'] : 'string';
        $value = '';
        switch ($type) {
            case 'autocomplete':
                $options = $colInfo['colParams']['options'];
                if (isset($options['snippet']) && is_string($options['snippet'])) {
                    $snippets = \App::$cur->Ui->getSnippets('autocomplete');
                    if (isset($snippets[$options['snippet']])) {
                        $value = $snippets[$options['snippet']]['getValueText']($item->$colName, $options['snippetParams']);
                    }
                }
                break;
            case 'select':
                switch ($colInfo['colParams']['source']) {
                    case 'model':
                        $sourceValue = '';
                        if ($item->$colName) {
                            $sourceValue = $colInfo['colParams']['model']::get($item->$colName);
                        }
                        $value = $sourceValue ? $sourceValue->name() : 'Не задано';
                        break;
                    case 'array':
                        $value = !empty($colInfo['colParams']['sourceArray'][$item->$colName]) ? $colInfo['colParams']['sourceArray'][$item->$colName] : 'Не задано';
                        if (is_array($value) && $value['text']) {
                            $value = $value['text'];
                        }
                        break;
                    case 'bool':
                        return $item->$colName ? 'Да' : 'Нет';
                    case 'method':
                        if (!empty($colInfo['colParams']['params'])) {
                            $values = call_user_func_array([App::$cur->{$colInfo['colParams']['module']}, $colInfo['colParams']['method']],
                                $colInfo['colParams']['params'] + [$item]
                            );
                        } else {
                            $values = \App::$cur->{$colInfo['colParams']['module']}->{$colInfo['colParams']['method']}($item);
                        }
                        $value = !empty($values[$item->$colName]) ? $values[$item->$colName] : 'Не задано';
                        break;
                    case 'void':
                        if (!empty($modelName::$cols[$colName]['value']['type']) && $modelName::$cols[$colName]['value']['type'] == 'moduleMethod') {

The property cols does not exist on string.

                            return \App::$cur->{$modelName::$cols[$colName]['value']['module']}->{$modelName::$cols[$colName]['value']['method']}($item, $colName, $modelName::$cols[$colName]);
                        }
                        break;
                    case 'relation':
                        if (strpos($colInfo['colParams']['relation'], ':')) {
                            $relationPath = explode(':', $colInfo['colParams']['relation']);
                            $relationName = array_pop($relationPath);
                            $curItem = $item;
                            foreach ($relationPath as $path) {
                                $curItem = $curItem->$path;
                            }
                            $itemModel = get_class($curItem);
                            $relation = $itemModel::getRelation($relationName);
                            $relModel = $relation['model'];
                        } else {
                            $itemModel = get_class($item);
                            $relation = $itemModel::getRelation($colInfo['colParams']['relation']);
                            $relModel = $relation['model'];
                        }
                        $relValue = $relModel::get($item->$colName);
                        $relModel = strpos($relModel, '\\') === 0 ? substr($relModel, 1) : $relModel;
                        if ($manageHref) {
                            $value = $relValue ? "<a href='/admin/" . str_replace('\\', '/view/', $relModel) . "/" . $relValue->pk() . "'>" . $relValue->name() . "</a>" : 'Не задано';
                        } else {
                            $value = $relValue ? $relValue->name() : 'Не задано';
                        }
                        break;
                }
                break;
            case 'image':
                $file = Files\File::get($item->$colName);
                if ($file) {
                    $photoId = Tools::randomString();
                    $value = '<a href = "' . $file->path . '" id="' . $photoId . '" rel="fgall[allimg]"><img src="' . $file->path . '?resize=60x120" /></a>';
                    $value .= '<script>inji.onLoad(function(){$("[rel]").fancybox();});</script>';
                } else {
                    $value = '<img src="/static/system/images/no-image.png?resize=60x120" />';
                }
                break;
            case 'file':
                $file = Files\File::get($item->$colName);
                if ($file) {
                    $value = '<a href="' . $file->path . '">' . $file->name . '.' . $file->type->ext . '</a>';
                } else {
                    $value = 'Файл не загружен';
                }
                break;
            case 'bool':
                $value = $item->$colName ? 'Да' : 'Нет';
                break;
            case 'void':
                if (!empty($colInfo['colParams']['value']['type']) && $colInfo['colParams']['value']['type'] == 'moduleMethod') {
                    return \App::$cur->{$colInfo['colParams']['value']['module']}->{$colInfo['colParams']['value']['method']}($item, $colName, $colInfo['colParams']);
                }
                break;
            case 'map':
                if ($item->$colName && json_decode($item->$colName, true)) {
                    $addres = json_decode($item->$colName, true);
                    $name = $addres['address'] ? $addres['address'] : 'lat:' . $addres['lat'] . ': lng:' . $addres['lng'];
                    \App::$cur->libs->loadLib('yandexMap');
                    ob_start();
                    $uid = Tools::randomString();
                    ?>
                    <div id='map<?= $uid; ?>_container' style="display:none;">
                        <script>/*
                             <div id='map<?= $uid; ?>' style="width: 100%; height: 500px"></div>
                             <script>
                             var myMap<?= $uid; ?>;
                             var myMap<?= $uid; ?>CurPin;
                             inji.onLoad(function () {
                             ymaps.ready(init<?= $uid; ?>);
                             function init<?= $uid; ?>() {
                             var myPlacemark;
                             myMap<?= $uid; ?> = new ymaps.Map("map<?= $uid; ?>", {
                             center: ["<?= $addres['lat'] ?>", "<?= $addres['lng']; ?>"],
                             zoom: 13
                             });
                             myCoords = ["<?= $addres['lat'] ?>", "<?= $addres['lng']; ?>"];
                             myMap<?= $uid; ?>CurPin = new ymaps.Placemark(myCoords,
                             {iconContent: "<?= $addres['address']; ?>"},
                             {preset: 'islands#greenStretchyIcon'}
                             );
                             myMap<?= $uid; ?>.geoObjects.add(myMap<?= $uid; ?>CurPin, 0);
                             }
                             window['init<?= $uid; ?>'] = init<?= $uid; ?>;
                             });
                             */</script>
                    </div>
                    <?php
                    $content = ob_get_contents();
                    ob_end_clean();
                    $onclick = 'inji.Ui.modals.show("' . addcslashes($addres['address'], '"') . '", $("#map' . $uid . '_container script").html().replace(/^\/\*/g, "").replace(/\*\/$/g, "")+"</script>","mapmodal' . $uid . '","modal-lg");';
                    $onclick .= 'return false;';
                    $value = "<a href ='#' onclick='{$onclick}' >{$name}</a>";
                    $value .= $content;
                } else {
                    $value = 'Местоположение не заданно';
                }

                break;
            case 'dynamicType':
                switch ($colInfo['colParams']['typeSource']) {
                    case 'selfMethod':
                        $type = $item->{$colInfo['colParams']['selfMethod']}();
                        if (is_array($type)) {
                            $value = static::resloveTypeValue($item, $colName, $manageHref, ['colParams' => $type]);
                        } else {
                            $value = static::resloveTypeValue($item, $colName, $manageHref, ['colParams' => ['type' => $type]]);
                        }
                        break;
                }
                break;
            default:
                $value = $item->$colName;
        }
        return $value;
    }

    /**
     * Fix col prefix
     *
     * @param mixed $array
     * @param string $searchtype
     * @param string $rootModel
     * @return null
     */
    public static function fixPrefix(&$array, $searchtype = 'key', $rootModel = '') {
        if (!$rootModel) {
            $rootModel = get_called_class();
        }
        $cols = static::cols();
        if (!$array) {
            return;
        }
        if (!is_array($array)) {
            if (!isset($cols[static::colPrefix() . $array]) && isset(static::$cols[$array])) {
                static::createCol($array);
                $cols = static::cols();
            }
            if (!isset($cols[$array]) && isset($cols[static::colPrefix() . $array])) {
                $array = static::colPrefix() . $array;
            } else {
                static::checkForJoin($array, $rootModel);
            }
            return;
        }
        switch ($searchtype) {
            case 'key':
                foreach ($array as $key => $item) {
                    if (!isset($cols[static::colPrefix() . $key]) && isset(static::$cols[$key])) {
                        static::createCol($key);
                        $cols = static::cols(true);
                    }
                    if (!isset($cols[$key]) && isset($cols[static::colPrefix() . $key])) {
                        $array[static::colPrefix() . $key] = $item;
                        unset($array[$key]);
                        $key = static::colPrefix() . $key;
                    }
                    if (is_array($array[$key])) {
                        static::fixPrefix($array[$key], 'key', $rootModel);
                    } else {
                        static::checkForJoin($key, $rootModel);
                    }
                }
                break;
            case 'first':
                if (isset($array[0]) && is_string($array[0])) {
                    if (!isset($cols[static::colPrefix() . $array[0]]) && isset(static::$cols[$array[0]])) {
                        static::createCol($array[0]);
                        $cols = static::cols();
                    }
                    if (!isset($cols[$array[0]]) && isset($cols[static::colPrefix() . $array[0]])) {
                        $array[0] = static::colPrefix() . $array[0];
                    } else {
                        static::checkForJoin($array[0], $rootModel);
                    }
                } elseif (isset($array[0]) && is_array($array[0])) {
                    foreach ($array as &$item) {
                        static::fixPrefix($item, 'first', $rootModel);
                    }
                }
                break;
        }
    }

    /**
     * @param boolean $new
     */
    public function logChanges($new) {
        if (!App::$cur->db->connect || !App::$cur->dashboard) {

The property dashboard does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

            return false;
        }
        $class = get_class($this);
        if (!Model::$logging || !$class::$logging || (is_string($class::$logging) && $class::$logging != ($new ? 'new' : 'changes'))) {

The property logging does not exist on string.

            return false;
        }
        $user_id = class_exists('Users\User') ? \Users\User::$cur->id : 0;
        if (!$new && !empty($this->_changedParams)) {
            $activity = new Dashboard\Activity([
                'user_id' => $user_id,
                'module' => substr($class, 0, strpos($class, '\\')),
                'model' => $class,
                'item_id' => $this->pk(),
                'type' => 'changes'
            ]);
            $changes_text = [];
            foreach ($this->_changedParams as $fullColName => $oldValue) {
                $colName = substr($fullColName, strlen($class::colPrefix()));
                if (isset($class::$cols[$colName]['logging']) && $class::$cols[$colName]['logging'] === false) {

The property cols does not exist on string.

                    continue;
                }
                if (!isset($class::$cols[$colName]['logging']) || $class::$cols[$colName]['logging'] !== 'noValue') {
                    $oldValueText = $oldValue;
                    if (isset($class::$cols[$colName]) && $class::$cols[$colName]['type'] === 'select') {
                        switch ($class::$cols[$colName]['source']) {
                            case 'array':
                                $oldValueText = isset($class::$cols[$colName]['sourceArray'][$oldValue]) ? $class::$cols[$colName]['sourceArray'][$oldValue] : $oldValue;
                                break;
                            case 'relation':
                                $relation = $class::getRelation($class::$cols[$colName]['relation']);
                                $relModel = $relation['model'];
                                $rel = $relModel::get($oldValue);
                                if ($rel) {
                                    $oldValueText = $rel->name();
                                }
                        }
                    }
                    $newValueText = $this->$colName;
                    if (isset($class::$cols[$colName]) && $class::$cols[$colName]['type'] === 'select') {
                        switch ($class::$cols[$colName]['source']) {
                            case 'array':
                                $newValueText = isset($class::$cols[$colName]['sourceArray'][$this->$colName]) ? $class::$cols[$colName]['sourceArray'][$this->$colName] : $this->$colName;
                                break;
                            case 'relation':
                                $relation = $class::getRelation($class::$cols[$colName]['relation']);
                                $relModel = $relation['model'];
                                $rel = $relModel::get($this->$colName);
                                if ($rel) {
                                    $newValueText = $rel->name();
                                }
                        }
                    }
                }
                if ((!isset($class::$cols[$colName]['logging']) || $class::$cols[$colName]['logging'] !== 'noValue') && strlen($oldValueText) + strlen($newValueText) < 200) {

The variable $newValueText does not seem to be defined for all execution paths leading up to this point.

The variable $oldValueText does not seem to be defined for all execution paths leading up to this point.

                    $changes_text[] = (!empty($class::$labels[$colName]) ? $class::$labels[$colName] : $colName) . ": \"{$oldValueText}\" => \"{$newValueText}\"";

The property labels does not exist on string.

                } else {
                    $changes_text[] = !empty($class::$labels[$colName]) ? $class::$labels[$colName] : $colName;
                }
            }
            if (!$changes_text) {
                return false;
            }
            $activity->changes_text = implode(', ', $changes_text);
            $activity->save();
            foreach ($this->_changedParams as $fullColName => $oldValue) {
                $colName = substr($fullColName, strlen($class::colPrefix()));
                if (isset($class::$cols[$colName]['logging']) && !$class::$cols[$colName]['logging']) {
                    continue;
                }
                $colName = substr($fullColName, strlen($class::colPrefix()));
                $change = new Dashboard\Activity\Change([

The type Inji\Dashboard\Activity\Change was not found. Did you mean Dashboard\Activity\Change? If so, make sure to prefix the type with \.

                    'activity_id' => $activity->id,
                    'col' => $colName,
                    'old' => $oldValue,
                    'new' => $this->$colName
                ]);
                $change->save();
            }
        } elseif ($new) {
            $activity = new Dashboard\Activity([
                'user_id' => $user_id,
                'module' => substr($class, 0, strpos($class, '\\')),
                'model' => $class,
                'item_id' => $this->pk(),
                'type' => 'new'
            ]);
            $activity->save();
        }
        return true;
    }

    /**
     * Check model relations path and load need relations
     *
     * @param string $col
     * @param string $rootModel
     */
    public static function checkForJoin(&$col, $rootModel) {

        if (strpos($col, ':') !== false) {
            $relations = static::relations();
            if (isset($relations[substr($col, 0, strpos($col, ':'))])) {
                $rel = substr($col, 0, strpos($col, ':'));
                $col = substr($col, strpos($col, ':') + 1);
                $type = empty($relations[$rel]['type']) ? 'to' : $relations[$rel]['type'];
                $joinName = $relations[$rel]['model'] . '_' . $rel;
                switch ($type) {
                    case 'to':
                        $relCol = $relations[$rel]['col'];
                        static::fixPrefix($relCol);
                        $rootModel::$relJoins[$joinName] = [$relations[$rel]['model']::table(), $relations[$rel]['model']::index() . ' = ' . $relCol, 'left', ''];

The property relJoins does not exist on string.

                        break;
                    case 'one':
                    case 'many':
                        $relCol = $relations[$rel]['col'];
                        $relations[$rel]['model']::fixPrefix($relCol);
                        $rootModel::$relJoins[$joinName] = [$relations[$rel]['model']::table(), static::index() . ' = ' . $relCol, 'left', ''];
                        break;
                    case 'relModel':
                        $relation = $relations[$rel];
                        $fixedCol = $relation['model']::index();
                        $relation['relModel']::fixPrefix($fixedCol);
                        $joinName = $relations[$rel]['relModel'] . '_' . $rel;
                        $rootModel::$relJoins[$joinName] = [$relation['relModel']::table(), $relation['relModel']::colPrefix() . static::index() . ' = ' . static::index(), 'INNER'];
                        $joinName = $relations[$rel]['model'] . '_' . $rel;
                        $rootModel::$relJoins[$joinName] = [$relation['model']::table(), $relation['relModel']::colPrefix() . $relation['model']::index() . ' = ' . $relation['model']::index(), 'INNER'];
                        //$rootModel::$relJoins[$joinName] = [$relations[$rel]['model']::table(), static::index() . ' = ' . $relCol, 'left', ''];

69% of this comment could be valid code. Did you maybe forget this after debugging?

                        break;
                }
                $relations[$rel]['model']::fixPrefix($col, 'key', $rootModel);
            }
        }
    }

    /**
     * Return full col information
     *
     * @param string $col
     * @return array
     */
    public static function getColInfo($col) {
        return static::parseColRecursion($col);
    }

    /**
     * Information extractor for col relations path
     *
     * @param string $info
     * @return array
     */
    public static function parseColRecursion($info) {
        if (is_string($info)) {
            $info = ['col' => $info, 'rawCol' => $info, 'rawModel' => get_called_class(), 'modelName' => get_called_class(), 'label' => $info, 'joins' => []];
        }
        if ($info['col'] === 'id') {
            $info['colParams'] = [
                'type' => 'number',
            ];
            return $info;
        }
        if (strpos($info['col'], ':') !== false) {
            $relations = static::relations();
            if (isset($relations[substr($info['col'], 0, strpos($info['col'], ':'))])) {
                $rel = substr($info['col'], 0, strpos($info['col'], ':'));
                $info['col'] = substr($info['col'], strpos($info['col'], ':') + 1);
                //$info['modelName'] = $relations[$rel]['model'];

80% of this comment could be valid code. Did you maybe forget this after debugging?

                $type = empty($relations[$rel]['type']) ? 'to' : $relations[$rel]['type'];
                $joinName = $relations[$rel]['model'] . '_' . $rel;
                switch ($type) {
                    case 'to':
                        $relCol = $relations[$rel]['col'];
                        static::fixPrefix($relCol);
                        $info['joins'][$joinName] = [$relations[$rel]['model']::table(), $relations[$rel]['model']::index() . ' = ' . $relCol];
                        break;
                    case 'one':
                        $relCol = $relations[$rel]['col'];
                        $relations[$rel]['model']::fixPrefix($relCol);
                        $info['joins'][$joinName] = [$relations[$rel]['model']::table(), static::index() . ' = ' . $relCol];
                        break;
                }
                $info = $relations[$rel]['model']::parseColRecursion($info);
            }
        } else {
            $cols = static::cols();
            if (!empty(static::$labels[$info['col']])) {
                $info['label'] = static::$labels[$info['col']];
            }

            if (isset(static::$cols[$info['col']])) {
                $info['colParams'] = static::$cols[$info['col']];
            } elseif (isset(static::$cols[str_replace(static::colPrefix(), '', $info['col'])])) {
                $info['colParams'] = static::$cols[str_replace(static::colPrefix(), '', $info['col'])];
            } else {
                $info['colParams'] = [];
            }
            if (!isset($cols[$info['col']]) && isset($cols[static::colPrefix() . $info['col']])) {
                $info['col'] = static::colPrefix() . $info['col'];
            }
        }
        if (!empty(static::$labels[$info['rawCol']])) {
            $info['label'] = static::$labels[$info['rawCol']];
        }
        return $info;
    }

    /**
     * Return actual cols from data base
     *
     * @param boolean $refresh
     * @return array
     */
    public static function cols($refresh = false) {
        if (static::$storage['type'] == 'moduleConfig') {
            return [];
        }
        if (empty(\Inji\Model::$cols[static::table()]) || $refresh) {
            \Inji\Model::$cols[static::table()] = App::$cur->db->getTableCols(static::table());

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

The method getTableCols() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

The method getTableCols() does not exist on null.

        }
        if (!isset(\Inji\Model::$cols[static::table()])) {
            static::createTable();
            \Inji\Model::$cols[static::table()] = App::$cur->db->getTableCols(static::table());
        }
        return \Inji\Model::$cols[static::table()];
    }

    /**
     * Return cols indexes for create tables
     *
     * @return array
     */
    public static function indexes() {
        return [];
    }

    /**
     * Generate params string for col by name
     *
     * @param string $colName
     * @return false|string
     */
    public static function genColParams($colName) {
        if (empty(static::$cols[$colName]) || static::$storage['type'] == 'moduleConfig') {
            return false;
        }
        $null = ' NULL';
        if (empty(static::$cols[$colName]['null'])) {
            $null = ' NOT NULL';
        }

        $params = false;
        switch (static::$cols[$colName]['type']) {
            case 'select':
                switch (static::$cols[$colName]['source']) {
                    case 'relation':
                        $params = 'int(11) UNSIGNED' . $null;
                        break;
                    default:
                        $params = 'varchar(255)' . $null;
                }
                break;
            case 'image':
            case 'file':
                $params = 'int(11) UNSIGNED' . $null;
                break;
            case 'number':
                $params = 'int(11)' . $null;
                break;
            case 'text':
            case 'email':
                $params = 'varchar(255)' . $null;
                break;
            case 'html':
            case 'textarea':
            case 'json':
            case 'password':
            case 'dynamicType':
            case 'map':
                $params = 'text' . $null;
                break;
            case 'bool':
                $params = 'tinyint(1) UNSIGNED' . $null;
                break;
            case 'decimal':
                $params = 'decimal(8, 2)' . $null;
                break;
            case 'time':
                $params = 'time' . $null;
                break;
            case 'date':
                $params = 'date' . $null;
                break;
            case 'dateTime':
                $params = 'timestamp' . $null;
                break;
        }
        return $params;
    }

    /**
     * Create new col in data base
     *
     * @param string $colName
     * @return boolean|integer
     */
    public static function createCol($colName) {
        $cols = static::cols();
        if (!empty($cols[static::colPrefix() . $colName])) {
            return true;
        }
        $params = static::genColParams($colName);
        if ($params === false) {
            return false;
        }
        $result = App::$cur->db->addCol(static::table(), static::colPrefix() . $colName, $params);

The method addCol() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

        static::cols(true);
        return $result;
    }

    public static function createTable() {
        if (static::$storage['type'] == 'moduleConfig') {
            return true;
        }
        if (!App::$cur->db) {

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

            return false;
        }

        $query = App::$cur->db->newQuery();

The method newQuery() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

        if (!$query) {
            return false;
        }

        if (!isset($this)) {

The variable $this seems to never exist and therefore isset should always be false.

            $tableName = static::table();
            $colPrefix = static::colPrefix();
            $indexes = static::indexes();
        } else {
            $tableName = $this->table();
            $colPrefix = $this->colPrefix();
            $indexes = $this->indexes();
        }
        if (App::$cur->db->tableExist($tableName)) {

The method tableExist() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

            return true;
        }
        $cols = [
            $colPrefix . 'id' => 'pk'
        ];
        $className = get_called_class();
        if (!empty($className::$cols)) {

The property cols does not exist on string.

            foreach ($className::$cols as $colName => $colParams) {
                if ($colName == 'date_create') {
                    $cols[$colPrefix . 'date_create'] = 'timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP';
                    continue;
                }
                $params = $className::genColParams($colName);
                if ($params) {
                    $cols[$colPrefix . $colName] = $params;
                }
            }
        }
        if (empty($cols[$colPrefix . 'date_create'])) {
            $cols[$colPrefix . 'date_create'] = 'timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP';
        }
        $tableIndexes = [];
        if ($indexes) {
            foreach ($indexes as $indexName => $index) {
                $tableIndexes[] = $index['type'] . ' ' . App::$cur->db->table_prefix . $indexName . ' (' . implode(',', $index['cols']) . ')';

The property table_prefix does not seem to exist on Inji\Module.

            }
        }

        $query->createTable($tableName, $cols, $tableIndexes);
        return true;
    }

    /**
     * Return table name
     *
     * @return string
     */
    public static function table() {
        return strtolower(str_replace('\\', '_', get_called_class()));
    }

    /**
     * Return table index col name
     *
     * @return string
     */
    public static function index() {
        return 'id';
    }

    /**
     * Return col prefix
     *
     * @return string
     */
    public static function colPrefix() {
        $classPath = explode('\\', get_called_class());
        $classPath = array_slice($classPath, 2);
        return strtolower(implode('_', $classPath)) . '_';
    }

    /**
     * return relations list
     *
     * @return array
     */
    public static function relations() {
        return [];
    }

    /**
     * views list
     *
     * @return array
     */
    public static $views = [];

    /**
     * Return name of col with object name
     *
     * @return string
     */
    public static function nameCol() {
        return 'name';
    }

    /**
     * Return object name
     *
     * @return string
     */
    public function name() {
        return $this->{$this->nameCol()} ? $this->{$this->nameCol()} : '№' . $this->pk();
    }

    /**
     * Get single object from data base
     *
     * @param mixed $param
     * @param string $col
     * @param array $options
     * @return boolean|static
     */
    public static function get($param, $col = null, $options = []) {
        $builder = new Builder(get_called_class());
        foreach ($options as $optionName => $option) {
            $builder->$optionName($option);
        }
        if (is_array($param)) {
            $builder->where($param);
        } else {
            $builder->where($col === null ? static::index() : $col, $param);
        }
        return $builder->get();
        if (static::$storage['type'] == 'moduleConfig') {

IfNode is not reachable.

            return static::getFromModuleStorage($param, $col, $options);
        }
        if (!empty($col)) {
            static::fixPrefix($col);
        }

        if (is_array($param)) {
            static::fixPrefix($param, 'first');
        }
        $query = App::$cur->db->newQuery();
        foreach (static::$relJoins as $join) {
            $query->join($join);
        }
        static::$relJoins = [];
        foreach (static::$needJoin as $rel) {
            $relations = static::relations();
            if (isset($relations[$rel])) {
                $type = empty($relations[$rel]['type']) ? 'to' : $relations[$rel]['type'];
                switch ($type) {
                    case 'to':
                        $relCol = $relations[$rel]['col'];
                        static::fixPrefix($relCol);
                        $query->join($relations[$rel]['model']::table(), $relations[$rel]['model']::index() . ' = ' . $relCol);
                        break;
                    case 'one':
                        $col = $relations[$rel]['col'];
                        $relations[$rel]['model']::fixPrefix($col);
                        $query->join($relations[$rel]['model']::table(), static::index() . ' = ' . $col);
                        break;
                }
            }
        }
        static::$needJoin = [];
        if (is_array($param)) {
            $query->where($param);
        } else {
            if ($col === null) {

                $col = static::index();
            }
            if ($param !== null) {
                $cols = static::cols();
                if (!isset($cols[$col]) && isset($cols[static::colPrefix() . $col])) {
                    $col = static::colPrefix() . $col;
                }
                $query->where($col, $param);
            } else {
                return false;
            }
        }
        if (!$query->where) {
            return false;
        }
        try {
            $result = $query->select(static::table());
        } catch (\PDOException $exc) {
            if ($exc->getCode() == '42S02') {
                static::createTable();
            } else {
                throw $exc;
            }
            $result = $query->select(static::table());
        }
        if (!$result) {
            return false;
        }
        return $result->fetch(get_called_class());
    }

    /**
     * Old method
     *
     * @param type $options

The type Inji\type was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return Array
     */
    public static function get_list($options = [], $debug = false) {
        $query = App::$cur->db->newQuery();

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

        if (!$query) {
            return [];
        }
        if (!empty($options['where'])) {
            $query->where($options['where']);
        }
        if (!empty($options['cols'])) {
            $query->cols = $options['cols'];
        }
        if (!empty($options['group'])) {
            $query->group($options['group']);
        }
        if (!empty($options['having'])) {
            $query->having($options['having']);
        }
        if (!empty($options['order'])) {
            $query->order($options['order']);
        }
        if (!empty($options['join'])) {
            $query->join($options['join']);
        }
        if (!empty($options['distinct'])) {
            $query->distinct = $options['distinct'];
        }

        foreach (static::$needJoin as $rel) {
            $relations = static::relations();
            foreach ($query->join as $item) {
                if ($item[0] === $relations[$rel]['model']::table() && $item[3] === '') {
                    continue 2;
                }
            }
            if (isset($relations[$rel])) {
                $type = empty($relations[$rel]['type']) ? 'to' : $relations[$rel]['type'];
                switch ($type) {
                    case 'to':
                        $relCol = $relations[$rel]['col'];
                        static::fixPrefix($relCol);
                        $query->join($relations[$rel]['model']::table(), $relations[$rel]['model']::index() . ' = ' . $relCol);
                        break;
                    case 'one':
                        $col = $relations[$rel]['col'];
                        $relations[$rel]['model']::fixPrefix($col);
                        $query->join($relations[$rel]['model']::table(), static::index() . ' = ' . $col);
                        break;
                }
            }
        }
        static::$needJoin = [];

        foreach (static::$relJoins as $join) {
            foreach ($query->join as $item) {
                if ($item[0] === $join[0] && $item[3] === $join[3]) {
                    continue 2;
                }
            }
            $query->join($join);
        }
        static::$relJoins = [];
        if (!empty($options['limit'])) {
            $limit = (int)$options['limit'];
        } else {
            $limit = 0;
        }
        if (!empty($options['start'])) {
            $start = (int)$options['start'];
        } else {
            $start = 0;
        }
        if ($limit || $start) {
            $query->limit($start, $limit);
        }
        if (isset($options['key'])) {
            $key = $options['key'];
        } else {
            $key = static::index();
        }

        if ($debug) {
            $query->operation = 'SELECT';
            $query->table = static::table();
            return $query->buildQuery();
        }
        try {
            $query->operation = 'SELECT';
            $query->table = static::table();
            $queryArr = $query->buildQuery();
            $result = $query->query($queryArr);
        } catch (PDOException $exc) {

The type Inji\PDOException was not found. Did you mean PDOException? If so, make sure to prefix the type with \.

            if ($exc->getCode() == '42S02') {
                static::createTable();
                $result = $query->query($queryArr);

The variable $queryArr does not seem to be defined for all execution paths leading up to this point.

            } else {
                throw $exc;
            }
        }

        if (!empty($options['array'])) {
            static::fixPrefix($key);
            return $result->getArray($key);
        }
        $list = $result->getObjects(get_called_class(), $key);
        if (!empty($options['forSelect'])) {
            $return = [];
            foreach ($list as $key => $item) {
                $return[$key] = $item->name();
            }
            return $return;
        }
        return $list;
    }

    /**
     * Return list of objects from data base
     *
     * @param array $options
     * @return static[]
     */
    public static function getList($options = [], $debug = false) {
        $builder = new Builder(get_called_class());
        foreach ($options as $optionName => $option) {
            $builder->$optionName($option);
        }
        return $builder->getList();

The expression return $builder->getList() also could return the type boolean which is incompatible with the documented return type array<mixed,Inji\Model>.

        if (static::$storage['type'] != 'db') {

IfNode is not reachable.

            return static::getListFromModuleStorage($options);
        }
        if (!empty($options['where'])) {
            static::fixPrefix($options['where'], 'first');
        }
        if (!empty($options['group'])) {
            static::fixPrefix($options['group'], 'first');
        }
        if (!empty($options['order'])) {
            static::fixPrefix($options['order'], 'first');
        }
        if (!empty($options['having'])) {
            static::fixPrefix($options['having'], 'first');
        }
        return static::get_list($options, $debug);
    }


    /**
     * Return count of records from data base
     *
     * @param array $options
     * @return array|int
     */
    public static function getCount($options = []) {
        $builder = new Builder(get_called_class());
        foreach ($options as $optionName => $option) {
            $builder->$optionName($option);
        }
        $builder->count('*');
        return $builder->get();

The expression return $builder->get() returns the type false which is incompatible with the documented return type integer|array.

        foreach (static::$needJoin as $rel) {

ForeachNode is not reachable.

            $relations = static::relations();
            foreach ($query->join as $item) {
                if ($item[0] === $relations[$rel]['model']::table() && $item[3] === '') {
                    continue 2;
                }
            }
            if (isset($relations[$rel])) {
                $type = empty($relations[$rel]['type']) ? 'to' : $relations[$rel]['type'];
                switch ($type) {
                    case 'to':
                        $relCol = $relations[$rel]['col'];
                        static::fixPrefix($relCol);
                        $query->join($relations[$rel]['model']::table(), $relations[$rel]['model']::index() . ' = ' . $relCol);
                        break;
                    case 'one':
                        $col = $relations[$rel]['col'];
                        $relations[$rel]['model']::fixPrefix($col);
                        $query->join($relations[$rel]['model']::table(), static::index() . ' = ' . $col);
                        break;
                }
            }
        }
        static::$needJoin = [];
        foreach (static::$relJoins as $join) {
            foreach ($query->join as $item) {
                if ($item[0] === $join[0] && $item[3] === $join[3]) {
                    continue 2;
                }
            }
            $query->join($join);
        }
        static::$relJoins = [];
        $cols = 'COUNT(';

        if (!empty($options['distinct'])) {
            if (is_bool($options['distinct'])) {
                $cols .= 'DISTINCT *';
            } else {
                $cols .= "DISTINCT {$options['distinct']}";
            }
        } else {
            $cols .= '*';
        }
        $cols .= ') as `count`' . (!empty($options['cols']) ? ',' . $options['cols'] : '');
        $query->cols = $cols;
        if (!empty($options['group'])) {
            $query->group($options['group']);
        }
        try {
            $result = $query->select(static::table());
        } catch (PDOException $exc) {
            if ($exc->getCode() == '42S02') {
                static::createTable();
            } else {
                throw $exc;
            }
            $result = $query->select(static::table());
        }
        if (!empty($options['group'])) {
            $count = $result->getArray();
            return $count;
        } else {
            $count = $result->fetch();
            return $count['count'];
        }
    }

    /**
     * Update records in data base
     *
     * @param array $params
     * @param array $where
     * @return false|null
     */
    public static function update($params, $where = []) {
        static::fixPrefix($params);

        $cols = self::cols();

        $values = [];
        foreach ($cols as $col => $param) {
            if (isset($params[$col])) {
                $values[$col] = $params[$col];
            }
        }
        if (empty($values)) {
            return false;
        }

        if (!empty($where)) {
            static::fixPrefix($where, 'first');

            App::$cur->db->where($where);

The method where() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

        }
        App::$cur->db->update(static::table(), $values);

The method update() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

    }

    /**
     * Return primary key of object
     *
     * @return mixed
     */
    public function pk() {
        return $this->{$this->index()};
    }

    /**
     * Before save trigger
     */
    public function beforeSave() {

    }


    /**
     * Update tree path category
     */
    public function changeCategoryTree() {
        $class = get_class($this);
        $itemModel = $class::$treeCategory;

The property treeCategory does not exist on string.

        $oldPath = $this->tree_path;
        $newPath = $this->getCatalogTree($this);
        $itemsTable = \App::$cur->db->table_prefix . $itemModel::table();
        $itemTreeCol = $itemModel::colPrefix() . 'tree_path';
        $categoryTreeCol = $this->colPrefix() . 'tree_path';
        $categoryTable = \App::$cur->db->table_prefix . $this->table();
        if ($oldPath) {
            \App::$cur->db->query('UPDATE
                ' . $categoryTable . ' 
                    SET 
                        ' . $categoryTreeCol . ' = REPLACE(' . $categoryTreeCol . ', "' . $oldPath . $this->id . '/' . '", "' . $newPath . $this->id . '/' . '") 

The property id does not exist on Inji\Model. Since you implemented __get, consider adding a @property annotation.

                    WHERE ' . $categoryTreeCol . ' LIKE "' . $oldPath . $this->id . '/' . '%"');

            \App::$cur->db->query('UPDATE
                ' . $itemsTable . '
                    SET 
                        ' . $itemTreeCol . ' = REPLACE(' . $itemTreeCol . ', "' . $oldPath . $this->id . '/' . '", "' . $newPath . $this->id . '/' . '") 
                    WHERE ' . $itemTreeCol . ' LIKE "' . $oldPath . $this->id . '/' . '%"');
        }
        $itemModel::update([$itemTreeCol => $newPath . $this->id . '/'], [$itemModel::colPrefix() . $this->index(), $this->id]);
        $this->tree_path = $newPath;

The property tree_path does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * Return tree path
     *
     * @param \Inji\Model $catalog
     * @return string
     */
    public function getCatalogTree($catalog) {
        $catalogClass = get_class($catalog);
        $catalogParent = $catalogClass::get($catalog->parent_id);

The property parent_id does not exist on Inji\Model. Since you implemented __get, consider adding a @property annotation.

        if ($catalog && $catalogParent) {
            if ($catalogParent->tree_path) {
                return $catalogParent->tree_path . $catalogParent->id . '/';
            } else {
                return $this->getCatalogTree($catalogParent) . $catalogParent->id . '/';
            }
        }
        return '/';
    }

    /**
     * Update tree path item
     */
    public function changeItemTree() {
        $class = get_class($this);
        $categoryModel = $class::$categoryModel;

The property categoryModel does not exist on string.

        $category = $categoryModel::get($this->{$categoryModel::index()});
        if ($category) {
            $this->tree_path = $category->tree_path . $category->pk() . '/';

The property tree_path does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        } else {
            $this->tree_path = '/';
        }
    }

    /**
     * Save object to data base
     *
     * @param array $options
     * @return boolean|int
     */
    public function save($options = []) {

        $builder = new Builder(get_called_class(), $this->app);
        $builder->connection($this->connectionName);
        foreach ($this->dbOptions as $dbOption => $value) {
            $builder->setDbOption($dbOption, $value);
        }
        $class = get_called_class();
        if (!empty($this->_changedParams) && $this->pk()) {
            \Inji::$inst->event('modelItemParamsChanged-' . $class, $this);
        }
        $this->beforeSave();
        $values = [];

        foreach (static::$cols as $col => $param) {
            if (isset($this->_params[$col]) && (!$this->pk() || ($this->pk() && isset($this->_changedParams[$col])))) {
                $values[$col] = $this->_params[$col];
            }
        }
        if (!$this->pk()) {
            foreach ($class::$cols as $colName => $params) {

The property cols does not exist on string.

                if (isset($params['default']) && !isset($values[$colName])) {
                    $this->_params[$colName] = $values[$colName] = $params['default'];
                }
            }
        }
        if (empty($values) && empty($options['empty'])) {
            return false;
        }
        if (static::$categoryModel) {
            $this->changeItemTree();
        }
        if (static::$treeCategory) {
            $this->changeCategoryTree();
        }
        $new = !$this->pk();

        if ($new) {
            $builder->where(static::index(), $builder->insert($values));
        } else {

            $builder->where(static::index(), $this->pk());
            $builder->update($values);
        }
        $this->logChanges($new);
        $this->_params = $builder->get(['array' => true]);

It seems like $builder->get(array('array' => true)) of type false is incompatible with the declared type array of property $_params.

        if ($new) {
            \Inji::$inst->event('modelCreatedItem-' . get_called_class(), $this);
        }
        $this->afterSave();
        return $this->pk();
    }

    /**
     * After save trigger
     */
    public function afterSave() {

    }

    /**
     * Before delete trigger
     */
    public function beforeDelete() {

    }

    /**
     * Delete item from data base
     *
     * @param array $options
     * @return boolean
     */
    public function delete($options = []) {
        $this->beforeDelete();
        if (!empty($this->pk())) {
            $builder = new Builder(get_called_class(), $this->app);
            $builder->connection($this->connectionName);
            foreach ($this->dbOptions as $dbOption => $value) {
                $builder->setDbOption($dbOption, $value);
            }
            $builder->where($this->index(), $this->pk());
            $result = $builder->delete();
            if ($result) {
                $this->afterDelete();
                return $result;
            }
        }
        return false;
    }

    /**
     * Delete items from data base
     *
     * @param array $where
     */
    public static function deleteList($where = []) {
        if (!empty($where)) {
            static::fixPrefix($where, 'first');
            App::$cur->db->where($where);

The property db does not exist on Inji\App. Since you implemented __get, consider adding a @property annotation.

        }
        App::$cur->db->delete(static::table());

The method delete() does not exist on Inji\Module. It seems like you code against a sub-type of Inji\Module such as Inji\Db.

    }

    /**
     * After delete trigger
     */
    public function afterDelete() {

    }

    /**
     * find relation for col name
     *
     * @param string $col
     * @return array|null
     */
    public static function findRelation($col) {

        foreach (static::relations() as $relName => $rel) {
            if ($rel['col'] == $col) {
                return $relName;
            }
        }
        return null;
    }

    /**
     * Set params for model
     *
     * @param array $params
     */
    public function setParams($params) {
        foreach ($params as $paramName => $value) {
            $this->$paramName = $value;
        }
    }

    /**
     * Return relation
     *
     * @param string $relName
     * @return array|boolean
     */
    public static function getRelation($relName) {
        $relations = static::relations();
        return !empty($relations[$relName]) ? $relations[$relName] : false;
    }

    /**
     * Load relation
     *
     * @param string $name
     * @param array $params
     * @return null|array|integer|\Model
     */
    public function loadRelation($name, $params = []) {
        $relation = static::getRelation($name);
        if ($relation) {
            if (!isset($relation['type'])) {
                $type = 'to';
            } else {
                $type = $relation['type'];
            }
            $getCol = null;
            $getParams = [];
            switch ($type) {
                case 'relModel':
                    if (!$this->pk()) {
                        return [];
                    }
                    $fixedCol = $relation['model']::index();
                    $relation['relModel']::fixPrefix($fixedCol);
                    $join = [$relation['relModel']::table(), $relation['relModel']::colPrefix() . $this->index() . ' = ' . $this->pk() . ' and ' . $relation['relModel']::colPrefix() . $relation['model']::index() . ' = ' . $relation['model']::index(), 'INNER'];
                    $getType = 'getList';
                    $options = [
                        'cols' => (isset($params['cols'])) ? $params['cols'] : ((isset($relation['cols'])) ? $relation['cols'] : null),
                        'join' => [$join],
                        'where' => (isset($params['where'])) ? $params['where'] : ((isset($relation['where'])) ? $relation['where'] : null),
                        'array' => (!empty($params['array'])) ? true : false,
                        'key' => (isset($params['key'])) ? $params['key'] : ((isset($relation['resultKey'])) ? $relation['resultKey'] : null),
                        'start' => (isset($params['start'])) ? $params['start'] : ((isset($relation['start'])) ? $relation['start'] : null),
                        'order' => (isset($params['order'])) ? $params['order'] : ((isset($relation['order'])) ? $relation['order'] : null),
                        'limit' => (isset($params['limit'])) ? $params['limit'] : ((isset($relation['limit'])) ? $relation['limit'] : null),
                    ];
                    break;
                case 'many':
                    if (!$this->{$this->index()}) {
                        return [];
                    }
                    $getType = 'getList';
                    $options = [
                        'cols' => (isset($params['cols'])) ? $params['cols'] : ((isset($relation['cols'])) ? $relation['cols'] : null),
                        'join' => (isset($relation['join'])) ? $relation['join'] : null,
                        'key' => (isset($params['key'])) ? $params['key'] : ((isset($relation['resultKey'])) ? $relation['resultKey'] : null),
                        'array' => (!empty($params['array'])) ? true : false,
                        'forSelect' => !empty($params['forSelect']),
                        'order' => (isset($params['order'])) ? $params['order'] : ((isset($relation['order'])) ? $relation['order'] : null),
                        'start' => (isset($params['start'])) ? $params['start'] : ((isset($relation['start'])) ? $relation['start'] : null),
                        'limit' => (isset($params['limit'])) ? $params['limit'] : ((isset($relation['limit'])) ? $relation['limit'] : null),
                        'where' => []
                    ];
                    $options['where'][] = [$relation['col'], $this->{$this->index()}];
                    if (!empty($relation['where'])) {
                        $options['where'] = array_merge($options['where'], [$relation['where']]);
                    }
                    if (!empty($params['where'])) {
                        $options['where'] = array_merge($options['where'], [$params['where']]);
                    }
                    break;
                case 'one':
                    $getType = 'get';
                    $options = [$relation['col'], $this->pk()];
                    break;
                default:
                    if ($this->{$relation['col']} === null) {
                        return null;
                    }
                    $getType = 'get';
                    $options = $this->{$relation['col']};
            }
            if (!empty($params['count'])) {
                if (class_exists($relation['model'])) {
                    return $relation['model']::getCount($options);
                }
                return 0;
            } else {
                if (class_exists($relation['model'])) {
                    $this->loadedRelations[$name][json_encode($params)] = $relation['model']::$getType($options, $getCol, $getParams);
                } else {
                    $this->loadedRelations[$name][json_encode($params)] = [];
                }
            }
            return $this->loadedRelations[$name][json_encode($params)];
        }
        return null;
    }

    /**
     * Add relation item
     *
     * @param string $relName
     * @param \Inji\Model $objectId
     * @return \Inji\Model|boolean
     */
    public function addRelation($relName, $objectId) {
        $relation = $this->getRelation($relName);
        if ($relation) {
            $rel = $relation['relModel']::get([[$relation['model']::index(), $objectId], [$this->index(), $this->pk()]]);
            if (!$rel) {
                $rel = new $relation['relModel']([
                    $relation['model']::index() => $objectId,
                    $this->index() => $this->pk()
                ]);
                $rel->save();
            }
            return $rel;
        }
        return false;
    }

    /**
     * Check user access for form
     *
     * @param string $formName
     * @return boolean
     */
    public function checkFormAccess($formName) {
        if ($formName == 'manage' && !Users\User::$cur->isAdmin()) {
            return false;
        }
        return true;
    }

    /**
     * Check access for model
     *
     * @param string $mode
     * @param \Users\User $user
     * @return boolean
     */
    public function checkAccess($mode = 'write', $user = null) {
        if (!$user) {
            $user = \Users\User::$cur;
        }
        return $user->isAdmin();
    }

    /**
     * Param and relation with params getter
     *
     * @param string $name
     * @param array $params
     * @return \Value|mixed

The type Value was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function __call($name, $params) {
        $fixedName = $name;
        static::fixPrefix($fixedName);
        if (isset($this->_params[$fixedName])) {
            return new Value($this, $fixedName);
        } elseif (isset($this->_params[$name])) {
            return new Value($this, $name);
        } elseif (!empty($params[0]) && isset($this->loadedRelations[$name][json_encode($params[0])])) {
            return $this->loadedRelations[$name][json_encode($params[0])];
        }
        return call_user_func_array([$this, 'loadRelation'], array_merge([$name], $params));
    }

    /**
     * Param and relation getter
     *
     * @param string $name
     * @return mixed
     */
    public function __get($name) {
        if (isset($this->_params[$name])) {
            return $this->_params[$name];
        }
        if (isset($this->loadedRelations[$name][json_encode([])])) {
            return $this->loadedRelations[$name][json_encode([])];
        }
        return $this->loadRelation($name);
    }

    /**
     * Return model value in object
     *
     * @param string $name
     * @return \Value|null
     */
    public function value($name) {
        $fixedName = $name;
        static::fixPrefix($fixedName);
        if (isset($this->_params[$fixedName])) {
            return new Value($this, $fixedName);

The expression return new Inji\Value($this, $fixedName) returns the type Inji\Value which is incompatible with the documented return type null|Value.

        } elseif ($this->_params[$name]) {
            return new Value($this, $name);

The expression return new Inji\Value($this, $name) returns the type Inji\Value which is incompatible with the documented return type null|Value.

        }
        return null;
    }

    /**
     * Return manager filters
     *
     * @return array
     */
    public static function managerFilters() {
        return [];
    }

    /**
     * Return validators for cols
     *
     * @return array
     */
    public static function validators() {
        return [];
    }

    /**
     * Return validator by name
     *
     * @param string $name
     * @return array
     */
    public static function validator($name) {
        $validators = static::validators();
        if (!empty($validators[$name])) {
            return $validators[$name];
        }
        return [];
    }

    public function genViewLink() {
        $className = get_class($this);
        $link = substr($className, 0, strpos($className, '\\'));
        $link .= '/view/';
        $link .= str_replace('\\', '%5C', substr($className, strpos($className, '\\') + 1));
        $link .= "/{$this->id}";

The property id does not exist on Inji\Model. Since you implemented __get, consider adding a @property annotation.

        return $link;
    }

    public function extract($model) {
        $params = [];
        if (empty($this->_params[$model::index()])) {
            return false;
        }
        $params['id'] = $this->_params[$model::index()];
        $indexes = array_keys($this->_params);
        foreach ($model::$cols as $colName => $colParams) {
            if (in_array($model::colPrefix() . $colName, $indexes)) {
                $params[$model::colPrefix() . $colName] = $this->_params[$model::colPrefix() . $colName];
            }
        }
        if (!$params) {

The expression $params of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return FALSE;
        }
        return new $model($params);
    }

    /**
     * Set handler for model params
     *
     * @param string $name
     * @param mixed $value
     */
    public function __set($name, $value) {
        //static::fixPrefix($name);

86% of this comment could be valid code. Did you maybe forget this after debugging?

        $className = get_called_class();
        $shortName = $name;
        if (!$value && !empty(static::$cols[$shortName]) && in_array('emptyValue', array_keys(static::$cols[$shortName]))) {
            $value = static::$cols[$shortName]['emptyValue'];
        }
        if (is_null($value) && empty(static::$cols[$shortName]['null'])) {
            $value = '';
        }
        if (!empty($className::$cols[$shortName])) {

The property cols does not exist on string.

            switch ($className::$cols[$shortName]['type']) {
                case 'decimal':
                    $value = (float)$value;
                    break;
                case 'number':
                    $value = (int)$value;
                    break;
                case 'bool':
                    $value = (bool)$value;
                    break;
            }
        }
        if (isset($this->_params[$name]) && $this->_params[$name] != $value && !isset($this->_changedParams[$name])) {
            $this->_changedParams[$name] = $this->_params[$name];
        }
        $this->_params[$name] = $value;
    }

    /**
     * Isset handler for model params
     *
     * @param string $name
     * @return boolean
     */
    public function __isset($name) {
        static::fixPrefix($name);
        return isset($this->_params[$name]);
    }

    /**
     * Convert object to string
     *
     * @return string
     */
    public function __toString() {
        return $this->name();
    }
}