Shamaseen\Repository\Utility\Models\Criteriable

Complexity

Total Complexity

34

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Importance

Changes	12
Bugs	3	Features	4

15 Methods

Rating	Name	Duplication	Size	Complexity
A	scopeAppendSortables()	0	5	1
A	getSortables()	0	7	2
A	scopeSetSearchables()	0	5	1
B	scopeFilterByCriteria()	0	26	8
A	scopeAppendSearchables()	0	5	1
B	scopeSearchByCriteria()	0	43	7
A	getFilterKey()	0	3	1
A	searchByCriteriaQueryPerColumn()	0	3	1
A	scopeOrderByCriteria()	0	7	3
A	scopeSetSortables()	0	5	1
A	getFilterables()	0	7	2
A	getSearchables()	0	7	2
A	scopeAppendFilterables()	0	5	1
A	getFiltersFromCriteria()	0	9	2
A	scopeSetFilterables()	0	5	1

<?php

namespace Shamaseen\Repository\Utility\Models;

use Illuminate\Database\Eloquent\Builder;

/**
 * @method static Builder filterByCriteria(array $criteria)
 * @method static Builder searchByCriteria(array $criteria)
 * @method static Builder orderByCriteria(array $criteria)
 * @method static Builder setSearchables(array $searchables)
 * @method static Builder appendSearchables(array $searchables)
 * @method static Builder setFilterables(array $filterables)
 * @method static Builder appendFilterables(array $filterables)
 * @method static Builder setSortables(array $sortables)
 * @method static Builder appendSortables(array $sortables)
 */
trait Criteriable
{
    protected ?array $searchables = null;
    protected ?array $filterables = null;
    protected ?array $sortables = null;
    protected string $fullTextSearchMode = '';
    protected bool $fullTextSearchExpansion = false;

    /**
     * @var string[]|array<string, string[]>
     */
    protected ?array $fulltextSearch = [];

    public function getFilterKey()
    {
        return config('repository.filter_key');
    }

    protected function getFiltersFromCriteria(array $criteria): array
    {
        $filterKey = $this->getFilterKey();

        if ($filterKey) {
            return (array) ($criteria[$filterKey] ?? []);
        }

        return $criteria;
    }

    public function scopeFilterByCriteria($query, array $criteria): Builder
    {
        $requestFilters = $this->getFiltersFromCriteria($criteria);

        foreach ($this->getFilterables() as $method => $columns) {
            // if this is associative then it is a relation
            if ('string' === gettype($method)) {
                if (method_exists($this, $method) && array_key_exists($method, $requestFilters)) {
                    $query->whereHas($method, function ($query) use ($requestFilters, $columns, $method) {
                        /* @var $query Builder */
                        $query->where(function ($query2) use ($requestFilters, $columns, $method) {
                            /* @var $query2 Builder */
                            foreach ((array) $columns as $column) {
                                if (isset($requestFilters[$method][$column])) {
                                    $query2->where($column, $requestFilters[$method][$column]);
                                }
                            }
                        });
                    });
                }
            } elseif (array_key_exists($columns, $requestFilters)) {
                $query->where($columns, $requestFilters[$columns]);
            }
        }

        return $query;
    }

