QueryBuilderProvider::getTotalNumberOfRows() - Code Metrics - Inspection of "Merge pull request #31 from timgws/coverage" - OpenSkill/Datatable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 87f182...f4f699 )

by Tim

created 2016-03-03 01:31 UTC

QueryBuilderProvider::getTotalNumberOfRows() A

↳ Parent: QueryBuilderProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

namespace OpenSkill\Datatable\Providers;

use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\Builder as QueryBuilder;
use OpenSkill\Datatable\Columns\ColumnConfiguration;
use OpenSkill\Datatable\Columns\ColumnOrder;
use OpenSkill\Datatable\Columns\ColumnSearch;
use OpenSkill\Datatable\Columns\Searchable\DefaultSearchable;
use OpenSkill\Datatable\Data\ResponseData;
use OpenSkill\Datatable\DatatableException;
use OpenSkill\Datatable\Queries\QueryConfiguration;

/**
 * Class CollectionProvider
 * @package OpenSkill\Datatable\Providers
 *
 * Provider that is able to provide data based on a initial passed collection.
 */
class QueryBuilderProvider implements Provider
{
    /**
     * @var QueryBuilder The original query, as passed to us.
     */
    private $originalQuery;

    /**
     * @var QueryBuilder The query, before limits are applied
     */
    private $queryBeforeLimits;

    /**
     * @var QueryBuilder The underlying query
     */
    private $query;

    /**
     * @var QueryConfiguration
     */
    private $queryConfiguration;

    /**
     * @var callable the default global function to check if a row should be included
     */
    private $defaultGlobalSearchFunction;


    /**
     * @var callable the default global order function
     */
    private $defaultGlobalOrderFunction;


    /**
     * @var array an array of callables with local search functions to check if the row should be included
     */
    private $columnSearchFunction = [];


    /**
     * @var array an array that will hold the search functions for each column
     */
    private $columnConfiguration = [];

    /**
     * CollectionProvider constructor.
     * @param QueryBuilder $query The query to base the built query on
     */
    public function __construct(QueryBuilder $query)
    {
        $this->originalQuery = $query;
        $this->query = clone $query;
    }

    /**
     * Here the DTQueryConfiguration is passed to prepare the provider for the processing of the request.
     * This will only be called when the DTProvider needs to handle the request.
     * It will never be called when the DTProvider does not need to handle the request.
     *
     * @param QueryConfiguration $queryConfiguration
     * @param ColumnConfiguration[] $columnConfiguration
     * @return mixed
     */
    public function prepareForProcessing(QueryConfiguration $queryConfiguration, array $columnConfiguration)
    {
        $this->queryConfiguration = $queryConfiguration;
        $this->columnConfiguration = $columnConfiguration;

        // compile the query first
        $this->compileQuery();

        // sort
        $this->sortQuery();
    }

    /**
     * This method should process all configurations and prepare the underlying data for the view. It will arrange the
     * data and provide the results in a DTData object.
     * It will be called after {@link #prepareForProcessing} has been called and needs to return the processed data in
     * a DTData object so the Composer can further handle the data.
     *
     * @return ResponseData The processed data
     *
     */
    public function process()
    {
        // check if the query configuration is set
        if (is_null($this->queryConfiguration) || empty($this->columnConfiguration)) {
            throw new \InvalidArgumentException("Provider was not configured. Did you call prepareForProcessing first?");
        }

        // limit
        $this->queryBeforeLimits = clone $this->query;
        $this->limitQuery();

        // # of items in filtered & ordered data set
        $dataCount = $this->queryBeforeLimits->count();

        // the data for the response
        $columns = $this->compileColumnNames();
        $response = new Collection($this->query->get($columns));

        // slice the result into the right size
        return new ResponseData(
            $response,
            $this->getTotalNumberOfRows(),
            $dataCount
        );
    }

    /**
     * Get the total number of rows for the original query.
     * @return int
     */
    private function getTotalNumberOfRows()
    {
        return $this->originalQuery->count();
    }

