QueryBuilderAbstract::first() - Code Metrics - Inspection of "pass request to init" - apichef/laravel-request-to-eloquent - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2d8f1b...7a2414 )

by Milroy

created 2020-02-16 02:55 UTC

QueryBuilderAbstract::first() A

↳ Parent: QueryBuilderAbstract

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace ApiChef\RequestToEloquent;

use ApiChef\RequestQueryHelper\Fields;
use ApiChef\RequestQueryHelper\QueryParamBag;
use ApiChef\RequestQueryHelper\SortField;
use ApiChef\RequestQueryHelper\Sorts;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use RuntimeException;

abstract class QueryBuilderAbstract
{
    /** @var Request $request */
    private $request;

    /** @var Fields $fields */
    protected $fields;

    /** @var QueryParamBag $includes */
    protected $includes;

    /** @var QueryParamBag $filters */
    protected $filters;

    /** @var Sorts $sorts */
    protected $sorts;

    /** @var EloquentBuilder|QueryBuilder $request */
    private $query;

    private $allowedIncludes = [];

    private $allPossibleAvailableIncludes = null;

    protected $availableIncludes = [];

    protected $availableFilters = [];

    protected $availableSorts = [];

    public function __construct(Request $request)
    {
        $this->request = $request;
        $this->fields = $request->fields();
        $this->includes = $request->includes();
        $this->filters = $request->filters();
        $this->sorts = $request->sorts();
        $this->query = $this->init($request);
    }

    /**
     * Initialise the query.
     *
     * @param Request $request
     * @return EloquentBuilder|QueryBuilder
     */
    abstract protected function init(Request $request);

    protected function includesMap(): array
    {
        return [];
    }

    protected function filtersMap(): array
    {
        return [];
    }

    protected function sortsMap(): array
    {
        return [];
    }

    public function parseAllowedIncludes(array $allowedIncludes): self
    {
        $this->allowedIncludes = $this->getPossibleRelationshipCombinations($allowedIncludes);

        return $this;
    }

    private function getPossibleRelationshipCombinations(array $relations)
    {
        $combinations = [];

        foreach ($relations as $relation) {
            $combination = null;
            foreach (explode('.', $relation) as $part) {
                $combination .= is_null($combination) ? $part : ".{$part}";
                if (! in_array($combination, $combinations)) {
                    array_push($combinations, $combination);
                }
            }
        }

        return $combinations;
    }

    /**
     * Build and get query.
     *
     * @return EloquentBuilder|QueryBuilder
     */
    public function query()
    {
        if (! empty($this->allowedIncludes) && $this->request->filled(config('request-query-helper.include'))) {
            $this->loadIncludes($this->includes);
        }

        if ($this->request->filled(config('request-query-helper.filter'))) {
            $this->applyFilters($this->filters);
        }

        if ($this->request->filled(config('request-query-helper.sort'))) {
            $this->applySorts($this->sorts);
        }

        return $this->query;
    }

    /**
     * Execute the query.
     *
     * @return Collection
     */
    public function get()
    {
        return $this->query()->get();
    }

    /**
     * Execute the query and get the first result.
     *
     * @param array $columns
     * @return Model|object|null
     */
    public function first($columns = ['*'])
    {
        return $this->query()->first($columns);
    }

    private function loadIncludes(QueryParamBag $includes)
    {
        $includes->each(function ($params, $relation) {
            if ($this->isAllowedToInclude($relation)) {
                $this->loadRelation($relation, $params);
            }
        });
    }

    private function isAllowedToInclude($relation): bool
    {
        return in_array($relation, $this->allowedIncludes);
    }

    private function loadRelation($relation, $params): void
    {
        if ($relationAlias = Arr::get($this->includesMap(), $relation)) {
            $this->query->with($relationAlias);

            return;
        }

        $methodName = 'include'.Str::studly(str_replace('.', 'With', $relation));
        if (method_exists($this, $methodName)) {
            $this->{$methodName}($this->query, $params);

            return;
        }

        if (is_null($this->allPossibleAvailableIncludes)) {
            $this->allPossibleAvailableIncludes = $this->getPossibleRelationshipCombinations($this->availableIncludes);
        }

        if (in_array($relation, $this->allPossibleAvailableIncludes)) {
            $this->query->with($relation);

            return;
        }

        throw new RuntimeException("Trying to include non existing relationship {$relation}");
    }

