Model::chunk() - Code Metrics - Inspection of "Adding ID to form groups for custom functions" - z-song/laravel-admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1281)

unknown

created 2017-10-03 02:35 UTC

Model::chunk() A

↳ Parent: Model

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	9
nc	2
nop	2
dl	0
loc	16
rs	9.4285
c	0
b	0
f	0

<?php

namespace Encore\Admin\Grid;

use Encore\Admin\Middleware\Pjax;
use Illuminate\Database\Eloquent\Model as EloquentModel;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\Request;

class Model
{
    /**
     * Eloquent model instance of the grid model.
     *
     * @var EloquentModel
     */
    protected $model;

    /**
     * Array of queries of the eloquent model.
     *
     * @var \Illuminate\Support\Collection
     */
    protected $queries;

    /**
     * Sort parameters of the model.
     *
     * @var array
     */
    protected $sort;

    /**
     * @var array
     */
    protected $data = [];

    /*
     * 20 items per page as default.
     *
     * @var int
     */
    protected $perPage = 20;

    /**
     * If the model use pagination.
     *
     * @var bool
     */
    protected $usePaginate = true;

    /**
     * The query string variable used to store the per-page.
     *
     * @var string
     */
    protected $perPageName = 'per_page';

    /**
     * The query string variable used to store the sort.
     *
     * @var string
     */
    protected $sortName = '_sort';

    /**
     * Collection callback.
     *
     * @var \Closure
     */
    protected $collectionCallback;

    /**
     * Create a new grid model instance.
     *
     * @param EloquentModel $model
     */
    public function __construct(EloquentModel $model)
    {
        $this->model = $model;

        $this->queries = collect();

//        static::doNotSnakeAttributes($this->model);

    }

    /**
     * Don't snake case attributes.
     *
     * @param EloquentModel $model
     *
     * @return void
     */
    protected static function doNotSnakeAttributes(EloquentModel $model)
    {
        $class = get_class($model);

        $class::$snakeAttributes = false;
    }

    /**
     * Get the eloquent model of the grid model.
     *
     * @return EloquentModel
     */
    public function eloquent()
    {
        return $this->model;
    }

    /**
     * Enable or disable pagination.
     *
     * @param bool $use
     */
    public function usePaginate($use = true)
    {
        $this->usePaginate = $use;
    }

    /**
     * Get the query string variable used to store the per-page.
     *
     * @return string
     */
    public function getPerPageName()
    {
        return $this->perPageName;
    }

    /**
     * Set the query string variable used to store the per-page.
     *
     * @param string $name
     *
     * @return $this
     */
    public function setPerPageName($name)
    {
        $this->perPageName = $name;

        return $this;
    }

    /**
     * Get the query string variable used to store the sort.
     *
     * @return string
     */
    public function getSortName()
    {
        return $this->sortName;
    }

    /**
     * Set the query string variable used to store the sort.
     *
     * @param string $name
     *
     * @return $this
     */
    public function setSortName($name)
    {
        $this->sortName = $name;

        return $this;
    }

    /**
     * Set collection callback.
     *
     * @param \Closure $callback
     *
     * @return $this
     */
    public function collection(\Closure $callback = null)
    {
        $this->collectionCallback = $callback;

        return $this;
    }

    /**
     * Build.
     *
     * @param bool $toArray
     *
     * @return array|Collection|mixed
     */
    public function buildData($toArray = true)
    {
        if (empty($this->data)) {
            $collection = $this->get();

            if ($this->collectionCallback) {
                $collection = call_user_func($this->collectionCallback, $collection);
            }

            if ($toArray) {
                $this->data = $collection->toArray();
            } else {
                $this->data = $collection;

            }
        }

        return $this->data;
    }

    /**
     * @param callable $callback
     * @param int      $count
     *
     * @return bool
     */
    public function chunk($callback, $count = 100)
    {
        if ($this->usePaginate) {
            return $this->buildData(false)->chunk($count)->each($callback);
        }

        $this->setSort();

        $this->queries->reject(function ($query) {
            return $query['method'] == 'paginate';
        })->each(function ($query) {
            $this->model = $this->model->{$query['method']}(...$query['arguments']);
        });

        return $this->model->chunk($count, $callback);
    }

    /**
     * Add conditions to grid model.
     *
     * @param array $conditions
     *
     * @return $this
     */
    public function addConditions(array $conditions)
    {
        foreach ($conditions as $condition) {
            call_user_func_array([$this, key($condition)], current($condition));
        }

        return $this;
    }

