Uploadable - Code Metrics - Inspection of "test and refactor" - padosoft/laravel-uploadable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eaccdd...67c865 )

by Lorenzo

created 2016-09-12 20:29 UTC

Uploadable C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	538
Duplicated Lines	3.72 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	79
lcom	1
cbo	8
dl	20
loc	538
rs	5.442
c	0
b	0
f	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	bootUploadable()	0	7	1
A	bindCreateEvents()	0	7	1
A	bindSaveEvents()	0	11	1
A	bindUpdateEvents()	0	11	1
A	bindDeleteEvents()	0	11	1
A	getUploadOptionsOrDefault()	0	16	3
A	guardAgainstInvalidUploadOptions()	0	9	4
A	uploadFiles()	0	12	3
B	uploadFile()	0	24	3
B	doUpload()	0	25	5
A	requestHasValidFilesAndCorrectPaths()	0	14	3
B	generateNewUploadFileName()	0	18	5
A	calcolateNewUploadFileName()	0	13	2
A	deleteUploadedFiles()	0	7	2
A	deleteUploadedFile()	0	20	3
A	setBlanckAttributeAndDB()	0	12	2
A	checkIfAllUploadFieldsAreEmpty()	0	11	4
A	checkOrCreateAllUploadBasePaths()	0	10	3
A	getUploadsAttributesSafe()	0	8	2
A	checkOrCreateUploadBasePath()	0	7	1
A	getUploadFileBasePath()	0	20	3
B	getUploadFileBasePathSpecific()	0	11	5
A	getUploadFileFullPath()	0	11	2
A	getUploadFileUrl()	8	8	2
A	removePublicPath()	0	12	3
A	getUploadFileBaseUrl()	12	12	2
A	generateAllNewUploadFileNameAndSetAttribute()	0	6	2
A	generateNewUploadFileNameAndSetAttribute()	0	19	4
A	updateDb()	0	9	2
A	isSlashOrEmptyDir()	0	4	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Uploadable often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Uploadable, and based on these observations, apply Extract Interface, too.

<?php

namespace Padosoft\Uploadable;

use DB;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\URL;
use Padosoft\Io\DirHelper;
use Padosoft\Io\FileHelper;
use Padosoft\Laravel\Request\RequestHelper;
use Padosoft\Laravel\Request\UploadedFileHelper;

/**
 * Class Uploadable
 * Auto upload and save files on save/create/delete model.
 * @package Padosoft\Uploadable
 */
trait Uploadable
{
    /** @var UploadOptions */
    protected $uploadOptions;

    /**
     * Boot the trait.
     */
    public static function bootUploadable()
    {
        self::bindCreateEvents();
        self::bindSaveEvents();
        self::bindUpdateEvents();
        self::bindDeleteEvents();
    }

    /**
     * Bind create model events.
     */
    protected static function bindCreateEvents()
    {
        static::creating(function ($model) {
            $model->uploadOptions = $model->getUploadOptionsOrDefault();
            $model->guardAgainstInvalidUploadOptions();
        });
    }

    /**
     * Bind save model events.
     */
    protected static function bindSaveEvents()
    {
        /*

        static::saving(function (Model $model) {
            $model->generateAllNewUploadFileNameAndSetAttribute();
        });
        */
        static::saved(function (Model $model) {
            $model->uploadFiles();
        });
    }

    /**
     * Bind update model events.
     */
    protected static function bindUpdateEvents()
    {
        /*

        static::updating(function (Model $model) {
            $model->generateAllNewUploadFileNameAndSetAttribute();
        });
        */
        static::updated(function (Model $model) {

            $model->uploadFiles();
        });
    }

    /**
     * Bind delete model events.
     */
    protected static function bindDeleteEvents()
    {
        static::deleting(function (Model $model) {
            $model->uploadOptions = $model->getUploadOptionsOrDefault();
            $model->guardAgainstInvalidUploadOptions();
        });

        static::deleted(function (Model $model) {
            $model->deleteUploadedFiles();
        });
    }

