DisplayDatatablesAsync::applyOrders() - Code Metrics - Inspection of "Merge pull request #331 from aios/master" - LaravelRUS/SleepingOwlAdmin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 55fdb7...374a13 )

by butschster

created 2016-11-03 13:30 UTC

DisplayDatatablesAsync::applyOrders() B

↳ Parent: DisplayDatatablesAsync

Complexity

Conditions	6
Paths	4

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	12
nc	4
nop	1
dl	0
loc	18
rs	8.8571
c	1
b	0
f	0

<?php

namespace SleepingOwl\Admin\Display;

use Illuminate\Routing\Router;
use Request;
use Route;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Builder;
use SleepingOwl\Admin\Contracts\ModelConfigurationInterface;
use SleepingOwl\Admin\Display\Column\Email;
use SleepingOwl\Admin\Display\Column\Link;
use SleepingOwl\Admin\Display\Column\Text;
use SleepingOwl\Admin\Display\Column\Custom;
use SleepingOwl\Admin\Display\Column\NamedColumn;
use SleepingOwl\Admin\Display\Column\Control;
use SleepingOwl\Admin\Contracts\WithRoutesInterface;

class DisplayDatatablesAsync extends DisplayDatatables implements WithRoutesInterface
{
    /**
     * Register display routes.
     *
     * @param Router $router
     */
    public static function registerRoutes(Router $router)
    {
        $router->get('{adminModel}/async/{adminDisplayName?}', ['as' => 'admin.model.async',
            function (ModelConfigurationInterface $model, $name = null) {
                $display = $model->fireDisplay();
                if ($display instanceof DisplayTabbed) {
                    $display = static::findDatatablesAsyncByName($display, $name);
                }

                if ($display instanceof DisplayDatatablesAsync) {
                    return $display->renderAsync();
                }

                abort(404);
            },
        ]);
    }

    /**
     * Find DisplayDatatablesAsync in tabbed display by name.
     *
     * @param DisplayTabbed $display
     * @param string|null   $name
     *
     * @return DisplayDatatablesAsync|null
     */
    protected static function findDatatablesAsyncByName(DisplayTabbed $display, $name)
    {
        $tabs = $display->getTabs();
        foreach ($tabs as $tab) {
            $content = $tab->getContent();
            if ($content instanceof self && $content->getName() === $name) {
                return $content;
            }
        }
    }

    /**
     * @var string
     */
    protected $name;

    /**
     * @param string|null $name
     */
    protected $distinct;

    /**
     * @var array
     */
    protected $searchableColumns = [
        Text::class,
        Link::class,
        Email::class,
    ];

    /**
     * DisplayDatatablesAsync constructor.
     *
     * @param string|null $name
     * @param string|null $distinct
     */
    public function __construct($name = null, $distinct = null)
    {
        parent::__construct();

        $this->setName($name);
        $this->setDistinct($distinct);

        $this->getColumns()->setView('display.extensions.columns_async');
    }