    /**
     * Get table of the model.
     *
     * @return string
     */
    public function getTable()
    {
        return $this->model->getTable();
    }

    /**
     * @throws \Exception
     *
     * @return Collection
     */
    protected function get()
    {
        if ($this->model instanceof LengthAwarePaginator) {
            return $this->model;
        }

        $this->setSort();
        $this->setPaginate();

        $this->queries->unique()->each(function ($query) {
            $this->model = call_user_func_array([$this->model, $query['method']], $query['arguments']);
        });

        if ($this->model instanceof Collection) {
            return $this->model;
        }

        if ($this->model instanceof LengthAwarePaginator) {
            $this->handleInvalidPage($this->model);

            return $this->model->getCollection();
        }

        throw new \Exception('Grid query error');
    }

    /**
     * If current page is greater than last page, then redirect to last page.
     *
     * @param LengthAwarePaginator $paginator
     *
     * @return void
     */
    protected function handleInvalidPage(LengthAwarePaginator $paginator)
    {
        if ($paginator->lastPage() && $paginator->currentPage() > $paginator->lastPage()) {
            $lastPageUrl = Request::fullUrlWithQuery([
                $paginator->getPageName() => $paginator->lastPage(),
            ]);

            Pjax::respond(redirect($lastPageUrl));
        }
    }

    /**
     * Set the grid paginate.
     *
     * @return void
     */
    protected function setPaginate()
    {
        $paginate = $this->findQueryByMethod('paginate');

        $this->queries = $this->queries->reject(function ($query) {
            return $query['method'] == 'paginate';
        });

        if (!$this->usePaginate) {
            $query = [
                'method'    => 'get',
                'arguments' => [],
            ];
        } else {
            $query = [
                'method'    => 'paginate',
                'arguments' => $this->resolvePerPage($paginate),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ];
        }

        $this->queries->push($query);
    }

    /**
     * Resolve perPage for pagination.
     *
     * @param array|null $paginate
     *
     * @return array
     */
    protected function resolvePerPage($paginate)
    {
        if ($perPage = app('request')->input($this->perPageName)) {
            if (is_array($paginate)) {
                $paginate['arguments'][0] = (int) $perPage;

                return $paginate['arguments'];
            }

            $this->perPage = (int) $perPage;
        }

        if (isset($paginate['arguments'][0])) {
            return $paginate['arguments'];
        }

        return [$this->perPage];
    }

    /**
     * Find query by method name.
     *
     * @param $method
     *
     * @return static
     */
    protected function findQueryByMethod($method)
    {
        return $this->queries->first(function ($query) use ($method) {
            return $query['method'] == $method;
        });
    }

    /**
     * Set the grid sort.
     *
     * @return void
     */
    protected function setSort()
    {
        $this->sort = Input::get($this->sortName, []);

        if (!is_array($this->sort)) {
            return;
        }

        if (empty($this->sort['column']) || empty($this->sort['type'])) {
            return;
        }

        if (str_contains($this->sort['column'], '.')) {
            $this->setRelationSort($this->sort['column']);
        } else {
            $this->resetOrderBy();

            $this->queries->push([
                'method'    => 'orderBy',
                'arguments' => [$this->sort['column'], $this->sort['type']],
            ]);
        }
    }

    /**
     * Set relation sort.
     *
     * @param string $column
     *
     * @return void
     */
    protected function setRelationSort($column)
    {
        list($relationName, $relationColumn) = explode('.', $column);

        if ($this->queries->contains(function ($query) use ($relationName) {
            return $query['method'] == 'with' && in_array($relationName, $query['arguments']);
        })) {
            $relation = $this->model->$relationName();

            $this->queries->push([
                'method'    => 'join',
                'arguments' => $this->joinParameters($relation),
            ]);

            $this->resetOrderBy();

            $this->queries->push([
                'method'    => 'orderBy',
                'arguments' => [
                    $relation->getRelated()->getTable().'.'.$relationColumn,
                    $this->sort['type'],
                ],
            ]);
        }
    }

    /**
     * Reset orderBy query.
     *
     * @return void
     */
    public function resetOrderBy()
    {
        $this->queries = $this->queries->reject(function ($query) {
            return $query['method'] == 'orderBy';
        });
    }

