CrudTrait::getUploadedImageFromDisk() - Code Metrics - Inspection of "fixed some UI and javascript bugs" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#124)

by Owen

created 2016-09-21 12:58 UTC

CrudTrait::getUploadedImageFromDisk() B

↳ Parent: CrudTrait

Complexity

Conditions	6
Paths	7

Size

Total Lines	33
Code Lines	22

Duplication

Lines	5
Ratio	15.15 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	6
eloc	22
c	1
b	1
f	0
nc	7
nop	3
dl	5
loc	33
rs	8.439

<?php

namespace Backpack\CRUD;

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

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;
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        preg_match('/^enum\((.*)\)$/', $type, $matches);
        $enum = [];
        foreach (explode(',', $matches[1]) as $value) {
            $enum[] = trim($value, "'");
        }

        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];
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        return $answer->IS_NULLABLE === 'YES';
    }

    /*
    |--------------------------------------------------------------------------
    | 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);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                }
            }
        }
    }

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

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

        if (! count($columns)) {
            $columns = (property_exists($model, 'fakeColumns')) ? $this->fakeColumns : ['extras'];
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        $this->addFakes($columns);

        return $this;
    }

    /*
    |--------------------------------------------------------------------------
    | 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.

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

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

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

     */
    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;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

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


            // 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.

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

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

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

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

    {
        $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) {

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

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

            foreach ($request->file($attribute_name) as $file) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                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);
    }

    /**
     * Handle image upload and DB storage for a image:
     * - on CREATE
     *     - stores the image at the destination path
     *     - generates a name
     *     - creates image variations
     *     - stores json object into database with variations and paths
     * - 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.

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

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

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

     * @param  [type] $variations       Array of variations and their dimensions

     */
    public function uploadImageToDisk($value, $attribute_name, $disk, $destination_path, $variations = null)

    {
        if (! $variations || ! is_array($variations)) {
            $variations = ['original' => null, 'thumb' => [150, 150]];
        }

        //Needed for the original image
        if (! array_key_exists('original', $variations)) {
            $variations['original'] = null;
        }

        //Needed for admin thumbnails
        if (! array_key_exists('thumb', $variations)) {
            $variations['thumb'] = [150, 150];
        }

        $request = \Request::instance();

        //We need to setup the disk paths as they're handled differently
        //depending if you need a public path or internal storage
        $disk_config = config('filesystems.disks.'.$disk);
        $disk_root = $disk_config['root'];

        //if the disk is public, we need to know the public path
        if ($disk_config['visibility'] == 'public') {

            $public_path = str_replace(public_path(), '', $disk_root);
        } else {
            $public_path = $disk_root;
        }

        // if a new file is uploaded, delete the file from the disk
        if (($request->hasFile($attribute_name) || starts_with($value, 'data:image')) && $this->{$attribute_name}) {
            foreach ($variations as $variant => $dimensions) {

                $variant_name = str_replace('-original', '-'.$variant, $this->{$attribute_name});
                \Storage::disk($disk)->delete($variant_name);
            }
            $this->attributes[$attribute_name] = null;
        }

        // if the file input is empty, delete the file from the disk
        if (empty($value)) {
            foreach ($variations as $variant => $dimensions) {

                $variant_name = str_replace('-original', '-'.$variant, $this->{$attribute_name});
                \Storage::disk($disk)->delete($variant_name);
            }

            return $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()) {

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

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

            // 3. but only if they have the ability to crop/handle images
            if (class_exists('\Intervention\Image\ImageManagerStatic')) {
                $img = \Intervention\Image\ImageManagerStatic::make($file);
                foreach ($variations as $variant => $dimensions) {
                    $variant_name = $new_file_name.'-'.$variant.'.'.$file->getClientOriginalExtension();
                    $variant_file = $destination_path.'/'.$variant_name;

                    if ($dimensions) {

                        $width = $dimensions[0];
                        $height = $dimensions[1];

                        if ($img->width() > $width || $img->height() > $height) {
                            $img->resize($width, $height, function ($constraint) {
                                $constraint->aspectRatio();
                            })
                            ->save($disk_root.'/'.$variant_file);
                        } else {
                            $img->save($disk_root.'/'.$variant_file);
                        }

                        $image_variations[$variant] = $public_path.'/'.$variant_file;
                    } else {
                        $image_variations['original'] = $public_path.'/'.$file_path;
                    }
                }
            } else {
                $image_variations['original'] = $public_path.'/'.$file_path;
                $image_variations['thumb'] = $public_path.'/'.$file_path;
            }

            // 3. Save the complete path to the database
            $this->attributes[$attribute_name] = $image_variations['original'];
        } elseif (starts_with($value, 'data:image')) {
            $img = \Intervention\Image\ImageManagerStatic::make($value);
            $new_file_name = md5($value.time());

            if (! \Illuminate\Support\Facades\File::exists($destination_path)) {
                \Illuminate\Support\Facades\File::makeDirectory($destination_path, 0775, true);
            }

            foreach ($variations as $variant => $dimensions) {
                switch ($img->mime()) {
                    case 'image/bmp':
                    case 'image/ief':
                    case 'image/jpeg':
                    case 'image/pipeg':
                    case 'image/tiff':
                    case 'image/x-jps':
                        $extension = '.jpg';
                        break;
                    case 'image/gif':
                        $extension = '.gif';
                        break;
                    case 'image/x-icon':
                    case 'image/png':
                        $extension = '.png';
                        break;
                    default:
                        $extension = '.jpg';
                        break;
                }

                $variant_name = $new_file_name.'-'.$variant.$extension;
                $variant_file = $destination_path.'/'.$variant_name;

                if ($dimensions) {

                    $width = $dimensions[0];
                    $height = $dimensions[1];

                    if ($img->width() > $width || $img->height() > $height) {
                        $img->resize($width, $height, function ($constraint) {
                            $constraint->aspectRatio();
                        })
                        ->save($disk_root.'/'.$variant_file);
                    } else {
                        $img->save($disk_root.'/'.$variant_file);
                    }

                    $image_variations[$variant] = $public_path.'/'.$variant_file;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                } else {
                    $img->save($disk_root.'/'.$variant_file);
                    $image_variations['original'] = $variant_file;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                }
            }

            $this->attributes[$attribute_name] = $image_variations['original'];
        }
    }

    /**
     * Handles the retrieval of an image by variant:.
     *
     * @param  [type] $attribute        Name of the attribute within the model that contains the json

     * @param  [type] $variant          Name of the variant you want to extract

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

     */
    public function getUploadedImageFromDisk($attribute, $variant = 'original', $disk = null)

    {
        $image = $this->attributes['image'];
        $url = null;
        if (! empty($image)) {
            $image_variant = str_replace('-original', '-'.$variant, $image);

            if ($disk) {
                $disk_config = config('filesystems.disks.'.$disk);
                $disk_root = $disk_config['root'];

                //if the disk is public, we need to know the public path
                if ($disk_config['visibility'] == 'public') {

                    $public_path = str_replace(public_path(), '', $disk_root);
                } else {
                    $public_path = $disk_root;
                }

                if (\Storage::disk($disk)->exists($image_variant)) {
                    $url = asset($public_path.'/'.$image_variant);
                } else {
                    $url = asset($public_path.'/'.trim($image, '/'));
                }
            } else {
                if (\Storage::exists($image_variant)) {

                    $url = \Storage::url(trim($image_variant, '/'));

                } else {
                    $url = url($image);
                }
            }
        }
        return $url;
    }
}