    /**
     * Will compile the collection into the final collection where operations like search and order can be applied.
     *
     * @return QueryBuilder
     * @throws DatatableException
     */
    private function compileQuery()
    {
        if ($this->queryConfiguration->isGlobalSearch()) {
            $this->compileGlobalQuery();
        } elseif ($this->queryConfiguration->isColumnSearch()) {
            $this->compileColumnQuery();
        }
    }

    /**
     * When a global (single) search has been done against data in the datatable.
     *
     * @return QueryBuilder
     * @throws DatatableException
     */
    private function compileGlobalQuery()
    {
        foreach ($this->columnConfiguration as $i => $col) {
            $this->createQueryForColumn($col, $this->queryConfiguration->searchValue());
        }
    }

    /**
     * When a global query is being performed (ie, a query against a single column)
     *
     * @return QueryBuilder
     * @throws DatatableException
     */
    private function compileColumnQuery()
    {
        $searchColumns = $this->queryConfiguration->searchColumns();

        foreach ($searchColumns as $i => $col) {
            $column = $this->getColumnFromName($col->columnName());

            if (!isset($column))
                continue;

            $this->createQueryForColumn($column, $col->searchValue());
        }
    }

    /**
     * Create the query w/ QueryBuilder
     * @param ColumnConfiguration $column
     * @param $searchValue
     * @return QueryBuilder
     * @throws DatatableException
     */
    private function createQueryForColumn(ColumnConfiguration $column, $searchValue)
    {
        $searchType = $column->getSearch();

        if ($searchType == DefaultSearchable::NONE()) {
            // Don't do anything, this is not a searchable field
            return $this->query;
        } elseif ($searchType == DefaultSearchable::NORMAL()) {
            $this->query->orWhere($column->getName(), 'LIKE', '%' . $searchValue . '%');
        } elseif ($searchType == DefaultSearchable::REGEX()) {
            $this->query->orWhere($column->getName(), 'REGEXP', $searchValue);
        } else {
            throw new DatatableException('An unsupported DefaultSearchable was provided.');
        }

        return $this->query;
    }

    /**
     * Get the requested column configuration from the name of a column
     * @param string $name
     * @return ColumnConfiguration
     * @throws DatatableException when a column is not found
     */
    private function getColumnFromName($name)
    {
        foreach ($this->columnConfiguration as $i => $col) {
            if ($col->getName() == $name) {
                return $col;
            }
        }

        // This exception should never happen. If it does, something is
        // wrong w/ the relationship between searchable columns and the
        // configuration.
        throw new DatatableException("A requested column was not found in the columnConfiguration.");
    }

    /**
     * Get a list of all the column names for the SELECT query.
     */
    private function compileColumnNames()
    {
        $columns = [];
        foreach($this->columnConfiguration as $column) {
            $columns[] = $column->getName();
        }

        return $columns;
    }

    /**
     * Will sort the query based on the given datatable query configuration.
     */
    private function sortQuery()
    {
        if ($this->queryConfiguration->hasOrderColumn()) {
            $orderColumns = $this->queryConfiguration->orderColumns();

            foreach($orderColumns as $order) {
                $this->query->orderBy($order->columnName(), $order->isDescending() ? 'desc' : 'asc');
            }
        }
    }

    /**
     * Will limit a query based on the start and length given
     */
    private function limitQuery()
    {
        $this->query->skip($this->queryConfiguration->start());
        $this->query->limit($this->queryConfiguration->length());
    }
}

