Backpack\CRUD\app\Models\Traits\CrudTrait

Complexity

Total Complexity

44

Size/Duplication

Total Lines	339
Duplicated Lines	10.32 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	hasCrudTrait()	0	4	1
A	getPossibleEnumValues()	0	16	2
A	getEnumValuesAsAssociativeArray()	0	13	2
A	getColumnType()	0	7	1
A	getConnectionWithExtraTypeMappings()	0	13	1
A	getTableWithPrefix()	0	7	1
A	isColumnNullable()	0	24	3
B	addFakes()	0	20	8
A	withFakes()	0	14	5
A	shouldDecodeFake()	0	4	1
A	shouldEncodeFake()	0	4	1
B	uploadFileToDisk()	21	29	8
B	uploadMultipleFilesToDisk()	14	38	7
A	getCastedAttributes()	0	4	1
A	translationEnabled()	0	8	2

<?php

namespace Backpack\CRUD\app\Models\Traits;

use DB;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Config;
use Traversable;

//use Backpack\CRUD\app\Models\Traits\HasIdentifiableAttribute;

trait CrudTrait
{
    use HasIdentifiableAttribute;

    public static function hasCrudTrait()
    {
        return true;
    }

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

    public static function getPossibleEnumValues($field_name)
    {
        $default_connection = Config::get('database.default');
        $table_prefix = Config::get('database.connections.'.$default_connection.'.prefix');

        $instance = new static(); // create an instance of the model to be able to get the table name
        $connectionName = $instance->getConnectionName();

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

        $type = DB::connection($connectionName)->select(DB::raw('SHOW COLUMNS FROM `'.$table_prefix.$instance->getTable().'` WHERE Field = "'.$field_name.'"'))[0]->Type;

The method getTable() does not exist on Backpack\CRUD\app\Models\Traits\CrudTrait. Did you maybe mean getTableWithPrefix()?

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

        return $enum;
    }

    public static function getEnumValuesAsAssociativeArray($field_name)
    {
        $instance = new static();
        $enum_values = $instance->getPossibleEnumValues($field_name);

        $array = array_flip($enum_values);

        foreach ($array as $key => $value) {
            $array[$key] = $key;
        }

        return $array;
    }

    /**
     * Register aditional types in doctrine schema manager for the current connection.
     *
     * @return DB
     */
    public function getConnectionWithExtraTypeMappings()
    {
        $instance = new self;

        $conn = DB::connection($instance->getConnectionName());

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

        // register the enum, json and jsonb column type, because Doctrine doesn't support it
        $conn->getDoctrineSchemaManager()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
        $conn->getDoctrineSchemaManager()->getDatabasePlatform()->registerDoctrineTypeMapping('json', 'json_array');
        $conn->getDoctrineSchemaManager()->getDatabasePlatform()->registerDoctrineTypeMapping('jsonb', 'json_array');

        return $conn;
    }

    /**
     * Get the model's table name, with the prefix added from the configuration file.
     *
     * @return string Table name with prefix
     */
    public function getTableWithPrefix()
    {
        $prefix = Config::get('database.connections.'.$this->getConnectionName().'.prefix');

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

        $tableName = $this->getTable();

The method getTable() does not exist on Backpack\CRUD\app\Models\Traits\CrudTrait. Did you maybe mean getTableWithPrefix()?

        return $prefix.$tableName;
    }

    /**
     * Get the column type for a certain db column.
     *
     * @param  string $columnName Name of the column in the db table.
     * @return string             Db column type.
     */
    public function getColumnType($columnName)
    {
        $conn = $this->getConnectionWithExtraTypeMappings();
        $table = $this->getTableWithPrefix();

        return $conn->getSchemaBuilder()->getColumnType($table, $columnName);
    }

    /**
     * Checks if the given column name is nullable.
     *
     * @param string $column_name The name of the db column.
     * @return bool
     */
    public static function isColumnNullable($column_name)
    {
        // create an instance of the model to be able to get the table name
        $instance = new static();

        $conn = $instance->getConnectionWithExtraTypeMappings();
        $table = $instance->getTableWithPrefix();

        // MongoDB columns are alway nullable
        if ($conn->getConfig()['driver'] === 'mongodb') {
            return true;
        }

        try {
            // check if the column exists in the database
            $column = $conn->getDoctrineColumn($table, $column_name);
            // check for NOT NULL
            $notNull = $column->getNotnull();
            // return the value of nullable (aka the inverse of NOT NULL)
            return ! $notNull;
        } catch (\Exception $e) {
            return true;
        }
    }

    /*
    |--------------------------------------------------------------------------
    | 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) {
            if (! isset($this->attributes[$column])) {

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

                continue;
            }

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

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

            if ((is_array($column_contents) || is_object($column_contents) || $column_contents instanceof Traversable)) {
                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 Model

Should the return type not be CrudTrait?

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

        $columnCount = ((is_array($columns) || $columns instanceof Countable) ? count($columns) : 0);

The class Backpack\CRUD\app\Models\Traits\Countable does not exist. Did you forget a USE statement, or did you not list all dependencies?

        if ($columnCount == 0) {
            $columns = (property_exists($model, 'fakeColumns')) ? $this->fakeColumns : ['extras'];

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

        }

        $this->addFakes($columns);

        return $this;
    }

    /**
     * Determine if this fake column should be json_decoded.
     *
     * @param $column string fake column name
     *
     * @return bool
     */
    public function shouldDecodeFake($column)
    {
        return ! in_array($column, array_keys($this->casts));

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

    }