Scrutinizer GitHub App not installed

Pull Request — master (#124)

CrudTrait::getUploadedImageFromDisk() B

Complexity

Size

Duplication

Importance

Available Fixes

1			<?php
2
3			namespace Backpack\CRUD;
4
5			use DB;
6			use Illuminate\Database\Eloquent\Model;
7
8			trait CrudTrait
9			{
10			/*
11			\|--------------------------------------------------------------------------
12			\| Methods for ENUM and SELECT crud fields.
13			\|--------------------------------------------------------------------------
14			*/
15
16			public static function getPossibleEnumValues($field_name)
			0 ignored issues – show Coding Style Naming introduced 2016-05-20 15:02 UTC by Report Bug Copy Issue Report The parameter $field_name is not named in camelCase. This check marks parameter names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history...
17			{
18			$instance = new static(); // create an instance of the model to be able to get the table name
19			$type = DB::select(DB::raw('SHOW COLUMNS FROM '.$instance->getTable().' WHERE Field = "'.$field_name.'"'))[0]->Type;
			0 ignored issues – show Bug introduced 2016-03-16 20:55 UTC by Report Bug Copy Issue Report It seems like `getTable()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history... Coding Style introduced 2016-05-20 15:02 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 124 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
20			preg_match('/^enum\((.*)\)$/', $type, $matches);
21			$enum = [];
22			foreach (explode(',', $matches[1]) as $value) {
23			$enum[] = trim($value, "'");
24			}
25
26			return $enum;
27			}
28
29			public static function isColumnNullable($column_name)
			0 ignored issues – show Coding Style Naming introduced 2016-05-20 15:02 UTC by Report Bug Copy Issue Report The parameter $column_name is not named in camelCase. This check marks parameter names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history...
30			{
31			$instance = new static(); // create an instance of the model to be able to get the table name
32			$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];
			0 ignored issues – show Bug introduced 2016-03-16 20:55 UTC by Report Bug Copy Issue Report It seems like `getTable()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history... Coding Style introduced 2016-05-20 15:02 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 217 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
33
34			return $answer->IS_NULLABLE === 'YES';
35			}
36

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Pull Request — master (#124)

CrudTrait::getUploadedImageFromDisk() B

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like