1			<?php
2
3			namespace OpenSkill\Datatable\Providers;
4
5			use Illuminate\Support\Collection;
6			use Illuminate\Database\Eloquent\Builder;
7			use Illuminate\Database\Query\Builder as QueryBuilder;
8			use OpenSkill\Datatable\Columns\ColumnConfiguration;
9			use OpenSkill\Datatable\Columns\ColumnOrder;
10			use OpenSkill\Datatable\Columns\ColumnSearch;
11			use OpenSkill\Datatable\Columns\Searchable\DefaultSearchable;
12			use OpenSkill\Datatable\Data\ResponseData;
13			use OpenSkill\Datatable\DatatableException;
14			use OpenSkill\Datatable\Queries\QueryConfiguration;
15
16			/**
17			* Class CollectionProvider
18			* @package OpenSkill\Datatable\Providers
19			*
20			* Provider that is able to provide data based on a initial passed collection.
21			*/
22			class QueryBuilderProvider implements Provider
23			{
24			/**
25			* @var QueryBuilder The original query, as passed to us.
26			*/
27			private $originalQuery;
28
29			/**
30			* @var QueryBuilder The query, before limits are applied
31			*/
32			private $queryBeforeLimits;
33
34			/**
35			* @var QueryBuilder The underlying query
36			*/
37			private $query;
38
39			/**
40			* @var QueryConfiguration
41			*/
42			private $queryConfiguration;
43
44			/**
45			* @var callable the default global function to check if a row should be included
46			*/
47			private $defaultGlobalSearchFunction;
			0 ignored issues – show Unused Code introduced 2016-03-02 06:38 UTC by Report Bug Copy Issue Report The property `$defaultGlobalSearchFunction` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
48
49			/**
50			* @var callable the default global order function
51			*/
52			private $defaultGlobalOrderFunction;
			0 ignored issues – show Unused Code introduced 2016-03-02 06:38 UTC by Report Bug Copy Issue Report The property `$defaultGlobalOrderFunction` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
53
54			/**
55			* @var array an array of callables with local search functions to check if the row should be included
56			*/
57			private $columnSearchFunction = [];
			0 ignored issues – show Unused Code introduced 2016-03-02 07:23 UTC by Report Bug Copy Issue Report The property `$columnSearchFunction` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
58
59			/**
60			* @var array an array that will hold the search functions for each column
61			*/
62			private $columnConfiguration = [];
63
64			/**
65			* CollectionProvider constructor.
66			* @param QueryBuilder $query The query to base the built query on
67			*/
68			public function __construct(QueryBuilder $query)
69			{
70			$this->originalQuery = $query;
71			$this->query = clone $query;
72			}
73
74			/**
75			* Here the DTQueryConfiguration is passed to prepare the provider for the processing of the request.
76			* This will only be called when the DTProvider needs to handle the request.
77			* It will never be called when the DTProvider does not need to handle the request.
78			*
79			* @param QueryConfiguration $queryConfiguration
80			* @param ColumnConfiguration[] $columnConfiguration
81			* @return mixed
82			*/
83			public function prepareForProcessing(QueryConfiguration $queryConfiguration, array $columnConfiguration)
84			{
85			$this->queryConfiguration = $queryConfiguration;
86			$this->columnConfiguration = $columnConfiguration;
87
88			// compile the query first
89			$this->compileQuery();
90
91			// sort
92			$this->sortQuery();
93			}
94
95			/**
96			* This method should process all configurations and prepare the underlying data for the view. It will arrange the
97			* data and provide the results in a DTData object.
98			* It will be called after {@link #prepareForProcessing} has been called and needs to return the processed data in
99			* a DTData object so the Composer can further handle the data.
100			*
101			* @return ResponseData The processed data
102			*
103			*/
104			public function process()
105			{
106			// check if the query configuration is set
107			if (is_null($this->queryConfiguration) \|\| empty($this->columnConfiguration)) {
108			throw new \InvalidArgumentException("Provider was not configured. Did you call prepareForProcessing first?");
109			}
110
111			// limit
112			$this->queryBeforeLimits = clone $this->query;
113			$this->limitQuery();
114
115			// # of items in filtered & ordered data set
116			$dataCount = $this->queryBeforeLimits->count();
117
118			// the data for the response
119			$columns = $this->compileColumnNames();
120			$response = new Collection($this->query->get($columns));
121
122			// slice the result into the right size
123			return new ResponseData(
124			$response,
125			$this->getTotalNumberOfRows(),
126			$dataCount
127			);
128			}
129
130			/**
131			* Get the total number of rows for the original query.
132			* @return int
133			*/
134			private function getTotalNumberOfRows()
135			{
136			return $this->originalQuery->count();
137			}
138
139			/**
140			* Will compile the collection into the final collection where operations like search and order can be applied.
141			*
142			* @return QueryBuilder
143			* @throws DatatableException
144			*/
145			private function compileQuery()
146			{
147			if ($this->queryConfiguration->isGlobalSearch()) {
148			$this->compileGlobalQuery();
149			} elseif ($this->queryConfiguration->isColumnSearch()) {
150			$this->compileColumnQuery();
151			}
152			}
153
154			/**
155			* When a global (single) search has been done against data in the datatable.
156			*
157			* @return QueryBuilder
158			* @throws DatatableException
159			*/
160			private function compileGlobalQuery()
161			{
162			foreach ($this->columnConfiguration as $i => $col) {
163			$this->createQueryForColumn($col, $this->queryConfiguration->searchValue());
164			}
165			}
166
167			/**
168			* When a global query is being performed (ie, a query against a single column)
169			*
170			* @return QueryBuilder
171			* @throws DatatableException
172			*/
173			private function compileColumnQuery()
174			{
175			$searchColumns = $this->queryConfiguration->searchColumns();
176
177			foreach ($searchColumns as $i => $col) {
178			$column = $this->getColumnFromName($col->columnName());
179
180			if (!isset($column))
181			continue;
182
183			$this->createQueryForColumn($column, $col->searchValue());
184			}
185			}
186
187			/**
188			* Create the query w/ QueryBuilder
189			* @param ColumnConfiguration $column
190			* @param $searchValue
191			* @return QueryBuilder
192			* @throws DatatableException
193			*/
194			private function createQueryForColumn(ColumnConfiguration $column, $searchValue)
195			{
196			$searchType = $column->getSearch();
197
198			if ($searchType == DefaultSearchable::NONE()) {
199			// Don't do anything, this is not a searchable field
200			return $this->query;
201			} elseif ($searchType == DefaultSearchable::NORMAL()) {
202			$this->query->orWhere($column->getName(), 'LIKE', '%' . $searchValue . '%');
203			} elseif ($searchType == DefaultSearchable::REGEX()) {
204			$this->query->orWhere($column->getName(), 'REGEXP', $searchValue);
205			} else {
206			throw new DatatableException('An unsupported DefaultSearchable was provided.');
207			}
208
209			return $this->query;
210			}
211
212			/**
213			* Get the requested column configuration from the name of a column
214			* @param string $name
215			* @return ColumnConfiguration
216			* @throws DatatableException when a column is not found
217			*/
218			private function getColumnFromName($name)
219			{
220			foreach ($this->columnConfiguration as $i => $col) {
221			if ($col->getName() == $name) {
222			return $col;
223			}
224			}
225
226			// This exception should never happen. If it does, something is
227			// wrong w/ the relationship between searchable columns and the
228			// configuration.
229			throw new DatatableException("A requested column was not found in the columnConfiguration.");
230			}
231
232			/**
233			* Get a list of all the column names for the SELECT query.
234			*/
235			private function compileColumnNames()
236			{
237			$columns = [];
238			foreach($this->columnConfiguration as $column) {
239			$columns[] = $column->getName();
240			}
241
242			return $columns;
243			}
244
245			/**
246			* Will sort the query based on the given datatable query configuration.
247			*/
248			private function sortQuery()
249			{
250			if ($this->queryConfiguration->hasOrderColumn()) {
251			$orderColumns = $this->queryConfiguration->orderColumns();
252
253			foreach($orderColumns as $order) {
254			$this->query->orderBy($order->columnName(), $order->isDescending() ? 'desc' : 'asc');
255			}
256			}
257			}
258
259			/**
260			* Will limit a query based on the start and length given
261			*/
262			private function limitQuery()
263			{
264			$this->query->skip($this->queryConfiguration->start());
265			$this->query->limit($this->queryConfiguration->length());
266			}
267			}

OpenSkill / Datatable

Push — master ( 87f182...f4f699 )

QueryBuilderProvider::getTotalNumberOfRows() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like