    /**
     * Initialize display.
     */
    public function initialize()
    {
        parent::initialize();

        $attributes = Request::all();
        array_unshift($attributes, $this->getName());
        array_unshift($attributes, $this->getModelConfiguration()->getAlias());

        $this->setHtmlAttribute('data-url', route('admin.model.async', $attributes));
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @param string $name
     *
     * @return $this
     */
    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    /**
     * @return mixed
     */
    public function getDistinct()
    {
        return $this->distinct;
    }

    /**
     * @param mixed $distinct
     *
     * @return $this
     */
    public function setDistinct($distinct)
    {
        $this->distinct = $distinct;

        return $this;
    }

    /**
     * Render async request.
     * @return array
     */
    public function renderAsync()
    {
        $query = $this->getRepository()->getQuery();
        $totalCount = $query->count();
        $filteredCount = 0;

        if (! is_null($this->distinct)) {
            $filteredCount = $query->distinct()->count($this->getDistinct());
        }

        $this->modifyQuery($query);
        $this->applySearch($query);
        $this->applyColumnSearch($query);

        if (is_null($this->distinct)) {
            $filteredCount = $query->count();
        }

        $this->applyOrders($query);
        $this->applyOffset($query);
        $collection = $query->get();

        return $this->prepareDatatablesStructure($collection, $totalCount, $filteredCount);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Apply offset and limit to the query.
     *
     * @param $query
     */
    protected function applyOffset($query)
    {
        $offset = Request::input('start', 0);
        $limit = Request::input('length', 10);

        if ($limit == -1) {
            return;
        }

        $query->offset($offset)->limit($limit);
    }

    /**
     * Apply orders to the query.
     *
     * @param $query
     */
    protected function applyOrders($query)
    {
        $orders = Request::input('order', []);

        foreach ($orders as $order) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $columnIndex = $order['column'];
            $orderDirection = $order['dir'];
            $column = $this->getColumns()->all()->get($columnIndex);

            if ($column instanceof NamedColumn && $column->isOrderable()) {
                $name = $column->getName();
                $query->orderBy($name, $orderDirection);
            } elseif ($column instanceof Custom && $column->getOrderField()) {
                $name = $column->getOrderField();
                $query->orderBy($name, $orderDirection);
            }
        }
    }

    /**
     * Apply search to the query.
     *
     * @param Builder $query
     */
    protected function applySearch(Builder $query)
    {
        $search = Request::input('search.value');
        if (empty($search)) {
            return;
        }

        $query->where(function ($query) use ($search) {
            $columns = $this->getColumns()->all();
            foreach ($columns as $column) {
                if (in_array(get_class($column), $this->searchableColumns)) {
                    $name = $column->getName();
                    if ($this->repository->hasColumn($name)) {
                        $query->orWhere($name, 'like', '%'.$search.'%');
                    }
                }
            }
        });
    }

    /**
     * @param Builder $query
     */
    protected function applyColumnSearch(Builder $query)
    {
        $queryColumns = Request::input('columns', []);

        foreach ($queryColumns as $index => $queryColumn) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $search = array_get($queryColumn, 'search.value');
            $fullSearch = array_get($queryColumn, 'search');
            $column = $this->getColumns()->all()->get($index);
            $columnFilter = array_get($this->getColumnFilters()->all(), $index);

            if (! is_null($columnFilter) && ! is_null($column)) {
                $columnFilter->apply($this->repository, $column, $query, $search, $fullSearch);
            }
        }
    }

    /**
     * Convert collection to the datatables structure.
     *
     * @param array|Collection $collection
     * @param int $totalCount
     * @param int $filteredCount
     *
     * @return array
     */
    protected function prepareDatatablesStructure(Collection $collection, $totalCount, $filteredCount)
    {
        $columns = $this->getColumns();

        $result = [];
        $result['draw'] = Request::input('draw', 0);
        $result['recordsTotal'] = $totalCount;
        $result['recordsFiltered'] = $filteredCount;
        $result['data'] = [];

        foreach ($collection as $instance) {
            $_row = [];

            foreach ($columns->all() as $column) {
                $column->setModel($instance);

                if ($column instanceof Control) {
                    $column->initialize();
                }

                $_row[] = (string) $column;
            }

            $result['data'][] = $_row;
        }

        return $result;
    }
}