    /**
     * Determine if this fake column should get json_encoded or not.
     *
     * @param $column string fake column name
     *
     * @return bool
     */
    public function shouldEncodeFake($column)
    {
        return ! in_array($column, array_keys($this->casts));
    }

    /*
    |--------------------------------------------------------------------------
    | Methods for storing uploaded files (used in CRUD).
    |--------------------------------------------------------------------------
    */

    /**
     * Handle file upload and DB storage for a file:
     * - on CREATE
     *     - stores the file at the destination path
     *     - generates a name
     *     - stores the full path in the DB;
     * - on UPDATE
     *     - if the value is null, deletes the file and sets null in the DB
     *     - if the value is different, stores the different file and updates DB value.
     *
     * @param string $value            Value for that column sent from the input.
     * @param string $attribute_name   Model attribute name (and column in the db).
     * @param string $disk             Filesystem disk used to store files.
     * @param string $destination_path Path in disk where to store the files.
     */
    public function uploadFileToDisk($value, $attribute_name, $disk, $destination_path)
    {
        // if a new file is uploaded, delete the file from the disk
        if (request()->hasFile($attribute_name) &&

This code seems to be duplicated across your project.

            $this->{$attribute_name} &&
            $this->{$attribute_name} != null) {
            \Storage::disk($disk)->delete($this->{$attribute_name});
            $this->attributes[$attribute_name] = null;
        }

        // if the file input is empty, delete the file from the disk
        if (is_null($value) && $this->{$attribute_name} != null) {

This code seems to be duplicated across your project.

            \Storage::disk($disk)->delete($this->{$attribute_name});
            $this->attributes[$attribute_name] = null;
        }

        // if a new file is uploaded, store it on disk and its filename in the database
        if (request()->hasFile($attribute_name) && request()->file($attribute_name)->isValid()) {

This code seems to be duplicated across your project.

            // 1. Generate a new file name
            $file = request()->file($attribute_name);
            $new_file_name = md5($file->getClientOriginalName().random_int(1, 9999).time()).'.'.$file->getClientOriginalExtension();

            // 2. Move the new file to the correct path
            $file_path = $file->storeAs($destination_path, $new_file_name, $disk);

            // 3. Save the complete path to the database
            $this->attributes[$attribute_name] = $file_path;
        }
    }

    /**
     * Handle multiple file upload and DB storage:
     * - if files are sent
     *     - stores the files at the destination path
     *     - generates random names
     *     - stores the full path in the DB, as JSON array;
     * - if a hidden input is sent to clear one or more files
     *     - deletes the file
     *     - removes that file from the DB.
     *
     * @param string $value            Value for that column sent from the input.
     * @param string $attribute_name   Model attribute name (and column in the db).
     * @param string $disk             Filesystem disk used to store files.
     * @param string $destination_path Path in disk where to store the files.
     */
    public function uploadMultipleFilesToDisk($value, $attribute_name, $disk, $destination_path)

The parameter $value is not used and could be removed.

    {
        if (! is_array($this->{$attribute_name})) {
            $attribute_value = json_decode($this->{$attribute_name}, true) ?? [];
        } else {
            $attribute_value = $this->{$attribute_name};
        }
        $files_to_clear = request()->get('clear_'.$attribute_name);

        // if a file has been marked for removal,
        // delete it from the disk and from the db
        if ($files_to_clear) {
            foreach ($files_to_clear as $key => $filename) {
                \Storage::disk($disk)->delete($filename);
                $attribute_value = array_where($attribute_value, function ($value, $key) use ($filename) {

The parameter $key is not used and could be removed.

                    return $value != $filename;
                });
            }
        }

        // if a new file is uploaded, store it on disk and its filename in the database
        if (request()->hasFile($attribute_name)) {

This code seems to be duplicated across your project.

            foreach (request()->file($attribute_name) as $file) {
                if ($file->isValid()) {
                    // 1. Generate a new file name
                    $new_file_name = md5($file->getClientOriginalName().random_int(1, 9999).time()).'.'.$file->getClientOriginalExtension();

                    // 2. Move the new file to the correct path
                    $file_path = $file->storeAs($destination_path, $new_file_name, $disk);

                    // 3. Add the public path to the database
                    $attribute_value[] = $file_path;
                }
            }
        }

        $this->attributes[$attribute_name] = json_encode($attribute_value);
    }

    /*
    |--------------------------------------------------------------------------
    | Methods for working with translatable models.
    |--------------------------------------------------------------------------
    */

    /**
     * Get the attributes that were casted in the model.
     * Used for translations because Spatie/Laravel-Translatable
     * overwrites the getCasts() method.
     *
     * @return self
     */
    public function getCastedAttributes()
    {
        return parent::getCasts();

It seems like you call parent on a different method (getCasts() instead of getCastedAttributes()). Are you sure this is correct? If so, you might want to change this to $this->getCasts().

    }

    /**
     * Check if a model is translatable.
     * All translation adaptors must have the translationEnabledForModel() method.
     *
     * @return bool
     */
    public function translationEnabled()
    {
        if (method_exists($this, 'translationEnabledForModel')) {
            return $this->translationEnabledForModel();

The method translationEnabledForModel() does not exist on Backpack\CRUD\app\Models\Traits\CrudTrait. Did you maybe mean translationEnabled()?

        }

        return false;
    }
}