Backpack\CRUD\CrudTrait

Complexity

Total Complexity

35

Size/Duplication

Total Lines	267
Duplicated Lines	9.36 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getPossibleEnumValues()	0	16	2
A	getEnumValuesAsAssociativeArray()	0	13	2
A	isColumnNullable()	0	15	1
B	addFakes()	0	20	8
A	withFakes()	0	12	3
A	shouldDecodeFake()	0	4	1
A	shouldEncodeFake()	0	4	1
B	uploadFileToDisk()	11	31	8
B	uploadMultipleFilesToDisk()	14	36	6
A	getCastedAttributes()	0	4	1
A	translationEnabled()	0	8	2

<?php

namespace Backpack\CRUD;

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

trait CrudTrait
{
    /*
    |--------------------------------------------------------------------------
    | 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;

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

This line exceeds maximum limit of 120 characters; contains 169 characters

        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;
    }

    public static function isColumnNullable($column_name)
    {
        // create an instance of the model to be able to get the table name
        $instance = new static();

        $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?

        $table = Config::get('database.connections.'.Config::get('database.default').'.prefix').$instance->getTable();

It seems like getTable() 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->getDoctrineColumn($table, $column_name)->getNotnull();
    }

    /*
    |--------------------------------------------------------------------------
    | 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)) {

This line exceeds maximum limit of 120 characters; contains 121 characters

                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);

        if (! count($columns)) {
            $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  [type] $value            Value for that column sent from the input.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $attribute_name   Model attribute name (and column in the db).

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $disk             Filesystem disk used to store files.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $destination_path Path in disk where to store the files.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function uploadFileToDisk($value, $attribute_name, $disk, $destination_path)
    {
        $request = \Request::instance();

        // if a new file is uploaded, delete the file from the disk
        if ($request->hasFile($attribute_name) &&
            $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) {
            \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().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  [type] $value            Value for that column sent from the input.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $attribute_name   Model attribute name (and column in the db).

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $disk             Filesystem disk used to store files.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     * @param  [type] $destination_path Path in disk where to store the files.

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function uploadMultipleFilesToDisk($value, $attribute_name, $disk, $destination_path)

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

    {
        $request = \Request::instance();
        $attribute_value = (array) $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) {
            $attribute_value = (array) $this->{$attribute_name};
            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) {

The expression $request->file($attribute_name) of type object<Illuminate\Http\UploadedFile>|array|null is not guaranteed to be traversable. How about adding an additional type check?

                if ($file->isValid()) {
                    // 1. Generate a new file name
                    $new_file_name = md5($file->getClientOriginalName().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 [type] [description]

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getCastedAttributes()

The return type could not be reliably inferred; please add a @return annotation.

    {
        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\CrudTrait. Did you maybe mean translationEnabled()?

        }

        return false;
    }
}