DataTablesFactory::parseColumns() - Code Metrics - Inspection of "Add CHANGELOG" - webeweb/jquery-datatables-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5ad8a9...5e63c7 )

by WEBEWEB

created 2018-11-10 10:39 UTC

DataTablesFactory::parseColumns() A

↳ Parent: DataTablesFactory

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	23
rs	9.552
c	0
b	0
f	0
cc	3
nc	3
nop	2

<?php

/**
 * This file is part of the jquery-datatables-bundle package.
 *
 * (c) 2018 WEBEWEB
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace WBW\Bundle\JQuery\DataTablesBundle\Factory;

use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesColumn;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesColumnInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesEnumerator;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOptions;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOptionsInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOrder;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOrderInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesRequest;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesRequestInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesResponse;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesResponseInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesSearch;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesSearchInterface;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesWrapper;
use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesWrapperInterface;
use WBW\Bundle\JQuery\DataTablesBundle\Provider\DataTablesProviderInterface;
use WBW\Library\Core\Argument\BooleanHelper;
use WBW\Library\Core\Network\HTTP\HTTPInterface;

/**
 * DataTables factory.
 *
 * @author webeweb <https://github.com/webeweb/>
 * @package WBW\Bundle\JQuery\DataTablesBundle\Factory
 */
class DataTablesFactory {

    /**
     * Copy a parameter bag.
     *
     * @param ParameterBag $src The source.
     * @param ParameterBag $dst The destination.
     * @return void
     */
    protected static function copyParameterBag(ParameterBag $src, ParameterBag $dst) {
        foreach ($src->keys() as $current) {
            if (true === in_array($current, DataTablesEnumerator::enumParameters())) {
                continue;
            }
            $dst->set($current, $src->get($current));
        }
    }

    /**
     * Determines if a raw column is valid.
     *
     * @param array $rawColumn The raw column.
     * @return bool Returns true in case of success, false otherwise.
     */
    protected static function isValidRawColumn(array $rawColumn) {
        if (false === array_key_exists(DataTablesColumnInterface::DATATABLES_PARAMETER_DATA, $rawColumn)) {
            return false;
        }
        if (false === array_key_exists(DataTablesColumnInterface::DATATABLES_PARAMETER_NAME, $rawColumn)) {
            return false;
        }
        return true;
    }

    /**
     * Determines if a raw order is valid.
     *
     * @param array $rawOrder The raw order.
     * @return bool Returns true in case of success, false otherwise.
     */
    protected static function isValidRawOrder(array $rawOrder) {
        if (false === array_key_exists(DataTablesOrderInterface::DATATABLES_PARAMETER_COLUMN, $rawOrder)) {
            return false;
        }
        if (false === array_key_exists(DataTablesOrderInterface::DATATABLES_PARAMETER_DIR, $rawOrder)) {
            return false;
        }
        return true;
    }

    /**
     * Determines if a raw search is valid.
     *
     * @param array $rawSearch The raw search.
     * @return bool Returns true in case of success, false otherwise.
     */
    protected static function isValidRawSearch(array $rawSearch) {
        if (false === array_key_exists(DataTablesSearchInterface::DATATABLES_PARAMETER_REGEX, $rawSearch)) {
            return false;
        }
        if (false === array_key_exists(DataTablesSearchInterface::DATATABLES_PARAMETER_VALUE, $rawSearch)) {
            return false;
        }
        return true;
    }

    /**
     * Create a new column instance.
     *
     * @param string $data The column data.
     * @param string $name The column name.
     * @param string $cellType The column cell type.
     * @return DataTablesColumnInterface Returns a column.
     */
    public static function newColumn($data, $name, $cellType = DataTablesColumnInterface::DATATABLES_CELL_TYPE_TD) {

        // Initialize a column.
        $dtColumn = new DataTablesColumn();
        $dtColumn->getMapping()->setColumn($data);
        $dtColumn->setCellType($cellType);
        $dtColumn->setData($data);
        $dtColumn->setName($name);
        $dtColumn->setTitle($name);

        // Return the column.
        return $dtColumn;
    }

