RafflesArgentina\ResourceController\Traits\WorksWithFileUploads

Complexity

Total Complexity

28

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	updateOrCreateFileHasOne()	0	8	2
A	getLocationColumn()	0	3	1
A	getDefaultRelativePath()	0	3	1
A	moveUploadedFile()	0	3	1
A	getStoragePath()	0	3	1
A	updateOrCreateFileBelongsToOne()	0	10	2
B	handleFileRelations()	0	15	8
B	uploadFiles()	0	23	5
A	getFilename()	0	6	1
A	updateOrCreateFileBelongsToMany()	0	7	1
A	updateOrCreateFileHasMany()	0	4	1
A	_checkFileRelationExists()	0	10	4

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

It seems like $message can also be of type array; however, parameter $message of Symfony\Component\HttpFoundation\File\Exception\UploadException::__construct() does only seem to accept string, maybe add an additional type check?

        }
    }
}