Zing\QueryBuilder\Concerns\WithSearchable

Complexity

Total Complexity

9

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
B	searchable()	0	38	8
A	addNestedRelation()	0	13	1

<?php

namespace Zing\QueryBuilder\Concerns;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;

trait WithSearchable
{
    /**
     * @param string $field
     * @param array $results
     *
     * @return array
     */
    private function addNestedRelation($field, array $results)
    {
        [$relation, $property] = collect(explode('.', $field))
            ->pipe(function (Collection $parts) {
                return [
                    $parts->except(count($parts) - 1)->map([Str::class, 'camel'])->implode('.'),
                    $parts->last(),
                ];
            });

        $results[$relation][] = $property;

        return $results;
    }

    public function searchable($searchable)
    {
        $searchable = is_array($searchable) ? $searchable : func_get_args();
        $search = $this->request->input('search');
        if ($search) {
            $this->where(

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

                function (Builder $query) use ($search, $searchable) {
                    $results = [];
                    foreach ($searchable as $field) {
                        if (Str::contains($field, '.')) {
                            $results = $this->addNestedRelation($field, $results);
                        } else {
                            $results[] = $field;
                        }
                    }
                    foreach ($results as $key => $value) {
                        if (is_numeric($key)) {
                            $query->orWhere($value, 'like', "%{$search}%");
                        } else {
                            $query->orWhereHas(
                                $key,
                                function ($query) use ($value, $search) {
                                    /** @var \Illuminate\Database\Query\Builder $query */
                                    $query->where(
                                        function (Builder $query) use ($value, $search) {
                                            foreach ($value as $field) {
                                                $query->orWhere($field, 'like', "%{$search}%");
                                            }
                                        }
                                    );
                                }
                            );
                        }
                    }
                }
            );
        }//end if
        return $this;
    }
}