NovaListCard\Http\Requests\CardRequest

Complexity

Total Complexity

18

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	authorize()	0	3	1
A	card()	0	14	4
A	rules()	0	3	1
B	prepareQuery()	0	37	10
A	cardResource()	0	8	2

<?php

namespace NovaListCard\Http\Requests;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Collection;
use Laravel\Nova\Http\Requests\NovaRequest;
use Laravel\Nova\Nova;
use Laravel\Nova\Resource;
use NovaListCard\ListCard;

class CardRequest extends NovaRequest
{
    protected ?ListCard $_card = null;

    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [];
    }


    public function card(): ?ListCard
    {
        if (!$this->_card) {
            $allCards = new Collection();
            collect(Nova::$dashboards)

Laravel\Nova\Nova::dashboards of type array<integer,Laravel\Nova\Dashboard> is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

                ->filter(fn ($dashboard) => method_exists($dashboard, 'cards') && is_array($dashboard->cards()))
                ->each(fn ($dashboard) => $allCards->push(...$dashboard->cards()));

            $this->_card = $allCards
                ->filter(fn ($card) => (method_exists($card, 'uriKey') && $card->uriKey() == $this->route('key')))
                ->first();
        }

        return $this->_card;
    }

    /**
     * @return class-string<Resource>

The doc comment class-string<Resource> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<Resource>.

     */
    public function cardResource(): string
    {
        $resource = $this->card()?->resource;
        if (!$resource) {
            throw new \Exception('Resource not found');
        }

        return $resource;
    }

    /**
     * @return Builder
     * @throws \Exception
     */
    public function prepareQuery(): Builder
    {
        $resource = $this->cardResource();

        /** @var Builder $query */
        $query = $resource::newModel()->query();

        $card = $this->card();

        if ($card->relationship) {
            $query = match ($card->aggregate) {
                'count' => $query->withCount($card->relationship),
                'sum'   => $query->withSum($card->relationship, $card->aggregateColumn ?: $card->valueColumn),
                'avg'   => $query->withAvg($card->relationship, $card->aggregateColumn ?: $card->valueColumn),
                'min'   => $query->withMin($card->relationship, $card->aggregateColumn ?: $card->valueColumn),
                'max'   => $query->withMax($card->relationship, $card->aggregateColumn ?: $card->valueColumn),
                default => $query
            };
        }


        if ($card->orderColumn) {
            $query->orderBy($card->orderColumn, $card->orderDirection);
        }

        if (
            ($limit = $card->limit) &&
            $limit > 0
        ) {
            $query->take($limit);
        }

        if (is_callable($card->queryCallback)) {
            call_user_func($card->queryCallback, $query);

It seems like $card->queryCallback can also be of type null; however, parameter $callback of call_user_func() does only seem to accept callable, maybe add an additional type check?

        }

        return $query;
    }
}