    /**
     * Create a new options.
     *
     * @return DataTablesOptionsInterface Returns an options.
     */
    public static function newOptions() {
        return new DataTablesOptions();
    }

    /**
     * Create a new response.
     *
     * @param DataTablesWrapperInterface $wrapper The wrapper.
     * @return DataTablesResponseInterface Returns a response.
     */
    protected static function newResponse(DataTablesWrapperInterface $wrapper) {

        // Initialize a response.
        $dtResponse = new DataTablesResponse();
        $dtResponse->setDraw($wrapper->getRequest()->getDraw());
        $dtResponse->setWrapper($wrapper);

        // Return the response.
        return $dtResponse;
    }

    /**
     * Create a new wrapper.
     *
     * @param string $url The URL.
     * @param DataTablesProviderInterface $provider The provider.
     * @return DataTablesWrapperInterface Returns a wrapper.
     */
    public static function newWrapper($url, DataTablesProviderInterface $provider) {

        // Initialize a wrapper.
        $dtWrapper = new DataTablesWrapper();
        $dtWrapper->getMapping()->setPrefix($provider->getPrefix());
        $dtWrapper->setMethod($provider->getMethod());
        $dtWrapper->setProvider($provider);
        $dtWrapper->setUrl($url);

        // Return the wrapper.
        return $dtWrapper;
    }

    /**
     * Parse a raw column.
     *
     * @param array $rawColumn The raw column.
     * @param DataTablesWrapperInterface $wrapper The wrapper.
     * @return DataTablesColumnInterface Returns the column.
     */
    protected static function parseColumn(array $rawColumn, DataTablesWrapperInterface $wrapper) {

        // Determines if the raw column is valid.
        if (false === static::isValidRawColumn($rawColumn)) {
            return null;
        }

        // Get the column.
        $dtColumn = $wrapper->getColumn($rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_DATA]);

