WorksWithFileUploads::getFilename() - Code Metrics - Inspection of "Update WorksWithFileUploadsTest.php and tests repo..." - rafflesargentina/l5-resource-controller - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 640e1f...c0b408 )

by Mario
created 2018-06-11 19:01 UTC
WorksWithFileUploads::getFilename() A

↳ Parent: WorksWithFileUploads
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1
<?php

namespace RafflesArgentina\ResourceController\Traits;

use Lang;
use Storage;

use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\File\Exception\UploadException;

use Illuminate\Http\Request;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Eloquent\Relations\{HasOne, MorphOne, BelongsTo};
use Illuminate\Database\Eloquent\Relations\{HasMany, MorphMany, MorphToMany, BelongsToMany};

trait WorksWithFileUploads
{
    /**
     * Upload request files and update or create relations handling array type request data.
     *
     * @param Request     $request      The Request object.
     * @param Model       $model        The eloquent model.
     * @param string|null $relativePath The file uploads relative path.
     *
     * @return void
     */
    public function uploadFiles(Request $request, Model $model, $relativePath = null)
    {
        if (!$relativePath) {
            $relativePath = $this->getDefaultRelativePath();
        }

        $files = $request->files;
        foreach ($files as $relationName => $uploadedFiles) {
            $this->_checkFileRelationExists($model, $relationName);
            $relation = $model->{$relationName}();

            foreach ($uploadedFiles as $id => $uploadedFile) {
                if (!$uploadedFile->isValid()) {
                    throw new UploadException($uploadedFile->getError());
                }

                $filename = $this->getFilename($uploadedFile);

                $destination = $this->getStoragePath($relativePath);
                $this->moveUploadedFile($uploadedFile, $filename, $destination);

                $location = $relativePath.$filename;
                $this->handleFileRelations($model, $relation, $location, $id);
            }
        }
    }

    /**
     * Get the name of the file.
     *
     * @param UploadedFile $uploadedFile The UploadedFile object.
     *
     * @return string
     */
    protected function getFilename(UploadedFile $uploadedFile)
    {
        $extension = $uploadedFile->guessExtension();
        $filename = str_random().'.'.$extension;

        return $filename;
    }

    /**
     * Get storage path for the configured driver.
     *
     * @param string $relativePath The relative path.
     *
     * @return string
     */
    protected function getStoragePath($relativePath)
    {
        return Storage::disk()->getDriver()->getAdapter()->getPathPrefix().$relativePath;
    }

    /**
     * Move the uploaded file to specified filename and destination.
     *
     * @param UploadedFile $uploadedFile The UploadedFile object.
     * @param string       $filename     The name of the file.
     * @param string       $destination  The file destination.
     *
     * @return \Symfony\Component\HttpFoundation\File\File
     */
    protected function moveUploadedFile($uploadedFile, $filename, $destination)
    {
        return $uploadedFile->move($destination, $filename);
    }

    /**
     * Get location column.
     *
     * @return string
     */
    protected function getLocationColumn()
    {
        return 'location';
    }

    /**
     * Get default relative path.
     *
     * @return string
     */
    protected function getDefaultRelativePath()
    {
        return 'uploads/';
    }

    /**
     * Handle file relations.
     *
     * @param Model    $model    The eloquent model.
     * @param Relation $relation The eloquent relation.
     * @param string   $location The uploaded file location.
     * @param string   $id       The related model id.
     *
     * @return void
     */
    protected function handleFileRelations(Model $model, Relation $relation, $location, $id)
    {
        switch (true) {
        case $relation instanceof HasOne || $relation instanceof MorphOne:
            $this->updateOrCreateFileHasOne($model, $relation, $location, $id);
            break;
        case $relation instanceof BelongsTo:
            $this->updateOrCreateFileBelongsToOne($model, $relation, $location, $id);
            break;
        case $relation instanceof HasMany || $relation instanceof MorphMany:
            $this->updateOrCreateFileHasMany($model, $relation, $location, $id);
            break;
        case $relation instanceof BelongsToMany || $relation instanceof MorphToMany:
            $this->updateOrCreateFileBelongsToMany($model, $relation, $location, $id);
            break;
        }
    }

    /**
     * HasOne file relation updateOrCreate logic.
     *
     * @param Model       $model    The eloquent model.
     * @param Relation    $relation The eloquent relation.
     * @param string      $location The uploaded file location.
     * @param string|null $id       The related model id.
     *
     * @return void
     */
    protected function updateOrCreateFileHasOne(Model $model, Relation $relation, $location, $id = null)
    {
        $column = $this->getLocationColumn();

        if (!$relation->first()) {
            $relation->create([$column => $location]);
        } else {
            $relation->update([$column => $location]);
        }
    }

    /**
     * BelongsToOne file relation updateOrCreate logic.
     *
     * @param Model       $model    The eloquent model.
     * @param Relation    $relation The eloquent relation.
     * @param string      $location The uploaded file location.
     * @param string|null $id       The related model id.
     *
     * @return void
     */
    protected function updateOrCreateFileBelongsToOne(Model $model, Relation $relation, $location, $id = null)
    {
        $column = $this->getLocationColumn();
        $related = $relation->getRelated();

        if (!$relation->first()) {
            $relation->associate($related->create([$column => $location]));
            $model->save();
        } else {
            $relation->update([$column => $location]);
        }
    }

    /**
     * HasMany file relation updateOrCreate logic.
     *
     * @param Model       $model    The eloquent model.
     * @param Relation    $relation The eloquent relation.
     * @param string      $location The uploaded file location.
     * @param string|null $id       The related model id.
     *
     * @return void
     */
    protected function updateOrCreateFileHasMany(Model $model, Relation $relation, $location, $id = null)
    {
        $column = $this->getLocationColumn();
        $relation->updateOrCreate(['id' => $id], [$column => $location]);
    }

    /**
     * BelongsToMany file relation updateOrCreate logic.
     *
     * @param Model       $model    The eloquent model.
     * @param Relation    $relation The eloquent relation.
     * @param string      $location The uploaded file location.
     * @param string|null $id       The related model id.
     *
     * @return void
     */
    protected function updateOrCreateFileBelongsToMany(Model $model, Relation $relation, $location, $id = null)
    {
        $column = $this->getLocationColumn();
        $related = $relation->getRelated();

        $related->updateOrCreate(['id' => $id], [$column => $location]);
        $relation->syncWithoutDetaching($id, [$column => $location]);
    }

    /**
     * Throw an exception if request file is not named after an existent relation.
     *
     * @param Model  $model        The eloquent model.
     * @param string $relationName The eloquent relation name.
     *
     * @throws UploadException
     *
     * @return void
     */
    private function _checkFileRelationExists(Model $model, $relationName)
    {
        if (!method_exists($model, $relationName) || !$model->{$relationName}() instanceof Relation) {
            if (Lang::has('resource-controller.filerelationinexistent')) {
                $message = trans('resource-controller.filerelationinexistent', ['relationName' => $relationName]);
            } else {
                $message = "Request file '{$relationName}' is not named after an existent relation.";
            }

            throw new UploadException($message);
            throw new UploadException(/** @scrutinizer ignore-type */ $message);
        }
    }
}

rafflesargentina / l5-resource-controller

Push — master ( 640e1f...c0b408 )

WorksWithFileUploads::getFilename() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
