Backpack\CRUD\app\Library\Uploaders\Support\Traits\HandleRepeatableUploads

Complexity

Total Complexity

88

Size/Duplication

Total Lines	404
Duplicated Lines	0 %

Importance

Changes	17
Bugs	13	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
B	uploadRelationshipFiles()	0	28	7
A	hasDeletedFiles()	0	3	3
A	getUploaderSubfield()	0	3	1
A	getFileOrderFromRequest()	0	10	3
B	handleRepeatableFiles()	0	40	9
A	uploadRepeatableFiles()	0	2	1
A	getValuesWithPathStripped()	0	10	3
A	retrieveRepeatableRelationFiles()	0	16	3
A	getRepeatableRelationType()	0	3	1
A	getUploaderFieldSubfields()	0	3	1
A	getUploaderField()	0	3	1
A	getPreviousRepeatableValues()	0	13	3
A	mergeValuesRecursive()	0	12	5
A	processRelationshipRepeatableUploaders()	0	7	2
B	deleteRepeatableFiles()	0	35	10
A	shouldKeepPreviousValueUnchanged()	0	3	3
A	getEntryAttributeValue()	0	3	1
A	getEntryOriginalValue()	0	3	1
A	shouldUploadFiles()	0	3	1
B	retrieveRepeatableFiles()	0	32	8
A	repeats()	0	7	1
A	processRepeatableUploads()	0	13	2
A	getRepeatableContainerName()	0	3	1
A	getFilesFromEntry()	0	3	1
A	deleteRepeatableRelationFiles()	0	27	5
A	deleteRelationshipFiles()	0	9	4
B	deletePivotModelFiles()	0	29	7

<?php

namespace Backpack\CRUD\app\Library\Uploaders\Support\Traits;

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\Database\Eloquent\Relations\Pivot;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

/**
 * @codeCoverageIgnore
 */
trait HandleRepeatableUploads
{
    public bool $handleRepeatableFiles = false;

    public null|string $repeatableContainerName = null;

    /*******************************
     * Setters - fluently configure the uploader
     *******************************/
    public function repeats(string $repeatableContainerName): self
    {
        $this->handleRepeatableFiles = true;

        $this->repeatableContainerName = $repeatableContainerName;

        return $this;
    }

    /*******************************
     * Getters
     *******************************/
    public function getRepeatableContainerName(): null|string
    {
        return $this->repeatableContainerName;
    }

    /*******************************
     * Default implementation methods
     *******************************/
    protected function uploadRepeatableFiles($values, $previousValues, $entry = null)
    {
    }

    protected function handleRepeatableFiles(Model $entry): Model
    {
        if ($this->isRelationship) {
            return $this->processRelationshipRepeatableUploaders($entry);
        }

        $values = collect(CRUD::getRequest()->get($this->getRepeatableContainerName()));

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

        $files = collect(CRUD::getRequest()->file($this->getRepeatableContainerName()));

        $value = $this->mergeValuesRecursive($values, $files);

        $processedEntryValues = $this->processRepeatableUploads($entry, $value);

It seems like $value can also be of type array; however, parameter $values of Backpack\CRUD\app\Library\Uploaders\Support\Traits\HandleRepeatableUploads::processRepeatableUploads() does only seem to accept Illuminate\Support\Collection, maybe add an additional type check?

        if ($this->isFake()) {

It seems like isFake() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $fakeValues = $entry->{$this->getFakeAttribute()} ?? [];

It seems like getFakeAttribute() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            if (is_string($fakeValues)) {
                $fakeValues = json_decode($fakeValues, true);
            }

            $fakeValues[$this->getRepeatableContainerName()] = empty($processedEntryValues)
                                                        ? null
                                                        : (isset($entry->getCasts()[$this->getFakeAttribute()])
                                                            ? $processedEntryValues
                                                            : json_encode($processedEntryValues));

            $entry->{$this->getFakeAttribute()} = isset($entry->getCasts()[$this->getFakeAttribute()])
                                                            ? $fakeValues
                                                            : json_encode($fakeValues);

            return $entry;
        }

        $entry->{$this->getRepeatableContainerName()} = empty($processedEntryValues)
                                                        ? null
                                                        : (isset($entry->getCasts()[$this->getRepeatableContainerName()])
                                                            ? $processedEntryValues
                                                            : json_encode($processedEntryValues));

        return $entry;
    }

    private function processRelationshipRepeatableUploaders(Model $entry)
    {
        foreach (app('UploadersRepository')->getRepeatableUploadersFor($this->getRepeatableContainerName()) as $uploader) {
            $entry = $uploader->uploadRelationshipFiles($entry);
        }

        return $entry;
    }

