ExportResourceAction::replaceFieldValuesWhenOnResource() - Code Metrics - dev-think-one/nova-resource-dynamic-export - Measure and Improve Code Quality continuously with Scrutinizer

replaceFieldValuesWhenOnResource() A
last analyzed 2023-09-06 05:23 UTC

↳ Parent: ExportResourceAction

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	12
ccs	8
cts	8
cp	1
rs	10
cc	2
nc	2
nop	2
crap	2

<?php


namespace NovaResourceDynamicExport\Nova\Actions;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Laravel\Nova\Actions\Action;
use Laravel\Nova\Fields\BooleanGroup;
use Laravel\Nova\Http\Requests\ActionRequest;
use Laravel\Nova\Nova;
use Maatwebsite\Excel\Facades\Excel;
use Maatwebsite\LaravelNovaExcel\Actions\ExportToExcel;
use Maatwebsite\LaravelNovaExcel\Requests\ExportActionRequest;
use NovaResourceDynamicExport\Models\ExportStoredFile;

class ExportResourceAction extends ExportToExcel
{
    protected bool $columnsSelected = false;
    protected array $columns;

    protected ?\Closure $postReplaceFieldValuesWhenOnResource = null;

    public function askForColumns(array $options, string $label = null, callable $callback = null): static
    {
        $this->columns = collect($options)
        $this->columns = collect(/** @scrutinizer ignore-type */ $options)
            ->mapWithKeys(function ($value, $key) {
                if (is_integer($key)) {
                    return [$value => Nova::humanize(Str::camel($value))];
                }

                return [$key => $value];
            })
            ->all();

        $field = BooleanGroup::make(
            __($label ?: 'Columns'),
            'columns'
        )
            ->options($this->columns)
            ->options(/** @scrutinizer ignore-type */ $this->columns)
            ->default(function () {
                return array_combine(
                    array_keys($this->columns),
                    array_fill(0, count($this->columns), true)
                );
            });

        if (is_callable($callback)) {
            $callback($field);
        }

        $this->actionFields[] = $field;

        return $this;
    }

    public function handleRequest(ActionRequest $request)
    {
        $this->handleColumns($request);

        return parent::handleRequest($request);
    }

    public function handle(ActionRequest $request, Action $exportable): mixed
    {
        $dbExport = ExportStoredFile::init(
            $request->resource()::uriKey(),
            $this->getDisk() ?: config('nova-resource-dynamic-export.defaults.disk'),
            date('Y/m/d/') . Str::uuid() . '.' . $this->getDefaultExtension(),
            $this->getFilename(),
            /** @scrutinizer ignore-type */ $this->getFilename(),
            function ($file) use ($request) {
                $file->meta
                    ->setAttribute('fields', $request->resolveFields())
                    ->setAttribute('filters', $request->filters);
                if ($user = $request->user()) {
                    $file->meta->toMorph('author', $user);
                }
            }
        );

        try {
            $response = Excel::store(
                $exportable,
                $dbExport->path,
                $dbExport->disk,
                $this->getWriterType()
            );
        } catch (\Exception $e) {
            $response = $e->getMessage();
        }

        if (true !== $response) {
            return \is_callable($this->onFailure)
                ? ($this->onFailure)($request, $response)
                : Action::danger($response ?: __('Resource could not be exported.'));
        }

        $dbExport->save();

        return \is_callable($this->onSuccess)
            ? ($this->onSuccess)($request, $response)
            : Action::message(__('Data exported to file.'));
    }

    protected function handleColumns(ActionRequest $request): void
    {
        $fields = $request->resolveFields();

        if ($columns = $fields->get('columns')) {
            $activeColumns = array_keys(array_filter($columns));
            $activeColumns = array_keys(array_filter(/** @scrutinizer ignore-type */ $columns));
            if (count($activeColumns) > 0) {
                $this->columnsSelected = true;
                $this->only            = $activeColumns;
            }
        }
    }

    protected function handleHeadings($query, ExportActionRequest $request)
    protected function handleHeadings(/** @scrutinizer ignore-unused */ $query, ExportActionRequest $request)
    {
        if ($this->columnsSelected) {
            $this->headings = Arr::only($this->columns, $this->only);
        } else {
            $this->headings = collect($this->only)
            $this->headings = collect(/** @scrutinizer ignore-type */ $this->only)
                ->map(function ($item) {
                    return Str::title($item);
                })
                ->all();
        }
    }

    public function setPostReplaceFieldValuesWhenOnResource(?\Closure $closure): static
    {
        $this->postReplaceFieldValuesWhenOnResource = $closure;

        return $this;
    }


    protected function replaceFieldValuesWhenOnResource(Model $model, array $only = []): array
    {
        $row = parent::replaceFieldValuesWhenOnResource($model, $only);

        if (is_callable($this->postReplaceFieldValuesWhenOnResource)) {
            $row = call_user_func_array(
                $this->postReplaceFieldValuesWhenOnResource,
                /** @scrutinizer ignore-type */ $this->postReplaceFieldValuesWhenOnResource,
                [$row, $model, $only,]
            );
        }

        return $row;
    }
}


dev-think-one / nova-resource-dynamic-export

replaceFieldValuesWhenOnResource() A last analyzed 2023-09-06 05:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

replaceFieldValuesWhenOnResource() A
last analyzed 2023-09-06 05:23 UTC