    /**
     * Build join parameters for related model.
     *
     * `HasOne` and `BelongsTo` relation has different join parameters.
     *
     * @param Relation $relation
     *
     * @throws \Exception
     *
     * @return array
     */
    protected function joinParameters(Relation $relation)
    {
        $relatedTable = $relation->getRelated()->getTable();

        if ($relation instanceof BelongsTo) {
            return [
                $relatedTable,
                $relation->getForeignKey(),
                '=',
                $relatedTable.'.'.$relation->getRelated()->getKeyName(),
            ];
        }

        if ($relation instanceof HasOne) {
            return [
                $relatedTable,
                $relation->getQualifiedParentKeyName(),
                '=',
                $relation->getQualifiedForeignKeyName(),
            ];
        }

        throw new \Exception('Related sortable only support `HasOne` and `BelongsTo` relation.');
    }

    /**
     * @param string $method
     * @param array  $arguments
     *
     * @return $this
     */
    public function __call($method, $arguments)
    {
        $this->queries->push([
            'method'    => $method,
            'arguments' => $arguments,
        ]);

        return $this;
    }

    /**
     * @param $key
     *
     * @return mixed
     */
    public function __get($key)
    {
        $data = $this->buildData();

        if (array_key_exists($key, $data)) {
            return $data[$key];
        }
    }
}


