Backpack\CRUD\app\Library\Uploaders\MultipleFiles

Complexity

Total Complexity

34

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	for()	0	3	1
A	getFilesToDeleteFromRequest()	0	3	1
A	getEntryAttributeValue()	0	5	2
A	hasDeletedFiles()	0	3	2
F	uploadFiles()	0	49	18
B	uploadRepeatableFiles()	0	39	10

<?php

namespace Backpack\CRUD\app\Library\Uploaders;

use Backpack\CRUD\app\Library\CrudPanel\CrudPanelFacade as CRUD;
use Backpack\CRUD\app\Library\Uploaders\Support\Interfaces\UploaderInterface;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Storage;

class MultipleFiles extends Uploader
{
    public static function for(array $field, $configuration): UploaderInterface
    {
        return (new self($field, $configuration))->multiple();
    }

    public function uploadFiles(Model $entry, $value = null)
    {
        if ($value && isset($value[0]) && is_null($value[0])) {
            $value = false;
        }

        $filesToDelete = $this->getFilesToDeleteFromRequest();
        $value = $value ?? collect($value)->flatten()->toArray();
        $previousFiles = $this->getPreviousFiles($entry) ?? [];

        if (is_array($previousFiles) && empty($previousFiles[0] ?? [])) {
            $previousFiles = [];
        }

        if (! is_array($previousFiles) && is_string($previousFiles)) {
            $previousFiles = json_decode($previousFiles, true);
        }

        if ($filesToDelete) {

The expression $filesToDelete of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($previousFiles as $previousFile) {
                if (in_array($previousFile, $filesToDelete)) {
                    Storage::disk($this->getDisk())->delete($previousFile);

                    $previousFiles = Arr::where($previousFiles, function ($value, $key) use ($previousFile) {

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

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

        if (! is_array($value)) {
            $value = [];
        }

        foreach ($value as $file) {
            if ($file && is_file($file)) {
                $fileName = $this->getFileName($file);
                $file->storeAs($this->getPath(), $fileName, $this->getDisk());
                $previousFiles[] = $this->getPath().$fileName;
            }
        }

        $previousFiles = array_values($previousFiles);

        if (empty($previousFiles)) {
            return null;
        }

        return isset($entry->getCasts()[$this->getName()]) || $this->isFake() ? $previousFiles : json_encode($previousFiles);
    }

    /** @codeCoverageIgnore */
    public function uploadRepeatableFiles($files, $previousRepeatableValues, $entry = null)

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

    {
        $fileOrder = $this->getFileOrderFromRequest();

        foreach ($files as $row => $files) {

$files is overwriting one of the parameters of this function.

            foreach ($files ?? [] as $file) {
                if ($file && is_file($file)) {
                    $fileName = $this->getFileName($file);
                    $file->storeAs($this->getPath(), $fileName, $this->getDisk());
                    $fileOrder[$row][] = $this->getPath().$fileName;
                }
            }
        }
        // create a temporary variable that we can unset keys
        // everytime one is found. That way we avoid iterating
        // already handled keys (notice we do a deep array copy)
        $tempFileOrder = array_map(function ($item) {
            return $item;
        }, $fileOrder);

        foreach ($previousRepeatableValues as $previousRow => $previousFiles) {
            foreach ($previousFiles ?? [] as $key => $file) {
                $previousFileInArray = array_filter($tempFileOrder, function ($items, $key) use ($file, $tempFileOrder) {
                    $found = array_search($file, $items ?? [], true);
                    if ($found !== false) {
                        Arr::forget($tempFileOrder, $key.'.'.$found);

                        return true;
                    }

                    return false;
                }, ARRAY_FILTER_USE_BOTH);
                if ($file && ! $previousFileInArray) {

The expression $previousFileInArray of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                    Storage::disk($this->getDisk())->delete($file);
                }
            }
        }

        return $fileOrder;
    }

    public function hasDeletedFiles($value): bool
    {
        return empty($this->getFilesToDeleteFromRequest()) ? false : true;
    }

    public function getEntryAttributeValue(Model $entry)
    {
        $value = $entry->{$this->getAttributeName()};

        return isset($entry->getCasts()[$this->getName()]) ? $value : json_encode($value);
    }

    private function getFilesToDeleteFromRequest(): array
    {
        return collect(CRUD::getRequest()->get('clear_'.$this->getNameForRequest()))->flatten()->toArray();

The method getRequest() does not exist on Backpack\CRUD\app\Library\CrudPanel\CrudPanelFacade. Since you implemented __callStatic, consider adding a @method annotation.

    }
}