Mascame\Artificer\Model\Model

Complexity

Total Complexity

33

Size/Duplication

Total Lines	248
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes	12
Bugs	2	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	share()	0	6	1
A	getCurrentModelsData()	0	9	2
A	isHidden()	0	4	2
A	hasGuarded()	0	4	3
A	hasFillable()	0	4	3
A	getCurrentModelName()	0	16	4
A	prepareCurrentModel()	0	15	2
A	getCurrentModelData()	0	12	1
A	isCurrent()	0	6	2
A	getCurrent()	0	4	2
A	getCurrentClass()	0	4	1
A	getRouteName()	0	6	3
A	setCurrent()	0	5	1
A	getOptions()	0	4	2
A	getOption()	0	4	2
A	getRelations()	0	4	1

<?php namespace Mascame\Artificer\Model;

use View;
use Route;
use \Illuminate\Support\Str as Str;
use Mascame\Artificer\Options\AdminOption;
use Mascame\Artificer\Options\ModelOption;

// Todo: get column type http://stackoverflow.com/questions/18562684/how-to-get-database-field-type-in-laravel
class Model
{

    /**
     * @var ModelSchema
     */
    public $schema;

    /**
     * @var array
     */
    public $models;

    /**
     * @var array
     */
    public $columns;

    /**
     * @var mixed
     */
    public $model;

    /**
     * @var string
     */
    public $class;

    /**
     * @var
     */
    public $name;

    /**
     * @var string
     */
    public $keyname;

    /**
     * @var
     */
    public $table;

    /**
     * @var
     */
    public $fillable;

    /**
     * @var array|mixed
     */
    public $options = array();

    /**
     * @var array|mixed
     */
    public $relations = array();

    /**
     * @var
     */
    public static $current = null;

    /**
     * @param ModelSchema $schema
     */
    public function __construct(ModelSchema $schema)
    {
        $this->schema = $schema;
        $this->relations = new ModelRelation();

        $this->prepareCurrentModel();
        $this->share();
    }


    public function share()
    {
        View::share('tables', $this->schema->tables);
        View::share('models', $this->getCurrentModelsData());
        View::share('model', $this->getCurrentModelData());
    }

    /**
     * @return array
     */
    private function getCurrentModelsData()
    {
        foreach ($this->schema->models as $modelName => $model) {
            $this->schema->models[$modelName]['options'] = $this->getOptions($modelName);
            $this->schema->models[$modelName]['hidden'] = $this->isHidden($modelName);
        }

        return $this->schema->models;
    }

    /**
     * @param $modelName
     * @return bool
     */
    public function isHidden($modelName)
    {
        return (in_array($modelName, AdminOption::get('models.hidden'))) ? true : false;
    }

    /**
     * @return bool
     */
    public function hasGuarded()
    {
        return (isset($this->options['guarded']) && !empty($this->options['guarded'])) ? true : false;
    }

    /**
     * @return bool
     */
    public function hasFillable()
    {
        return (isset($this->options['fillable']) && !empty($this->options['fillable'])) ? true : false;
    }

    /**
     * @return int|null|string
     */
    private function getCurrentModelName()
    {
        if ($this->name) {
            return $this->name;
        }

        foreach ($this->schema->models as $modelName => $model) {
            if ($this->isCurrent($modelName)) {
                $this->setCurrent($modelName);

                return $this->name = $modelName;
            }
        }

        return null;
    }

    public function prepareCurrentModel()
    {
        if (!Str::startsWith(Route::currentRouteName(), 'admin.model.')) {
            return null;
        }

        $this->name = $this->getCurrentModelName();

        $this->class = $this->schema->getClass($this->name);
        $this->model = $this->schema->getInstance($this->name);

It seems like $this->name can also be of type integer or string; however, Mascame\Artificer\Model\ModelSchema::getInstance() does only seem to accept null, maybe add an additional type check?

        $this->table = $this->model->getTable();
        $this->columns = $this->schema->getColumns($this->table);
        $this->fillable = $this->model->getFillable();
        $this->options = $this->getOptions();
    }

    /**
     * @return array
     */
    private function getCurrentModelData()
    {
        return array(
            'class' => $this->class,
            'name' => $this->getCurrentModelName(),
            'route' => $this->getRouteName(),
            'table' => $this->table,
            'columns' => $this->schema->columns,
            'fillable' => $this->fillable,
            'hidden' => $this->isHidden($this->name),
        );
    }

    /**
     * @param $model
     * @return bool
     */
    protected function isCurrent($modelName)
    {
        $slug = Route::current()->parameter('slug');

        return (isset($this->schema->models[$modelName]['route']) && $this->schema->models[$modelName]['route'] == $slug);
    }

    /**
     * @return null
     */
    public static function getCurrent()
    {
        return (isset(self::$current)) ? self::$current : null;
    }

    /**
     * @return string
     */
    public static function getCurrentClass()
    {
        return '\\' . self::$current;
    }

    /**
     * @param null $model
     * @return null
     */
    public function getRouteName($model = null)
    {
        if ($model) return $this->schema->models[$model]['route'];

        return (isset($this->schema->models[self::$current]['route'])) ? $this->schema->models[self::$current]['route'] : null;
    }

    /**
     * @param $modelName
     */
    protected function setCurrent($modelName)
    {
        self::$current = $modelName;
        ModelOption::set('current', $modelName);
    }

    /**
     * @param null $model
     * @return mixed
     */
    public function getOptions($model = null)
    {
        return ModelOption::model(($model) ?: $this->name);

It seems like $model ?: $this->name can also be of type integer or string; however, Mascame\Artificer\Options\ModelOption::model() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @param $key
     * @param null $model
     * @return mixed
     */
    public function getOption($key, $default = null, $model = null)
    {
        return (ModelOption::has($key, $model)) ? ModelOption::get($key, $model) : $default;
    }

    /**
     * @return array|mixed
     */
    public function getRelations()
    {
        return $this->relations->get();
    }

}