1			<?php
2
3			namespace Encore\Admin\Grid;
4
5			use Encore\Admin\Middleware\Pjax;
6			use Illuminate\Database\Eloquent\Model as EloquentModel;
7			use Illuminate\Database\Eloquent\Relations\BelongsTo;
8			use Illuminate\Database\Eloquent\Relations\HasOne;
9			use Illuminate\Database\Eloquent\Relations\Relation;
10			use Illuminate\Pagination\LengthAwarePaginator;
11			use Illuminate\Support\Collection;
12			use Illuminate\Support\Facades\Input;
13			use Illuminate\Support\Facades\Request;
14
15			class Model
16			{
17			/**
18			* Eloquent model instance of the grid model.
19			*
20			* @var EloquentModel
21			*/
22			protected $model;
23
24			/**
25			* Array of queries of the eloquent model.
26			*
27			* @var \Illuminate\Support\Collection
28			*/
29			protected $queries;
30
31			/**
32			* Sort parameters of the model.
33			*
34			* @var array
35			*/
36			protected $sort;
37
38			/**
39			* @var array
40			*/
41			protected $data = [];
42
43			/*
44			* 20 items per page as default.
45			*
46			* @var int
47			*/
48			protected $perPage = 20;
49
50			/**
51			* If the model use pagination.
52			*
53			* @var bool
54			*/
55			protected $usePaginate = true;
56
57			/**
58			* The query string variable used to store the per-page.
59			*
60			* @var string
61			*/
62			protected $perPageName = 'per_page';
63
64			/**
65			* The query string variable used to store the sort.
66			*
67			* @var string
68			*/
69			protected $sortName = '_sort';
70
71			/**
72			* Collection callback.
73			*
74			* @var \Closure
75			*/
76			protected $collectionCallback;
77
78			/**
79			* Create a new grid model instance.
80			*
81			* @param EloquentModel $model
82			*/
83			public function __construct(EloquentModel $model)
84			{
85			$this->model = $model;
86
87			$this->queries = collect();
88
89			// static::doNotSnakeAttributes($this->model);
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-10-03 02:38 UTC by Report Bug Copy Issue Report `70%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
90			}
91
92			/**
93			* Don't snake case attributes.
94			*
95			* @param EloquentModel $model
96			*
97			* @return void
98			*/
99			protected static function doNotSnakeAttributes(EloquentModel $model)
100			{
101			$class = get_class($model);
102
103			$class::$snakeAttributes = false;
104			}
105
106			/**
107			* Get the eloquent model of the grid model.
108			*
109			* @return EloquentModel
110			*/
111			public function eloquent()
112			{
113			return $this->model;
114			}
115
116			/**
117			* Enable or disable pagination.
118			*
119			* @param bool $use
120			*/
121			public function usePaginate($use = true)
122			{
123			$this->usePaginate = $use;
124			}
125
126			/**
127			* Get the query string variable used to store the per-page.
128			*
129			* @return string
130			*/
131			public function getPerPageName()
132			{
133			return $this->perPageName;
134			}
135
136			/**
137			* Set the query string variable used to store the per-page.
138			*
139			* @param string $name
140			*
141			* @return $this
142			*/
143			public function setPerPageName($name)
144			{
145			$this->perPageName = $name;
146
147			return $this;
148			}
149
150			/**
151			* Get the query string variable used to store the sort.
152			*
153			* @return string
154			*/
155			public function getSortName()
156			{
157			return $this->sortName;
158			}
159
160			/**
161			* Set the query string variable used to store the sort.
162			*
163			* @param string $name
164			*
165			* @return $this
166			*/
167			public function setSortName($name)
168			{
169			$this->sortName = $name;
170
171			return $this;
172			}
173
174			/**
175			* Set collection callback.
176			*
177			* @param \Closure $callback
178			*
179			* @return $this
180			*/
181			public function collection(\Closure $callback = null)
182			{
183			$this->collectionCallback = $callback;
184
185			return $this;
186			}
187
188			/**
189			* Build.
190			*
191			* @param bool $toArray
192			*
193			* @return array\|Collection\|mixed
194			*/
195			public function buildData($toArray = true)
196			{
197			if (empty($this->data)) {
198			$collection = $this->get();
199
200			if ($this->collectionCallback) {
201			$collection = call_user_func($this->collectionCallback, $collection);
202			}
203
204			if ($toArray) {
205			$this->data = $collection->toArray();
206			} else {
207			$this->data = $collection;
			0 ignored issues – show Documentation Bug introduced 2017-10-03 02:38 UTC by Report Bug Copy Issue Report It seems like `$collection` of type `*` is incompatible with the declared type `array` of property `$data`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
208			}
209			}
210
211			return $this->data;
212			}
213
214			/**
215			* @param callable $callback
216			* @param int $count
217			*
218			* @return bool
219			*/
220			public function chunk($callback, $count = 100)
221			{
222			if ($this->usePaginate) {
223			return $this->buildData(false)->chunk($count)->each($callback);
224			}
225
226			$this->setSort();
227
228			$this->queries->reject(function ($query) {
229			return $query['method'] == 'paginate';
230			})->each(function ($query) {
231			$this->model = $this->model->{$query['method']}(...$query['arguments']);
232			});
233
234			return $this->model->chunk($count, $callback);
235			}
236
237			/**
238			* Add conditions to grid model.
239			*
240			* @param array $conditions
241			*
242			* @return $this
243			*/
244			public function addConditions(array $conditions)
245			{
246			foreach ($conditions as $condition) {
247			call_user_func_array([$this, key($condition)], current($condition));
248			}
249
250			return $this;
251			}
252
253			/**
254			* Get table of the model.
255			*
256			* @return string
257			*/
258			public function getTable()
259			{
260			return $this->model->getTable();
261			}
262
263			/**
264			* @throws \Exception
265			*
266			* @return Collection
267			*/
268			protected function get()
269			{
270			if ($this->model instanceof LengthAwarePaginator) {
271			return $this->model;
272			}
273
274			$this->setSort();
275			$this->setPaginate();
276
277			$this->queries->unique()->each(function ($query) {
278			$this->model = call_user_func_array([$this->model, $query['method']], $query['arguments']);
279			});
280
281			if ($this->model instanceof Collection) {
282			return $this->model;
283			}
284
285			if ($this->model instanceof LengthAwarePaginator) {
286			$this->handleInvalidPage($this->model);
287
288			return $this->model->getCollection();
289			}
290
291			throw new \Exception('Grid query error');
292			}
293
294			/**
295			* If current page is greater than last page, then redirect to last page.
296			*
297			* @param LengthAwarePaginator $paginator
298			*
299			* @return void
300			*/
301			protected function handleInvalidPage(LengthAwarePaginator $paginator)
302			{
303			if ($paginator->lastPage() && $paginator->currentPage() > $paginator->lastPage()) {
304			$lastPageUrl = Request::fullUrlWithQuery([
305			$paginator->getPageName() => $paginator->lastPage(),
306			]);
307
308			Pjax::respond(redirect($lastPageUrl));
309			}
310			}
311
312			/**
313			* Set the grid paginate.
314			*
315			* @return void
316			*/
317			protected function setPaginate()
318			{
319			$paginate = $this->findQueryByMethod('paginate');
320
321			$this->queries = $this->queries->reject(function ($query) {
322			return $query['method'] == 'paginate';
323			});
324
325			if (!$this->usePaginate) {
326			$query = [
327			'method' => 'get',
328			'arguments' => [],
329			];
330			} else {
331			$query = [
332			'method' => 'paginate',
333			'arguments' => $this->resolvePerPage($paginate),
			0 ignored issues – show Documentation introduced 2016-12-05 09:22 UTC by Report Bug Copy Issue Report `$paginate` is of type `this<Encore\Admin\Grid\Model>`, but the function expects a `array\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
334			];
335			}
336
337			$this->queries->push($query);
338			}
339
340			/**
341			* Resolve perPage for pagination.
342			*
343			* @param array\|null $paginate
344			*
345			* @return array
346			*/
347			protected function resolvePerPage($paginate)
348			{
349			if ($perPage = app('request')->input($this->perPageName)) {
350			if (is_array($paginate)) {
351			$paginate['arguments'][0] = (int) $perPage;
352
353			return $paginate['arguments'];
354			}
355
356			$this->perPage = (int) $perPage;
357			}
358
359			if (isset($paginate['arguments'][0])) {
360			return $paginate['arguments'];
361			}
362
363			return [$this->perPage];
364			}
365
366			/**
367			* Find query by method name.
368			*
369			* @param $method
370			*
371			* @return static
372			*/
373			protected function findQueryByMethod($method)
374			{
375			return $this->queries->first(function ($query) use ($method) {
376			return $query['method'] == $method;
377			});
378			}
379
380			/**
381			* Set the grid sort.
382			*
383			* @return void
384			*/
385			protected function setSort()
386			{
387			$this->sort = Input::get($this->sortName, []);
			0 ignored issues – show Documentation Bug introduced 2016-12-05 09:22 UTC by Report Bug Copy Issue Report It seems like `\Illuminate\Support\Faca...his->sortName, array())` of type `*` is incompatible with the declared type `array` of property `$sort`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
388			if (!is_array($this->sort)) {
389			return;
390			}
391
392			if (empty($this->sort['column']) \|\| empty($this->sort['type'])) {
393			return;
394			}
395
396			if (str_contains($this->sort['column'], '.')) {
397			$this->setRelationSort($this->sort['column']);
398			} else {
399			$this->resetOrderBy();
400
401			$this->queries->push([
402			'method' => 'orderBy',
403			'arguments' => [$this->sort['column'], $this->sort['type']],
404			]);
405			}
406			}
407
408			/**
409			* Set relation sort.
410			*
411			* @param string $column
412			*
413			* @return void
414			*/
415			protected function setRelationSort($column)
416			{
417			list($relationName, $relationColumn) = explode('.', $column);
418
419			if ($this->queries->contains(function ($query) use ($relationName) {
420			return $query['method'] == 'with' && in_array($relationName, $query['arguments']);
421			})) {
422			$relation = $this->model->$relationName();
423
424			$this->queries->push([
425			'method' => 'join',
426			'arguments' => $this->joinParameters($relation),
427			]);
428
429			$this->resetOrderBy();
430
431			$this->queries->push([
432			'method' => 'orderBy',
433			'arguments' => [
434			$relation->getRelated()->getTable().'.'.$relationColumn,
435			$this->sort['type'],
436			],
437			]);
438			}
439			}
440
441			/**
442			* Reset orderBy query.
443			*
444			* @return void
445			*/
446			public function resetOrderBy()
447			{
448			$this->queries = $this->queries->reject(function ($query) {
449			return $query['method'] == 'orderBy';
450			});
451			}
452
453			/**
454			* Build join parameters for related model.
455			*
456			* `HasOne` and `BelongsTo` relation has different join parameters.
457			*
458			* @param Relation $relation
459			*
460			* @throws \Exception
461			*
462			* @return array
463			*/
464			protected function joinParameters(Relation $relation)
465			{
466			$relatedTable = $relation->getRelated()->getTable();
467
468			if ($relation instanceof BelongsTo) {
469			return [
470			$relatedTable,
471			$relation->getForeignKey(),
472			'=',
473			$relatedTable.'.'.$relation->getRelated()->getKeyName(),
474			];
475			}
476
477			if ($relation instanceof HasOne) {
478			return [
479			$relatedTable,
480			$relation->getQualifiedParentKeyName(),
481			'=',
482			$relation->getQualifiedForeignKeyName(),
483			];
484			}
485
486			throw new \Exception('Related sortable only support `HasOne` and `BelongsTo` relation.');
487			}
488
489			/**
490			* @param string $method
491			* @param array $arguments
492			*
493			* @return $this
494			*/
495			public function __call($method, $arguments)
496			{
497			$this->queries->push([
498			'method' => $method,
499			'arguments' => $arguments,
500			]);
501
502			return $this;
503			}
504
505			/**
506			* @param $key
507			*
508			* @return mixed
509			*/
510			public function __get($key)
511			{
512			$data = $this->buildData();
513
514			if (array_key_exists($key, $data)) {
515			return $data[$key];
516			}
517			}
518			}
519

z-song / laravel-admin

Pull Request — master (#1281)

Model::chunk() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like