        // Check the column.
        if (null === $dtColumn) {
            return null;
        }
        if ($dtColumn->getName() !== $rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_NAME]) {
            return null;
        }
        if (false === $dtColumn->getSearchable()) {
            $dtColumn->setSearch(static::parseSearch([])); // Set a default search.
            return $dtColumn;
        }

        // Set the search.
        $dtColumn->setSearch(static::parseSearch($rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_SEARCH]));

        // Return the column.
        return $dtColumn;
    }

    /**
     * Parse a raw columns.
     *
     * @param array $rawColumns The raw columns.
     * @param DataTablesWrapperInterface $wrapper The wrapper.
     * @return DataTablesColumnInterface[] Returns the columns.
     */
    protected static function parseColumns(array $rawColumns, DataTablesWrapperInterface $wrapper) {

        // Initialize the columns.
        $dtColumns = [];

        // Handle each column.
        foreach ($rawColumns as $current) {

            // Parse the column.
            $dtColumn = static::parseColumn($current, $wrapper);

            // Check the column.
            if (null === $dtColumn) {
                continue;
            }

            // Add the column.
            $dtColumns[] = $dtColumn;
        }

        // Returns the columns.
        return $dtColumns;
    }

    /**
     * Parse a raw order.
     *
     * @param array $rawOrder The raw order.
     * @return DataTablesOrderInterface Returns the order.
     */
    protected static function parseOrder(array $rawOrder) {

        // Initialize an order.
        $dtOrder = new DataTablesOrder();

        // Determines if the raw order is valid.
        if (false === static::isValidRawOrder($rawOrder)) {
            return $dtOrder;
        }

        // Set the order.
        $dtOrder->setColumn(intval($rawOrder[DataTablesOrderInterface::DATATABLES_PARAMETER_COLUMN]));
        $dtOrder->setDir($rawOrder[DataTablesOrderInterface::DATATABLES_PARAMETER_DIR]);

        // Return the order.
        return $dtOrder;
    }

    /**
     * Parse raw orders.
     *
     * @param array $rawOrders The raw orders.
     * @return DataTablesOrderInterface[] Returns the orders.
     */
    protected static function parseOrders(array $rawOrders) {

        // Initialize the orders.
        $dtOrders = [];

        // Handle each raw order.
        foreach ($rawOrders as $current) {
            $dtOrders[] = static::parseOrder($current);
        }

        // Return the orders.
        return $dtOrders;
    }

    /**
     * Parse a request.
     *
     * @param DataTablesWrapperInterface $wrapper The wrapper.
     * @param Request $request The request.
     * @return DataTablesRequestInterface Returns the request.
     */
    protected static function parseRequest(DataTablesWrapperInterface $wrapper, Request $request) {

        // Initialize a request.
        $dtRequest = new DataTablesRequest();

        // Copy the parameter bags.
        static::copyParameterBag($request->query, $dtRequest->getQuery());
        static::copyParameterBag($request->request, $dtRequest->getRequest());

        // Get the parameter bag.
        if (HTTPInterface::HTTP_METHOD_GET === $request->getMethod()) {
            $parameterBag = $request->query;
        } else {
            $parameterBag = $request->request;
        }

        // Get the request parameters.
        $columns = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_COLUMNS) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_COLUMNS) : [];
        $orders  = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_ORDER) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_ORDER) : [];
        $search  = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_SEARCH) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_SEARCH) : [];

        // Set the request.
        $dtRequest->setColumns(static::parseColumns($columns, $wrapper));
        $dtRequest->setDraw($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_DRAW));
        $dtRequest->setLength($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_LENGTH));
        $dtRequest->setOrder(static::parseOrders($orders));
        $dtRequest->setSearch(static::parseSearch($search));
        $dtRequest->setStart($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_START));
        $dtRequest->setWrapper($wrapper);

        // Return the request.
        return $dtRequest;
    }

    /**
     * Parse a raw search.
     *
     * @param array $rawSearch The raw search.
     * @return DataTablesSearchInterface Returns the search.
     */
    protected static function parseSearch(array $rawSearch) {

        // Initialize a search.
        $dtSearch = new DataTablesSearch();

        // Determines if the raw search is valid.
        if (false === static::isValidRawSearch($rawSearch)) {
            return $dtSearch;
        }

        // Set the search.
        $dtSearch->setRegex(BooleanHelper::parseString($rawSearch[DataTablesSearchInterface::DATATABLES_PARAMETER_REGEX]));
        $dtSearch->setValue($rawSearch[DataTablesSearchInterface::DATATABLES_PARAMETER_VALUE]);

        // Return the search.
        return $dtSearch;
    }

    /**
     * Parse a request.
     *
     * @param DataTablesWrapperInterface $wrapper The wrapper.
     * @param Request $request The request.
     * @return void
     */
    public static function parseWrapper(DataTablesWrapperInterface $wrapper, Request $request) {
        $wrapper->setRequest(static::parseRequest($wrapper, $request));
        $wrapper->setResponse(static::newResponse($wrapper));
    }

}


