Backpack\CRUD\CrudTrait

Complexity

Total Complexity

28

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	2
Bugs	2	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	addFakes()	0	18	5
A	translations()	0	11	2
A	getPossibleEnumValues()	0	12	2
A	isColumnNullable()	0	6	2
A	withFakes()	0	17	3
B	allTranslations()	0	25	3
A	translation()	0	14	3
A	translationLanguages()	0	16	3
A	language()	0	4	1
A	save()	0	15	4

<?php namespace Backpack\CRUD;

use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use DB;
use Lang;

trait CrudTrait {

    /*
    |--------------------------------------------------------------------------
    | Methods for ENUM and SELECT crud fields.
    |--------------------------------------------------------------------------
    */

    public static function getPossibleEnumValues($field_name){
        $instance = new static; // create an instance of the model to be able to get the table name
        $type = DB::select( DB::raw('SHOW COLUMNS FROM '.$instance->getTable().' WHERE Field = "'.$field_name.'"') )[0]->Type;

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        preg_match('/^enum\((.*)\)$/', $type, $matches);
        $enum = array();
        $exploded = explode(',', $matches[1]);
        foreach($exploded as $value){
            $v = trim( $value, "'" );
            $enum[] = $v;
        }
        return $enum;
    }

    public static function isColumnNullable($column_name) {
        $instance = new static; // create an instance of the model to be able to get the table name
        $answer = DB::select(DB::raw("SELECT IS_NULLABLE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='".$instance->getTable()."' AND COLUMN_NAME='".$column_name."' AND table_schema='".env('DB_DATABASE')."'"))[0];

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return ($answer->IS_NULLABLE == 'YES' ? true : false);
    }


    /*
    |--------------------------------------------------------------------------
    | Methods for Fake Fields functionality (used in PageManager).
    |--------------------------------------------------------------------------
    */

    /**
     * Add fake fields as regular attributes, even though they are stored as JSON.
     *
     * @param  array  $columns - the database columns that contain the JSONs
     */
    public function addFakes($columns = ['extras']) {
        foreach ($columns as $key => $column) {

            $column_contents = $this->{$column};

            if (!is_object($this->{$column}))
            {
                $column_contents = json_decode($this->{$column});
            }

            if (count($column_contents))
            {
                foreach ($column_contents as $fake_field_name => $fake_field_value) {
                    $this->setAttribute($fake_field_name, $fake_field_value);

It seems like setAttribute() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                }
            }
        }
    }

    /**
     * Return the entity with fake fields as attributes.
     *
     * @param  array  $columns - the database columns that contain the JSONs
     * @return CrudTrait

The return type CrudTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     */
    public function withFakes($columns = [])
    {
        $model = '\\'.get_class($this);

        if (!count($columns)) {
            if (property_exists($model, 'fakeColumns')) {
                $columns = $this->fakeColumns;

The property fakeColumns does not exist. Did you maybe forget to declare it?

            } else
            {
                $columns = ['extras'];
            }
        }

        $this->addFakes($columns);

        return $this;
    }

    /*
    |--------------------------------------------------------------------------
    | Translation Methods
    |--------------------------------------------------------------------------
    */

    public function translations()
    {
        $model = '\\'.get_class($this);

        if (isset($this->translatable))
        {
            return $model::where('translation_of', $this->id)->get();

The property id does not exist. Did you maybe forget to declare it?

        }

        return collect();
    }

    // get translations plus current item, plus original
    public function allTranslations()
    {
        $model = '\\'.get_class($this);

        // the translations
        $translations = $this->translations();

        $all_translations = new Collection();
        // the original
        if ($this->translation_of) {
            $original = $model::find($this->translation_of);

The property translation_of does not exist. Did you maybe forget to declare it?

            $all_translations = $all_translations->push($original);

            // get all translations from the original
            $translationsOfOriginal = $model::where('translation_of', $original->id)->get();
            foreach($translationsOfOriginal as $translation) {
                $all_translations->push($translation);
            }
        } else {
            // prepend the translation to be first in the list of translations
            $all_translations = $translations->prepend($this);
        }

        return $all_translations;
    }

    public function translation($translation_lang = false)
    {
        if ($translation_lang == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            $translation_lang = Lang::locale();
        }

        $model = '\\'.get_class($this);
        if (isset($this->translatable))
        {
            return $model::where('translation_of', $this->id)->where('translation_lang', $translation_lang)->first();
        }

        return false;
    }

    public function translationLanguages()
    {
        $model = '\\'.get_class($this);

$model is not used, you could remove the assignment.

        $translations = $this->translations();

        $translated_in = [];

        if ($translations->count())
        {
            foreach ($translations as $key => $translation) {
                $translated_in[] = $translation->language;
            }
        }

        return collect($translated_in);
    }

    public function language()
    {
        return $this->belongsTo('\Dick\TranslationManager\Models\Language', 'translation_lang', 'abbr');

It seems like belongsTo() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Overwriting the Eloquent save() method, to set a default translation language, if necessary.
     */
    public function save(array $options = [])
    {
        if (isset($this->translatable))
        {
            // set a default language (the one the user is currently using)
            if (!(isset($this->translation_lang)) || $this->translation_lang == '')
            {
                $this->translation_lang = \Lang::locale();

The property translation_lang does not exist. Did you maybe forget to declare it?

            }

            // TODO: if some untranslatable attributes are empty, but its parent's are filled, copy them
        }

        parent::save($options);
    }

}