    protected function uploadRelationshipFiles(Model $entry): Model
    {
        $entryValue = $this->getFilesFromEntry($entry);

        if ($this->handleMultipleFiles && is_string($entryValue)) {
            try {
                $entryValue = json_decode($entryValue, true);
            } catch (\Exception) {
                return $entry;
            }
        }

        if ($this->hasDeletedFiles($entryValue)) {
            $entry->{$this->getAttributeName()} = $this->uploadFiles($entry, false);

It seems like getAttributeName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like uploadFiles() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $this->updatedPreviousFiles = $this->getEntryAttributeValue($entry);

The property updatedPreviousFiles does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        if ($this->shouldKeepPreviousValueUnchanged($entry, $entryValue)) {
            $entry->{$this->getAttributeName()} = $this->updatedPreviousFiles ?? $this->getEntryOriginalValue($entry);

            return $entry;
        }

        if ($this->shouldUploadFiles($entryValue)) {
            $entry->{$this->getAttributeName()} = $this->uploadFiles($entry, $entryValue);
        }

        return $entry;
    }

    protected function getFilesFromEntry(Model $entry)
    {
        return $entry->getAttribute($this->getAttributeName());
    }

    protected function getEntryAttributeValue(Model $entry)
    {
        return $entry->{$this->getAttributeName()};
    }

    protected function getEntryOriginalValue(Model $entry)
    {
        return $entry->getOriginal($this->getAttributeName());
    }

    protected function shouldUploadFiles($entryValue): bool
    {
        return true;
    }

    protected function shouldKeepPreviousValueUnchanged(Model $entry, $entryValue): bool
    {
        return $entry->exists && ($entryValue === null || $entryValue === [null]);
    }

    protected function hasDeletedFiles($entryValue): bool
    {
        return $entryValue === false || $entryValue === null || $entryValue === [null];
    }

    protected function processRepeatableUploads(Model $entry, Collection $values): array
    {
        foreach (app('UploadersRepository')->getRepeatableUploadersFor($this->getRepeatableContainerName()) as $uploader) {
            $uploadedValues = $uploader->uploadRepeatableFiles($values->pluck($uploader->getAttributeName())->toArray(), $this->getPreviousRepeatableValues($entry, $uploader));

            $values = $values->map(function ($item, $key) use ($uploadedValues, $uploader) {
                $item[$uploader->getAttributeName()] = $uploadedValues[$key] ?? null;

                return $item;
            });
        }

        return $values->toArray();
    }

    private function retrieveRepeatableFiles(Model $entry): Model
    {
        if ($this->isRelationship) {
            return $this->retrieveRepeatableRelationFiles($entry);
        }

        $repeatableUploaders = app('UploadersRepository')->getRepeatableUploadersFor($this->getRepeatableContainerName());

        if ($this->attachedToFakeField) {
            $values = $entry->{$this->attachedToFakeField};

            $values = is_string($values) ? json_decode($values, true) : $values;

            $values[$this->getAttributeName()] = isset($values[$this->getAttributeName()]) ? $this->getValueWithoutPath($values[$this->getAttributeName()]) : null;

It seems like getValueWithoutPath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $entry->{$this->attachedToFakeField} = isset($entry->getCasts()[$this->attachedToFakeField]) ? $values : json_encode($values);

            return $entry;
        }

        $values = $entry->{$this->getRepeatableContainerName()};
        $values = is_string($values) ? json_decode($values, true) : $values;
        $values = array_map(function ($item) use ($repeatableUploaders) {
            foreach ($repeatableUploaders as $upload) {
                $item[$upload->getAttributeName()] = $this->getValuesWithPathStripped($item, $upload);
            }

            return $item;
        }, $values ?? []);

        $entry->{$this->getRepeatableContainerName()} = $values;

        return $entry;
    }

    private function retrieveRepeatableRelationFiles(Model $entry)
    {
        switch($this->getRepeatableRelationType()) {
            case 'BelongsToMany':
            case 'MorphToMany':
                $pivotClass = app('crud')->getModel()->{$this->getUploaderSubfield()['baseEntity']}()->getPivotClass();
                $pivotFieldName = 'pivot_'.$this->getAttributeName();
                $connectedEntry = new $pivotClass([$this->getAttributeName() => $entry->$pivotFieldName]);
                $entry->{$pivotFieldName} = $this->retrieveFiles($connectedEntry)->{$this->getAttributeName()};

It seems like retrieveFiles() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                break;
            default:
                $entry = $this->retrieveFiles($entry);
        }

        return $entry;
    }

    private function getRepeatableRelationType()
    {
        return $this->getUploaderField()->getAttributes()['relation_type'];
    }

    private function getUploaderField()
    {
        return app('crud')->field($this->getRepeatableContainerName());
    }

    private function getUploaderSubfield()
    {
        return collect($this->getUploaderFieldSubfields())->where('name', '===', $this->getName())->first();

It seems like getName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    private function getUploaderFieldSubfields()
    {
        return $this->getUploaderField()->getAttributes()['subfields'];
    }

    private function deleteRepeatableFiles(Model $entry): void
    {
        if ($this->isRelationship) {
            $this->deleteRelationshipFiles($entry);

            return;
        }

        if ($this->attachedToFakeField) {
            $repeatableValues = $entry->{$this->attachedToFakeField}[$this->getRepeatableContainerName()] ?? null;
            $repeatableValues = is_string($repeatableValues) ? json_decode($repeatableValues, true) : $repeatableValues;
            $repeatableValues = collect($repeatableValues);
        }

        $repeatableValues ??= collect($entry->{$this->getRepeatableContainerName()});

The variable $repeatableValues does not seem to be defined for all execution paths leading up to this point.

        foreach (app('UploadersRepository')->getRepeatableUploadersFor($this->getRepeatableContainerName()) as $upload) {
            if (! $upload->shouldDeleteFiles()) {
                continue;
            }
            $values = $repeatableValues->pluck($upload->getName())->toArray();
            foreach ($values as $value) {
                if (! $value) {
                    continue;
                }

                if (is_array($value)) {
                    foreach ($value as $subvalue) {
                        Storage::disk($upload->getDisk())->delete($upload->getPath().$subvalue);
                    }

                    continue;
                }

                Storage::disk($upload->getDisk())->delete($upload->getPath().$value);
            }
        }
    }
    /*******************************
     * Helper methods
     *******************************/

    /**
     * Given two multidimensional arrays/collections, merge them recursively.
     */
    protected function mergeValuesRecursive(array|Collection $array1, array|Collection $array2): array|Collection
    {
        $merged = $array1;
        foreach ($array2 as $key => &$value) {
            if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
                $merged[$key] = $this->mergeValuesRecursive($merged[$key], $value);
            } else {
                $merged[$key] = $value;
            }
        }

        return $merged;
    }

    /**
     * Repeatable items send `_order_` parameter in the request.
     * This holds the order of the items in the repeatable container.
     */
    protected function getFileOrderFromRequest(): array
    {
        $items = CRUD::getRequest()->input('_order_'.$this->getRepeatableContainerName()) ?? [];

        array_walk($items, function (&$key, $value) {
            $requestValue = $key[$this->getName()] ?? null;
            $key = $this->handleMultipleFiles ? (is_string($requestValue) ? explode(',', $requestValue) : $requestValue) : $requestValue;
        });

        return $items;
    }

    private function getPreviousRepeatableValues(Model $entry, UploaderInterface $uploader): array
    {
        $previousValues = $entry->getOriginal($uploader->getRepeatableContainerName());

        if (! is_array($previousValues)) {
            $previousValues = json_decode($previousValues, true);
        }

        if (! empty($previousValues)) {
            $previousValues = array_column($previousValues, $uploader->getName());
        }

        return $previousValues ?? [];
    }

    private function getValuesWithPathStripped(array|string|null $item, UploaderInterface $uploader)
    {
        $uploadedValues = $item[$uploader->getName()] ?? null;
        if (is_array($uploadedValues)) {
            return array_map(function ($value) use ($uploader) {
                return $uploader->getValueWithoutPath($value);
            }, $uploadedValues);
        }

        return isset($uploadedValues) ? $uploader->getValueWithoutPath($uploadedValues) : null;
    }

    private function deleteRelationshipFiles(Model $entry): void
    {
        if (! is_a($entry, Pivot::class, true)) {
            $entry->loadMissing($this->getRepeatableContainerName());
        }

        foreach (app('UploadersRepository')->getRepeatableUploadersFor($this->getRepeatableContainerName()) as $uploader) {
            if ($uploader->shouldDeleteFiles()) {
                $uploader->deleteRepeatableRelationFiles($entry);
            }
        }
    }

    protected function deleteRepeatableRelationFiles(Model $entry)
    {
        if (in_array($this->getRepeatableRelationType(), ['BelongsToMany', 'MorphToMany'])) {
            if (! is_a($entry, Pivot::class, true)) {
                $pivots = $entry->{$this->getRepeatableContainerName()};
                foreach ($pivots as $pivot) {
                    $this->deletePivotModelFiles($pivot);
                }

                return;
            }

            $pivotAttributes = $entry->getAttributes();
            $connectedPivot = $entry->pivotParent->{$this->getRepeatableContainerName()}->where(function ($item) use ($pivotAttributes) {
                $itemPivotAttributes = $item->pivot->only(array_keys($pivotAttributes));

                return $itemPivotAttributes === $pivotAttributes;
            })->first();

            if (! $connectedPivot) {
                return;
            }

            $this->deletePivotModelFiles($connectedPivot);
        }

        $this->deleteFiles($entry);

It seems like deleteFiles() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    private function deletePivotModelFiles(Pivot|Model $entry)
    {
        $files = $entry->getOriginal()['pivot_'.$this->getAttributeName()];

        if (! $files) {
            return;
        }

        if ($this->handleMultipleFiles && is_string($files)) {
            try {
                $files = json_decode($files, true);
            } catch (\Exception) {
                Log::error('Could not parse files for deletion pivot entry with key: '.$entry->getKey().' and uploader: '.$this->getName());

                return;
            }
        }

        if (is_array($files)) {
            foreach ($files as $value) {
                $value = Str::start($value, $this->getPath());

It seems like getPath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

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

It seems like getDisk() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            }

            return;
        }

        $value = Str::start($files, $this->getPath());
        Storage::disk($this->getDisk())->delete($value);
    }
}