1			<?php
2
3			namespace SleepingOwl\Admin\Display;
4
5			use Illuminate\Routing\Router;
6			use Request;
7			use Route;
8			use Illuminate\Support\Collection;
9			use Illuminate\Database\Eloquent\Builder;
10			use SleepingOwl\Admin\Contracts\ModelConfigurationInterface;
11			use SleepingOwl\Admin\Display\Column\Email;
12			use SleepingOwl\Admin\Display\Column\Link;
13			use SleepingOwl\Admin\Display\Column\Text;
14			use SleepingOwl\Admin\Display\Column\Custom;
15			use SleepingOwl\Admin\Display\Column\NamedColumn;
16			use SleepingOwl\Admin\Display\Column\Control;
17			use SleepingOwl\Admin\Contracts\WithRoutesInterface;
18
19			class DisplayDatatablesAsync extends DisplayDatatables implements WithRoutesInterface
20			{
21			/**
22			* Register display routes.
23			*
24			* @param Router $router
25			*/
26			public static function registerRoutes(Router $router)
27			{
28			$router->get('{adminModel}/async/{adminDisplayName?}', ['as' => 'admin.model.async',
29			function (ModelConfigurationInterface $model, $name = null) {
30			$display = $model->fireDisplay();
31			if ($display instanceof DisplayTabbed) {
32			$display = static::findDatatablesAsyncByName($display, $name);
33			}
34
35			if ($display instanceof DisplayDatatablesAsync) {
36			return $display->renderAsync();
37			}
38
39			abort(404);
40			},
41			]);
42			}
43
44			/**
45			* Find DisplayDatatablesAsync in tabbed display by name.
46			*
47			* @param DisplayTabbed $display
48			* @param string\|null $name
49			*
50			* @return DisplayDatatablesAsync\|null
51			*/
52			protected static function findDatatablesAsyncByName(DisplayTabbed $display, $name)
53			{
54			$tabs = $display->getTabs();
55			foreach ($tabs as $tab) {
56			$content = $tab->getContent();
57			if ($content instanceof self && $content->getName() === $name) {
58			return $content;
59			}
60			}
61			}
62
63			/**
64			* @var string
65			*/
66			protected $name;
67
68			/**
69			* @param string\|null $name
70			*/
71			protected $distinct;
72
73			/**
74			* @var array
75			*/
76			protected $searchableColumns = [
77			Text::class,
78			Link::class,
79			Email::class,
80			];
81
82			/**
83			* DisplayDatatablesAsync constructor.
84			*
85			* @param string\|null $name
86			* @param string\|null $distinct
87			*/
88			public function __construct($name = null, $distinct = null)
89			{
90			parent::__construct();
91
92			$this->setName($name);
93			$this->setDistinct($distinct);
94
95			$this->getColumns()->setView('display.extensions.columns_async');
96			}
97
98			/**
99			* Initialize display.
100			*/
101			public function initialize()
102			{
103			parent::initialize();
104
105			$attributes = Request::all();
106			array_unshift($attributes, $this->getName());
107			array_unshift($attributes, $this->getModelConfiguration()->getAlias());
108
109			$this->setHtmlAttribute('data-url', route('admin.model.async', $attributes));
110			}
111
112			/**
113			* @return string
114			*/
115			public function getName()
116			{
117			return $this->name;
118			}
119
120			/**
121			* @param string $name
122			*
123			* @return $this
124			*/
125			public function setName($name)
126			{
127			$this->name = $name;
128
129			return $this;
130			}
131
132			/**
133			* @return mixed
134			*/
135			public function getDistinct()
136			{
137			return $this->distinct;
138			}
139
140			/**
141			* @param mixed $distinct
142			*
143			* @return $this
144			*/
145			public function setDistinct($distinct)
146			{
147			$this->distinct = $distinct;
148
149			return $this;
150			}
151
152			/**
153			* Render async request.
154			* @return array
155			*/
156			public function renderAsync()
157			{
158			$query = $this->getRepository()->getQuery();
159			$totalCount = $query->count();
160			$filteredCount = 0;
161
162			if (! is_null($this->distinct)) {
163			$filteredCount = $query->distinct()->count($this->getDistinct());
164			}
165
166			$this->modifyQuery($query);
167			$this->applySearch($query);
168			$this->applyColumnSearch($query);
169
170			if (is_null($this->distinct)) {
171			$filteredCount = $query->count();
172			}
173
174			$this->applyOrders($query);
175			$this->applyOffset($query);
176			$collection = $query->get();
177
178			return $this->prepareDatatablesStructure($collection, $totalCount, $filteredCount);
			0 ignored issues – show Bug introduced 2016-08-16 07:35 UTC by Report Bug Copy Issue Report It seems like `$collection` defined by `$query->get()` on line `176` can also be of type `array<integer,object<Ill...base\Eloquent\Builder>>`; however, `SleepingOwl\Admin\Displa...reDatatablesStructure()` does only seem to accept `object<Illuminate\Support\Collection>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
179			}
180
181			/**
182			* Apply offset and limit to the query.
183			*
184			* @param $query
185			*/
186			protected function applyOffset($query)
187			{
188			$offset = Request::input('start', 0);
189			$limit = Request::input('length', 10);
190
191			if ($limit == -1) {
192			return;
193			}
194
195			$query->offset($offset)->limit($limit);
196			}
197
198			/**
199			* Apply orders to the query.
200			*
201			* @param $query
202			*/
203			protected function applyOrders($query)
204			{
205			$orders = Request::input('order', []);
206
207			foreach ($orders as $order) {
			0 ignored issues – show Bug introduced 2016-07-15 12:17 UTC by Report Bug Copy Issue Report The expression `$orders` of type `string\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
208			$columnIndex = $order['column'];
209			$orderDirection = $order['dir'];
210			$column = $this->getColumns()->all()->get($columnIndex);
211
212			if ($column instanceof NamedColumn && $column->isOrderable()) {
213			$name = $column->getName();
214			$query->orderBy($name, $orderDirection);
215			} elseif ($column instanceof Custom && $column->getOrderField()) {
216			$name = $column->getOrderField();
217			$query->orderBy($name, $orderDirection);
218			}
219			}
220			}
221
222			/**
223			* Apply search to the query.
224			*
225			* @param Builder $query
226			*/
227			protected function applySearch(Builder $query)
228			{
229			$search = Request::input('search.value');
230			if (empty($search)) {
231			return;
232			}
233
234			$query->where(function ($query) use ($search) {
235			$columns = $this->getColumns()->all();
236			foreach ($columns as $column) {
237			if (in_array(get_class($column), $this->searchableColumns)) {
238			$name = $column->getName();
239			if ($this->repository->hasColumn($name)) {
240			$query->orWhere($name, 'like', '%'.$search.'%');
241			}
242			}
243			}
244			});
245			}
246
247			/**
248			* @param Builder $query
249			*/
250			protected function applyColumnSearch(Builder $query)
251			{
252			$queryColumns = Request::input('columns', []);
253
254			foreach ($queryColumns as $index => $queryColumn) {
			0 ignored issues – show Bug introduced 2016-07-15 12:17 UTC by Report Bug Copy Issue Report The expression `$queryColumns` of type `string\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
255			$search = array_get($queryColumn, 'search.value');
256			$fullSearch = array_get($queryColumn, 'search');
257			$column = $this->getColumns()->all()->get($index);
258			$columnFilter = array_get($this->getColumnFilters()->all(), $index);
259
260			if (! is_null($columnFilter) && ! is_null($column)) {
261			$columnFilter->apply($this->repository, $column, $query, $search, $fullSearch);
262			}
263			}
264			}
265
266			/**
267			* Convert collection to the datatables structure.
268			*
269			* @param array\|Collection $collection
270			* @param int $totalCount
271			* @param int $filteredCount
272			*
273			* @return array
274			*/
275			protected function prepareDatatablesStructure(Collection $collection, $totalCount, $filteredCount)
276			{
277			$columns = $this->getColumns();
278
279			$result = [];
280			$result['draw'] = Request::input('draw', 0);
281			$result['recordsTotal'] = $totalCount;
282			$result['recordsFiltered'] = $filteredCount;
283			$result['data'] = [];
284
285			foreach ($collection as $instance) {
286			$_row = [];
287
288			foreach ($columns->all() as $column) {
289			$column->setModel($instance);
290
291			if ($column instanceof Control) {
292			$column->initialize();
293			}
294
295			$_row[] = (string) $column;
296			}
297
298			$result['data'][] = $_row;
299			}
300
301			return $result;
302			}
303			}
304

LaravelRUS / SleepingOwlAdmin

GitHub Access Token became invalid

Push — master ( 55fdb7...374a13 )

DisplayDatatablesAsync::applyOrders() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like