1			<?php
2
3			/**
4			* This file is part of the jquery-datatables-bundle package.
5			*
6			* (c) 2018 WEBEWEB
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace WBW\Bundle\JQuery\DataTablesBundle\Factory;
13
14			use Symfony\Component\HttpFoundation\ParameterBag;
15			use Symfony\Component\HttpFoundation\Request;
16			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesColumn;
17			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesColumnInterface;
18			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesEnumerator;
19			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOptions;
20			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOptionsInterface;
21			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOrder;
22			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesOrderInterface;
23			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesRequest;
24			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesRequestInterface;
25			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesResponse;
26			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesResponseInterface;
27			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesSearch;
28			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesSearchInterface;
29			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesWrapper;
30			use WBW\Bundle\JQuery\DataTablesBundle\API\DataTablesWrapperInterface;
31			use WBW\Bundle\JQuery\DataTablesBundle\Provider\DataTablesProviderInterface;
32			use WBW\Library\Core\Argument\BooleanHelper;
33			use WBW\Library\Core\Network\HTTP\HTTPInterface;
34
35			/**
36			* DataTables factory.
37			*
38			* @author webeweb <https://github.com/webeweb/>
39			* @package WBW\Bundle\JQuery\DataTablesBundle\Factory
40			*/
41			class DataTablesFactory {
42
43			/**
44			* Copy a parameter bag.
45			*
46			* @param ParameterBag $src The source.
47			* @param ParameterBag $dst The destination.
48			* @return void
49			*/
50			protected static function copyParameterBag(ParameterBag $src, ParameterBag $dst) {
51			foreach ($src->keys() as $current) {
52			if (true === in_array($current, DataTablesEnumerator::enumParameters())) {
53			continue;
54			}
55			$dst->set($current, $src->get($current));
56			}
57			}
58
59			/**
60			* Determines if a raw column is valid.
61			*
62			* @param array $rawColumn The raw column.
63			* @return bool Returns true in case of success, false otherwise.
64			*/
65			protected static function isValidRawColumn(array $rawColumn) {
66			if (false === array_key_exists(DataTablesColumnInterface::DATATABLES_PARAMETER_DATA, $rawColumn)) {
67			return false;
68			}
69			if (false === array_key_exists(DataTablesColumnInterface::DATATABLES_PARAMETER_NAME, $rawColumn)) {
70			return false;
71			}
72			return true;
73			}
74
75			/**
76			* Determines if a raw order is valid.
77			*
78			* @param array $rawOrder The raw order.
79			* @return bool Returns true in case of success, false otherwise.
80			*/
81			protected static function isValidRawOrder(array $rawOrder) {
82			if (false === array_key_exists(DataTablesOrderInterface::DATATABLES_PARAMETER_COLUMN, $rawOrder)) {
83			return false;
84			}
85			if (false === array_key_exists(DataTablesOrderInterface::DATATABLES_PARAMETER_DIR, $rawOrder)) {
86			return false;
87			}
88			return true;
89			}
90
91			/**
92			* Determines if a raw search is valid.
93			*
94			* @param array $rawSearch The raw search.
95			* @return bool Returns true in case of success, false otherwise.
96			*/
97			protected static function isValidRawSearch(array $rawSearch) {
98			if (false === array_key_exists(DataTablesSearchInterface::DATATABLES_PARAMETER_REGEX, $rawSearch)) {
99			return false;
100			}
101			if (false === array_key_exists(DataTablesSearchInterface::DATATABLES_PARAMETER_VALUE, $rawSearch)) {
102			return false;
103			}
104			return true;
105			}
106
107			/**
108			* Create a new column instance.
109			*
110			* @param string $data The column data.
111			* @param string $name The column name.
112			* @param string $cellType The column cell type.
113			* @return DataTablesColumnInterface Returns a column.
114			*/
115			public static function newColumn($data, $name, $cellType = DataTablesColumnInterface::DATATABLES_CELL_TYPE_TD) {
116
117			// Initialize a column.
118			$dtColumn = new DataTablesColumn();
119			$dtColumn->getMapping()->setColumn($data);
120			$dtColumn->setCellType($cellType);
121			$dtColumn->setData($data);
122			$dtColumn->setName($name);
123			$dtColumn->setTitle($name);
124
125			// Return the column.
126			return $dtColumn;
127			}
128
129			/**
130			* Create a new options.
131			*
132			* @return DataTablesOptionsInterface Returns an options.
133			*/
134			public static function newOptions() {
135			return new DataTablesOptions();
136			}
137
138			/**
139			* Create a new response.
140			*
141			* @param DataTablesWrapperInterface $wrapper The wrapper.
142			* @return DataTablesResponseInterface Returns a response.
143			*/
144			protected static function newResponse(DataTablesWrapperInterface $wrapper) {
145
146			// Initialize a response.
147			$dtResponse = new DataTablesResponse();
148			$dtResponse->setDraw($wrapper->getRequest()->getDraw());
149			$dtResponse->setWrapper($wrapper);
150
151			// Return the response.
152			return $dtResponse;
153			}
154
155			/**
156			* Create a new wrapper.
157			*
158			* @param string $url The URL.
159			* @param DataTablesProviderInterface $provider The provider.
160			* @return DataTablesWrapperInterface Returns a wrapper.
161			*/
162			public static function newWrapper($url, DataTablesProviderInterface $provider) {
163
164			// Initialize a wrapper.
165			$dtWrapper = new DataTablesWrapper();
166			$dtWrapper->getMapping()->setPrefix($provider->getPrefix());
167			$dtWrapper->setMethod($provider->getMethod());
168			$dtWrapper->setProvider($provider);
169			$dtWrapper->setUrl($url);
170
171			// Return the wrapper.
172			return $dtWrapper;
173			}
174
175			/**
176			* Parse a raw column.
177			*
178			* @param array $rawColumn The raw column.
179			* @param DataTablesWrapperInterface $wrapper The wrapper.
180			* @return DataTablesColumnInterface Returns the column.
181			*/
182			protected static function parseColumn(array $rawColumn, DataTablesWrapperInterface $wrapper) {
183
184			// Determines if the raw column is valid.
185			if (false === static::isValidRawColumn($rawColumn)) {
186			return null;
187			}
188
189			// Get the column.
190			$dtColumn = $wrapper->getColumn($rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_DATA]);
191
192			// Check the column.
193			if (null === $dtColumn) {
194			return null;
195			}
196			if ($dtColumn->getName() !== $rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_NAME]) {
197			return null;
198			}
199			if (false === $dtColumn->getSearchable()) {
200			$dtColumn->setSearch(static::parseSearch([])); // Set a default search.
201			return $dtColumn;
202			}
203
204			// Set the search.
205			$dtColumn->setSearch(static::parseSearch($rawColumn[DataTablesColumnInterface::DATATABLES_PARAMETER_SEARCH]));
206
207			// Return the column.
208			return $dtColumn;
209			}
210
211			/**
212			* Parse a raw columns.
213			*
214			* @param array $rawColumns The raw columns.
215			* @param DataTablesWrapperInterface $wrapper The wrapper.
216			* @return DataTablesColumnInterface[] Returns the columns.
217			*/
218			protected static function parseColumns(array $rawColumns, DataTablesWrapperInterface $wrapper) {
219
220			// Initialize the columns.
221			$dtColumns = [];
222
223			// Handle each column.
224			foreach ($rawColumns as $current) {
225
226			// Parse the column.
227			$dtColumn = static::parseColumn($current, $wrapper);
228
229			// Check the column.
230			if (null === $dtColumn) {
231			continue;
232			}
233
234			// Add the column.
235			$dtColumns[] = $dtColumn;
236			}
237
238			// Returns the columns.
239			return $dtColumns;
240			}
241
242			/**
243			* Parse a raw order.
244			*
245			* @param array $rawOrder The raw order.
246			* @return DataTablesOrderInterface Returns the order.
247			*/
248			protected static function parseOrder(array $rawOrder) {
249
250			// Initialize an order.
251			$dtOrder = new DataTablesOrder();
252
253			// Determines if the raw order is valid.
254			if (false === static::isValidRawOrder($rawOrder)) {
255			return $dtOrder;
256			}
257
258			// Set the order.
259			$dtOrder->setColumn(intval($rawOrder[DataTablesOrderInterface::DATATABLES_PARAMETER_COLUMN]));
260			$dtOrder->setDir($rawOrder[DataTablesOrderInterface::DATATABLES_PARAMETER_DIR]);
261
262			// Return the order.
263			return $dtOrder;
264			}
265
266			/**
267			* Parse raw orders.
268			*
269			* @param array $rawOrders The raw orders.
270			* @return DataTablesOrderInterface[] Returns the orders.
271			*/
272			protected static function parseOrders(array $rawOrders) {
273
274			// Initialize the orders.
275			$dtOrders = [];
276
277			// Handle each raw order.
278			foreach ($rawOrders as $current) {
279			$dtOrders[] = static::parseOrder($current);
280			}
281
282			// Return the orders.
283			return $dtOrders;
284			}
285
286			/**
287			* Parse a request.
288			*
289			* @param DataTablesWrapperInterface $wrapper The wrapper.
290			* @param Request $request The request.
291			* @return DataTablesRequestInterface Returns the request.
292			*/
293			protected static function parseRequest(DataTablesWrapperInterface $wrapper, Request $request) {
294
295			// Initialize a request.
296			$dtRequest = new DataTablesRequest();
297
298			// Copy the parameter bags.
299			static::copyParameterBag($request->query, $dtRequest->getQuery());
300			static::copyParameterBag($request->request, $dtRequest->getRequest());
301
302			// Get the parameter bag.
303			if (HTTPInterface::HTTP_METHOD_GET === $request->getMethod()) {
304			$parameterBag = $request->query;
305			} else {
306			$parameterBag = $request->request;
307			}
308
309			// Get the request parameters.
310			$columns = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_COLUMNS) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_COLUMNS) : [];
311			$orders = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_ORDER) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_ORDER) : [];
312			$search = null !== $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_SEARCH) ? $parameterBag->get(DataTablesRequestInterface::DATATABLES_PARAMETER_SEARCH) : [];
313
314			// Set the request.
315			$dtRequest->setColumns(static::parseColumns($columns, $wrapper));
316			$dtRequest->setDraw($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_DRAW));
317			$dtRequest->setLength($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_LENGTH));
318			$dtRequest->setOrder(static::parseOrders($orders));
319			$dtRequest->setSearch(static::parseSearch($search));
320			$dtRequest->setStart($parameterBag->getInt(DataTablesRequestInterface::DATATABLES_PARAMETER_START));
321			$dtRequest->setWrapper($wrapper);
322
323			// Return the request.
324			return $dtRequest;
325			}
326
327			/**
328			* Parse a raw search.
329			*
330			* @param array $rawSearch The raw search.
331			* @return DataTablesSearchInterface Returns the search.
332			*/
333			protected static function parseSearch(array $rawSearch) {
334
335			// Initialize a search.
336			$dtSearch = new DataTablesSearch();
337
338			// Determines if the raw search is valid.
339			if (false === static::isValidRawSearch($rawSearch)) {
340			return $dtSearch;
341			}
342
343			// Set the search.
344			$dtSearch->setRegex(BooleanHelper::parseString($rawSearch[DataTablesSearchInterface::DATATABLES_PARAMETER_REGEX]));
345			$dtSearch->setValue($rawSearch[DataTablesSearchInterface::DATATABLES_PARAMETER_VALUE]);
346
347			// Return the search.
348			return $dtSearch;
349			}
350
351			/**
352			* Parse a request.
353			*
354			* @param DataTablesWrapperInterface $wrapper The wrapper.
355			* @param Request $request The request.
356			* @return void
357			*/
358			public static function parseWrapper(DataTablesWrapperInterface $wrapper, Request $request) {
359			$wrapper->setRequest(static::parseRequest($wrapper, $request));
360			$wrapper->setResponse(static::newResponse($wrapper));
361			}
362
363			}
364

webeweb / jquery-datatables-bundle

Push — master ( 5ad8a9...5e63c7 )

DataTablesFactory::parseColumns() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like