    /**
     * Retrive a specifice UploadOptions for this model, or return default UploadOptions
     * @return UploadOptions
     */
    public function getUploadOptionsOrDefault() : UploadOptions
    {
        if ($this->uploadOptions) {
            return $this->uploadOptions;
        }

        if (method_exists($this, 'getUploadOptions')) {
            $method = 'getUploadOptions';
            $this->uploadOptions = $this->{$method}();
        } else {
            $this->uploadOptions = UploadOptions::create()->getUploadOptionsDefault()
                ->setUploadBasePath(public_path('upload/' . $this->getTable()));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return $this->uploadOptions;
    }

    /**
     * This function will throw an exception when any of the options is missing or invalid.
     * @throws InvalidOption
     */
    public function guardAgainstInvalidUploadOptions()
    {
        if (!count($this->uploadOptions->uploads)) {
            throw InvalidOption::missingUploadFields();
        }
        if ($this->uploadOptions->uploadBasePath === null || $this->uploadOptions->uploadBasePath == '') {
            throw InvalidOption::missingUploadBasePath();
        }
    }

    /**
     * Handle file upload.
     */
    public function uploadFiles()
    {
        //invalid model
        if ($this->id < 1) {
class MyClass { }

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

        //loop for every upload model attributes and do upload if has a file in request
        foreach ($this->getUploadsAttributesSafe() as $uploadField) {
            $this->uploadFile($uploadField);
        }
    }

    /**
     * Upload a file releted to a passed attribute name
     * @param string $uploadField
     */
    public function uploadFile(string $uploadField)
    {
        //check if there is a valid file in request for current attribute
        if (!RequestHelper::isValidCurrentRequestUploadFile($uploadField,
            $this->getUploadOptionsOrDefault()->uploadsMimeType)
        ) {
            return;
        }

        //retrive the uploaded file
        $uploadedFile = RequestHelper::getCurrentRequestFileSafe($uploadField);
        if ($uploadedFile === null) {
            return;
        }

        //calcolate new file name and set it to model attribute
        $this->generateNewUploadFileNameAndSetAttribute($uploadField);

        //do the work
        $newName = $this->doUpload($uploadedFile, $uploadField);

        //save on db (not call model save because invoke event and entering in loop)
        $this->updateDb($uploadField, $newName);
    }

    /**
     * Get an UploadedFile, generate new name, and save it in destination path.
     * Return empty string if it fails, otherwise return the saved file name.
     * @param UploadedFile $uploadedFile
     * @param string $uploadAttribute
     * @return string
     */
    protected function doUpload(UploadedFile $uploadedFile, $uploadAttribute) : string
    {
        if (!$uploadedFile || !$uploadAttribute) {
            return '';
        }

        //get file name by attribute
        $newName = $this->{$uploadAttribute};

        //get upload path to store (method create dir if not exists and return '' if it failed)
        $pathToStore = $this->getUploadFileBasePath($uploadAttribute);

        //delete if file already exists
        FileHelper::unlinkSafe(DirHelper::njoin($pathToStore,$newName));

        //move file to destination folder
        try {
            $targetFile = $uploadedFile->move($pathToStore, $newName);
        } catch (\Symfony\Component\HttpFoundation\File\Exception\FileException $e) {
            $targetFile = null;
            Log::warning('Error in doUpload() when try to move ' . $newName . ' to folder: ' . $pathToStore . PHP_EOL . $e->getMessage() . PHP_EOL . $e->getTraceAsString());
        }

        return $targetFile ? $newName : '';
    }

    /**
     * Check request for valid files and server for correct paths defined in model
     * @return bool
     */
    public function requestHasValidFilesAndCorrectPaths() : bool
    {
        //current request has not uploaded files
        if (!RequestHelper::currentRequestHasFiles()) {
            return false;
        }

        //ensure that all upload path are ok or create it.
        if (!$this->checkOrCreateAllUploadBasePaths()) {
            return false;
        }

        return true;
    }

    /**
     * Generate a new file name for uploaded file.
     * Return empty string if uploadedFile is null, otherwise return the new file name..
     * @param UploadedFile $uploadedFile
     * @return string
     * @internal param string $uploadField
     */
    public function generateNewUploadFileName(UploadedFile $uploadedFile) : string
    {
        if (!$uploadedFile) {
            return '';
        }
       if (!$this->id && $this->getUploadOptionsOrDefault()->appendModelIdSuffixInUploadedFileName) {
            return '';
        }

        //check if file need a new name
        $newName = $this->calcolateNewUploadFileName($uploadedFile);
        if ($newName != '') {
            return $newName;
        }

        //no new file name, return original file name
        return $uploadedFile->getFilename();
    }

    /**
     * Check if file need a new name and return it, otherwise return empty string.
     * @param UploadedFile $uploadedFile
     * @return string
     */
    public function calcolateNewUploadFileName(UploadedFile $uploadedFile) : string
    {
        if (!$this->getUploadOptionsOrDefault()->appendModelIdSuffixInUploadedFileName) {
            return '';
        }

        //retrive original file name and extension
        $filenameWithoutExtension = UploadedFileHelper::getFilenameWithoutExtension($uploadedFile);
        $ext = $uploadedFile->getClientOriginalExtension();

        $newName = $filenameWithoutExtension . $this->getUploadOptionsOrDefault()->uploadFileNameSuffixSeparator . $this->id . '.' . $ext;
        return sanitize_filename($newName);
    }

    /**
     * delete all Uploaded Files
     */
    public function deleteUploadedFiles()
    {
        //loop for every upload model attributes
        foreach ($this->getUploadOptionsOrDefault()->uploads as $uploadField) {
            $this->deleteUploadedFile($uploadField);
        }
    }

    /**
     * Delete upload file related to passed attribute name
     * @param string $uploadField
     */
    public function deleteUploadedFile(string $uploadField)
    {
        if (!$uploadField) {
            return;
        }

        if (!$this->{$uploadField}) {
            return;
        }

        //retrive correct upload storage path for current attribute
        $uploadFieldPath = $this->getUploadFileBasePath($uploadField);

        //unlink file
        $path = DirHelper::njoin($uploadFieldPath, $this->{$uploadField});
        FileHelper::unlinkSafe($path);

        //reset model attribute and update db field
        $this->setBlanckAttributeAndDB($uploadField);
    }

    /**
     * Reset model attribute and update db field
     * @param string $uploadField
     */
    public function setBlanckAttributeAndDB(string $uploadField)
    {
        if (!$uploadField) {
            return;
        }

        //set to black attribute
        $this->{$uploadField} = '';

        //save on db (not call model save because invoke event and entering in loop)
        $this->updateDb($uploadField, '');
    }

    /**
     * Return true If All Upload atrributes Are Empty or
     * if the uploads array is not set.
     * @return bool
     */
    public function checkIfAllUploadFieldsAreEmpty() : bool
    {
        foreach ($this->getUploadsAttributesSafe() as $uploadField) {
            //for performance if one attribute has value exit false
            if ($uploadField && $this->{$uploadField}) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check all attributes upload path, and try to create dir if not already exists.
     * Return false if it fails to create all founded dirs.
     * @return bool
     */
    public function checkOrCreateAllUploadBasePaths() : bool
    {
        foreach ($this->getUploadsAttributesSafe() as $uploadField) {
            if (!$this->checkOrCreateUploadBasePath($uploadField)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check uploads property and return a uploads class field
     * or empty array if somethings wrong.
     * @return array
     */
    public function getUploadsAttributesSafe() : array
    {
        if (!is_array($this->getUploadOptionsOrDefault()->uploads)) {
            return [];
        }

        return $this->getUploadOptionsOrDefault()->uploads;
    }

    /**
     * Check attribute upload path, and try to create dir if not already exists.
     * Return false if it fails to create the dir.
     * @param string $uploadField
     * @return bool
     */
    public function checkOrCreateUploadBasePath(string $uploadField) : bool
    {
        $uploadFieldPath = $this->getUploadFileBasePath($uploadField);

        return DirHelper::checkDirExistOrCreate($uploadFieldPath,
            $this->getUploadOptionsOrDefault()->uploadCreateDirModeMask);
    }

    /**
     * Return the upload path for the passed attribute and try to create it if not exists.
     * Returns empty string if dir if not exists and fails to create it.
     * @param string $uploadField
     * @return string
     */
    public function getUploadFileBasePath(string $uploadField) : string
    {
        //default model upload path
        $uploadFieldPath = DirHelper::canonicalize($this->getUploadOptionsOrDefault()->uploadBasePath);

        //overwrite if there is specific path for the field
        $specificPath = $this->getUploadFileBasePathSpecific($uploadField);
        if ($specificPath != '') {
            $uploadFieldPath = $specificPath;
        }

        //check if exists or try to create dir
        if (!DirHelper::checkDirExistOrCreate($uploadFieldPath,
            $this->getUploadOptionsOrDefault()->uploadCreateDirModeMask)
        ) {
            return '';
        }

        return $uploadFieldPath;
    }

    /**
     * Return the specific upload path (by uploadPaths prop) for the passed attribute if exists,
     * otherwise return empty string.
     * If uploadPaths for this field is relative, a public_path was appended.
     * @param string $uploadField
     * @return string
     */
    public function getUploadFileBasePathSpecific(string $uploadField) : string
    {
        //check if there is a specified upload path
        if (empty($this->getUploadOptionsOrDefault()->uploadPaths) || count($this->getUploadOptionsOrDefault()->uploadPaths) < 1
            || !array_key_exists($uploadField, $this->getUploadOptionsOrDefault()->uploadPaths)
        ) {
            return '';
        }
        $path = $this->getUploadOptionsOrDefault()->uploadPaths[$uploadField];
        return DirHelper::isAbsolute($path) ? DirHelper::canonicalize($path) : DirHelper::canonicalize(public_path($path));
    }

    /**
     * Return the full (path+filename) upload abs path for the passed attribute.
     * Returns empty string if dir if not exists.
     * @param string $uploadField
     * @return string
     */
    public function getUploadFileFullPath(string $uploadField) : string
    {
        $uploadFieldPath = $this->getUploadFileBasePath($uploadField);
        $uploadFieldPath = DirHelper::addFinalSlash($uploadFieldPath) . $this->{$uploadField};

        if ($this->isSlashOrEmptyDir($uploadFieldPath)) {
            return '';
        }

        return $uploadFieldPath;
    }

    /**
     * Return the full url (base url + filename) for the passed attribute.
     * Returns empty string if dir if not exists.
     * Ex.:  http://localhost/laravel/public/upload/news/pippo.jpg
     * @param string $uploadField
     * @return string
     */
    public function getUploadFileUrl(string $uploadField) : string

    {
        $Url = $this->getUploadFileFullPath($uploadField);

        $uploadFieldPath = DirHelper::canonicalize($this->removePublicPath($Url));

        return $uploadFieldPath == '' ? '' : URL::to($uploadFieldPath);
    }

    /**
     * get a path and remove public_path.
     * @param string $path
     * @return string
     */
    public function removePublicPath(string $path) : string
    {
        if ($path == '') {
            return '';
        }
        $path = str_replace(DirHelper::canonicalize(public_path()), '', DirHelper::canonicalize($path));
        if ($this->isSlashOrEmptyDir($path)) {
            return '';
        }

        return $path;
    }

    /**
     * Return the base url (without filename) for the passed attribute.
     * Returns empty string if dir if not exists.
     * Ex.:  http://localhost/laravel/public/upload/
     * @param string $uploadField
     * @return string
     */
    public function getUploadFileBaseUrl(string $uploadField) : string

    {
        $uploadFieldPath = $this->getUploadFileBasePath($uploadField);

        $uploadFieldPath = DirHelper::canonicalize(DirHelper::addFinalSlash($this->removePublicPath($uploadFieldPath)));

        if ($this->isSlashOrEmptyDir($uploadFieldPath)) {
            return '';
        }

        return URL::to($uploadFieldPath);
    }

    /**
     * Calcolate the new name for ALL uploaded files and set relative upload attributes
     */
    public function generateAllNewUploadFileNameAndSetAttribute()
    {
        foreach ($this->getUploadsAttributesSafe() as $uploadField) {
            $this->generateNewUploadFileNameAndSetAttribute($uploadField);
        }
    }

    /**
     * Calcolate the new name for uploaded file relative to passed attribute name and set the upload attribute
     * @param string $uploadField
     */
    public function generateNewUploadFileNameAndSetAttribute(string $uploadField)
    {
        if (!trim($uploadField)) {
            return;
        }

        //generate new file name
        $uploadedFile = RequestHelper::getCurrentRequestFileSafe($uploadField);
        if ($uploadedFile === null) {
            return;
        }
        $newName = $this->generateNewUploadFileName($uploadedFile);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if ($newName == '') {
            return;
        }

        //set attribute
        $this->{$uploadField} = $newName;
    }

    /**
     * @param string $uploadField
     * @param string $newName
     */
    public function updateDb(string $uploadField, string $newName)
    {
        if ($this->id < 1) {
            return;
        }
        DB::table($this->getTable())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->where('id', $this->id)
            ->update([$uploadField => $newName]);
    }

    /**
     * @param string $path
     * @return bool
     */
    public function isSlashOrEmptyDir(string $path):bool
    {
        return $path === null || $path == '' || $path == '\/' || $path == DIRECTORY_SEPARATOR;
    }
}


padosoft / laravel-uploadable