    private function applyFilters(QueryParamBag $filters)
    {
        $filters->each(function ($params, $scope) {
            $this->applyFilter($scope, $params);
        });
    }

    private function applyFilter($scope, $params)
    {
        if ($filterAlias = Arr::get($this->filtersMap(), $scope)) {
            $this->query->{$filterAlias}($params);

            return;
        }

        $methodName = 'filterBy'.Str::studly($scope);

        if (method_exists($this, $methodName)) {
            $this->{$methodName}($this->query, $params);

            return;
        }

        if (in_array($scope, $this->availableFilters)) {
            $this->query->{$scope}($params);

            return;
        }

        throw new RuntimeException("Trying to filter by non existing filter {$scope}");
    }

    private function applySorts(Sorts $sorts)
    {
        $sorts->each(function (SortField $sortField) {
            $this->applySort($sortField->getField(), $sortField->getDirection());
        });
    }

    private function applySort(string $field, string $direction)
    {
        if ($sortAlias = Arr::get($this->sortsMap(), $field)) {
            $this->query->orderBy($sortAlias, $direction);

            return;
        }

        $methodName = 'sortBy'.Str::studly($field);

        if (method_exists($this, $methodName)) {
            $this->{$methodName}($this->query, $direction);

            return;
        }

        if (in_array($field, $this->availableSorts)) {
            $this->query->orderBy($field, $direction);

            return;
        }

        throw new RuntimeException("Trying to sort by non existing field {$field}");
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace ApiChef\RequestToEloquent;
6
7		use ApiChef\RequestQueryHelper\Fields;
8		use ApiChef\RequestQueryHelper\QueryParamBag;
9		use ApiChef\RequestQueryHelper\SortField;
10		use ApiChef\RequestQueryHelper\Sorts;
11		use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
12		use Illuminate\Database\Eloquent\Collection;
13		use Illuminate\Database\Eloquent\Model;
14		use Illuminate\Database\Query\Builder as QueryBuilder;
15		use Illuminate\Http\Request;
16		use Illuminate\Support\Arr;
17		use Illuminate\Support\Str;
18		use RuntimeException;
19
20		abstract class QueryBuilderAbstract
21		{
22		/** @var Request $request */
23		private $request;
24
25		/** @var Fields $fields */
26		protected $fields;
27
28		/** @var QueryParamBag $includes */
29		protected $includes;
30
31		/** @var QueryParamBag $filters */
32		protected $filters;
33
34		/** @var Sorts $sorts */
35		protected $sorts;
36
37		/** @var EloquentBuilder\|QueryBuilder $request */
38		private $query;
39
40		private $allowedIncludes = [];
41
42		private $allPossibleAvailableIncludes = null;
43
44		protected $availableIncludes = [];
45
46		protected $availableFilters = [];
47
48		protected $availableSorts = [];
49
50	51	public function __construct(Request $request)
51		{
52	51	$this->request = $request;
53	51	$this->fields = $request->fields();
54	51	$this->includes = $request->includes();
55	51	$this->filters = $request->filters();
56	51	$this->sorts = $request->sorts();
57	51	$this->query = $this->init($request);
58	51	}
59
60		/**
61		* Initialise the query.
62		*
63		* @param Request $request
64		* @return EloquentBuilder\|QueryBuilder
65		*/
66		abstract protected function init(Request $request);
67
68		protected function includesMap(): array
69		{
70		return [];
71		}
72
73		protected function filtersMap(): array
74		{
75		return [];
76		}
77
78		protected function sortsMap(): array
79		{
80		return [];
81		}
82
83	21	public function parseAllowedIncludes(array $allowedIncludes): self
84		{
85	21	$this->allowedIncludes = $this->getPossibleRelationshipCombinations($allowedIncludes);
86
87	21	return $this;
88		}
89
90	21	private function getPossibleRelationshipCombinations(array $relations)
91		{
92	21	$combinations = [];
93
94	21	foreach ($relations as $relation) {
95	21	$combination = null;
96	21	foreach (explode('.', $relation) as $part) {
97	21	$combination .= is_null($combination) ? $part : ".{$part}";
98	21	if (! in_array($combination, $combinations)) {
99	21	array_push($combinations, $combination);
100		}
101		}
102		}
103
104	21	return $combinations;
105		}
106
107		/**
108		* Build and get query.
109		*
110		* @return EloquentBuilder\|QueryBuilder
111		*/
112	51	public function query()
113		{
114	51	if (! empty($this->allowedIncludes) && $this->request->filled(config('request-query-helper.include'))) {
115	21	$this->loadIncludes($this->includes);
116		}
117
118	48	if ($this->request->filled(config('request-query-helper.filter'))) {
119	12	$this->applyFilters($this->filters);
120		}
121
122	45	if ($this->request->filled(config('request-query-helper.sort'))) {
123	12	$this->applySorts($this->sorts);
124		}
125
126	42	return $this->query;
127		}
128
129		/**
130		* Execute the query.
131		*
132		* @return Collection
133		*/
134	27	public function get()
135		{
136	27	return $this->query()->get();
137		}
138
139		/**
140		* Execute the query and get the first result.
141		*
142		* @param array $columns
143		* @return Model\|object\|null
144		*/
145	21	public function first($columns = ['*'])
146		{
147	21	return $this->query()->first($columns);
148		}
149
150	21	private function loadIncludes(QueryParamBag $includes)
151		{
152		$includes->each(function ($params, $relation) {
153	21	if ($this->isAllowedToInclude($relation)) {
154	21	$this->loadRelation($relation, $params);
155		}
156	21	});
157	18	}
158
159	21	private function isAllowedToInclude($relation): bool
160		{
161	21	return in_array($relation, $this->allowedIncludes);
162		}
163
164	21	private function loadRelation($relation, $params): void
165		{
166	21	if ($relationAlias = Arr::get($this->includesMap(), $relation)) {
167	3	$this->query->with($relationAlias);
168
169	3	return;
170		}
171
172	18	$methodName = 'include'.Str::studly(str_replace('.', 'With', $relation));
173	18	if (method_exists($this, $methodName)) {
174	6	$this->{$methodName}($this->query, $params);
175
176	6	return;
177		}
178
179	12	if (is_null($this->allPossibleAvailableIncludes)) {
180	12	$this->allPossibleAvailableIncludes = $this->getPossibleRelationshipCombinations($this->availableIncludes);
181		}
182
183	12	if (in_array($relation, $this->allPossibleAvailableIncludes)) {
184	9	$this->query->with($relation);
185
186	9	return;
187		}
188
189	3	throw new RuntimeException("Trying to include non existing relationship {$relation}");
190		}
191
192	12	private function applyFilters(QueryParamBag $filters)
193		{
194		$filters->each(function ($params, $scope) {
195	12	$this->applyFilter($scope, $params);
196	12	});
197	9	}
198
199	12	private function applyFilter($scope, $params)
200		{
201	12	if ($filterAlias = Arr::get($this->filtersMap(), $scope)) {
202	3	$this->query->{$filterAlias}($params);
203
204	3	return;
205		}
206
207	9	$methodName = 'filterBy'.Str::studly($scope);
208
209	9	if (method_exists($this, $methodName)) {
210	3	$this->{$methodName}($this->query, $params);
211
212	3	return;
213		}
214
215	6	if (in_array($scope, $this->availableFilters)) {
216	3	$this->query->{$scope}($params);
217
218	3	return;
219		}
220
221	3	throw new RuntimeException("Trying to filter by non existing filter {$scope}");
222		}
223
224	12	private function applySorts(Sorts $sorts)
225		{
226		$sorts->each(function (SortField $sortField) {
227	12	$this->applySort($sortField->getField(), $sortField->getDirection());
228	12	});
229	9	}
230
231	12	private function applySort(string $field, string $direction)
232		{
233	12	if ($sortAlias = Arr::get($this->sortsMap(), $field)) {
234	3	$this->query->orderBy($sortAlias, $direction);
235
236	3	return;
237		}
238
239	9	$methodName = 'sortBy'.Str::studly($field);
240
241	9	if (method_exists($this, $methodName)) {
242	3	$this->{$methodName}($this->query, $direction);
243
244	3	return;
245		}
246
247	6	if (in_array($field, $this->availableSorts)) {
248	3	$this->query->orderBy($field, $direction);
249
250	3	return;
251		}
252
253	3	throw new RuntimeException("Trying to sort by non existing field {$field}");
254		}
255		}
256

apichef / laravel-request-to-eloquent

Push — master ( 2d8f1b...7a2414 )

QueryBuilderAbstract::first() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like