    public function scopeSearchByCriteria($query, array $criteria): Builder
    {
        if (!isset($criteria['search'])) {
            return $query;
        }

        $fullTextOptions = [
            'mode' => $this->fullTextSearchMode,
            'expanded' => $this->fullTextSearchExpansion
        ];

        $query->where(function ($q) use ($criteria, $fullTextOptions) {
            foreach ($this->fulltextSearch as $method => $columns) {
                if (method_exists($this, $method)) {
                    $q->orWhereHas($method, function ($q2) use ($criteria, $columns, $fullTextOptions) {
                        $q2->whereFullText($columns, $criteria['search'], $fullTextOptions);
                    });
                } else {
                    $q->whereFullText($columns, $criteria['search'], $fullTextOptions);
                }
            }

            /*
             * @var Builder $q
             */
            foreach ($this->getSearchables() as $method => $columns) {
                if (method_exists($this, $method)) {
                    $q->orWhereHas($method, function ($query) use ($criteria, $columns) {
                        /* @var $query Builder */
                        $query->where(function ($query2) use ($criteria, $columns) {
                            /* @var $query2 Builder */
                            foreach ((array) $columns as $column) {
                                $this->searchByCriteriaQueryPerColumn($query2, $column, $criteria['search']);
                            }
                        });
                    });
                } else {
                    $this->searchByCriteriaQueryPerColumn($q, $columns, $criteria['search']);
                }
            }
        });

        return $query;
    }

    protected function searchByCriteriaQueryPerColumn(Builder $query, string $column, string $search): void
    {
        $query->orWhere($column, 'like', $search.'%');
    }

    public function scopeOrderByCriteria($query, array $criteria): Builder
    {
        if (isset($criteria['order']) && in_array($criteria['order'], $this->getSortables())) {
            $query->orderBy($criteria['order'], $criteria['direction'] ?? 'desc');
        }

        return $query;
    }

    /**
     * By default, all fillables and not hidden are searchables, if you want to override that explicitly set an array of searchables.
     * For a relation this is the syntax [ relationName => [columns in the relation] ].
     */
    public function getSearchables(): array
    {
        if (null !== $this->searchables) {
            return $this->searchables;
        }

        return array_diff($this->getFillable(), $this->getHidden());

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

The method getFillable() does not exist on Shamaseen\Repository\Utility\Models\Criteriable. Did you maybe mean getFilterables()?

    }

    public function scopeAppendSearchables($query, array $searchables): Builder
    {
        $this->searchables = collect($this->searchables)->merge($searchables)->unique()->toArray();

It seems like $this->searchables can also be of type array; however, parameter $value of collect() does only seem to accept Illuminate\Contracts\Support\Arrayable, maybe add an additional type check?

$searchables of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\Collection::merge().

        return $query;
    }

    public function scopeSetSearchables($query, array $searchables): Builder
    {
        $this->searchables = $searchables;

        return $query;
    }

    /**
     * By default, all fillables and not hidden are sortables, if you want to override that explicitly set an array of sortables.
     */
    public function getSortables(): array
    {
        if (null !== $this->sortables) {
            return $this->sortables;
        }

        return array_diff($this->getFillable(), $this->getHidden());
    }

    public function scopeAppendSortables($query, array $sortables): Builder
    {
        $this->sortables = collect($this->sortables)->merge($sortables)->unique()->toArray();

$sortables of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\Collection::merge().

It seems like $this->sortables can also be of type array; however, parameter $value of collect() does only seem to accept Illuminate\Contracts\Support\Arrayable, maybe add an additional type check?

        return $query;
    }

    public function scopeSetSortables($query, array $sortables): Builder
    {
        $this->sortables = $sortables;

        return $query;
    }

    /**
     * By default, all fillables and not hidden are filterables, if you want to override that explicitly set an array of searchables.
     * For a relation this is the syntax [ relationName => [columns in the relation] ].
     */
    public function getFilterables(): array
    {
        if (null !== $this->filterables) {
            return $this->filterables;
        }

        return array_diff($this->getFillable(), $this->getHidden());
    }

    public function scopeAppendFilterables($query, array $filterables): Builder
    {
        $this->filterables = collect($this->filterables)->merge($filterables)->unique()->toArray();

It seems like $this->filterables can also be of type array; however, parameter $value of collect() does only seem to accept Illuminate\Contracts\Support\Arrayable, maybe add an additional type check?

$filterables of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\Collection::merge().

        return $query;
    }

    public function scopeSetFilterables($query, array $filterables): Builder
    {
        $this->filterables = $filterables;

        return $query;
    }
}