13569484215

Committed 27 Feb 2025 03:06PM UTC coverage: 56.929% (-35.2%) from 92.083%

Build Type

push

github

Committed by Jordi de la Mano

Commit Message

Fix: tests

Run Details

152 of 267 relevant lines covered (56.93%)

12.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

47.45

/src/DataTables/Builder.php

<?php

namespace Daycry\Doctrine\DataTables;

use Doctrine\DBAL\Query\QueryBuilder;
use Doctrine\ORM\QueryBuilder as ORMQueryBuilder;
use Doctrine\ORM\Tools\Pagination\Paginator;

/**
 * Class Builder
 */
class Builder
{
    /**
     * @var array
     */
    protected $columnAliases = [];

    /**
     * @var string
     */
    protected $columnField = 'data'; // or 'name'

    /**
     * @var string
     */
    protected $indexColumn = '*';

    /**
     * @var bool
     */
    protected $caseInsensitive = false;

    /**
     * @var ORMQueryBuilder|QueryBuilder
     */
    protected $queryBuilder;

    /**
     * @var array
     */
    protected $requestParams;

    /**
     * @var bool
     */
    protected $useOutputWalkers;

    /**
     * @return array
     */
    public function getData()
    {
        $query   = $this->getFilteredQuery();
        $columns = &$this->requestParams['columns'];

        // Order
        if (array_key_exists('order', $this->requestParams)) {
            $order = &$this->requestParams['order'];

            foreach ($order as $sort) {
                $column = &$columns[(int) ($sort['column'])];
                if (array_key_exists($column[$this->columnField], $this->columnAliases)) {
                    $column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];
                }
                $query->addOrderBy($column[$this->columnField], $sort['dir']);
            }
        }

        // Offset
        if (array_key_exists('start', $this->requestParams)) {
            $query->setFirstResult((int) ($this->requestParams['start']));
        }

        // Limit
        if (array_key_exists('length', $this->requestParams)) {
            $length = (int) ($this->requestParams['length']);
            if ($length > 0) {
                $query->setMaxResults($length);
            }
        }

        // Fetch
        $paginator = new Paginator($query, $fetchJoinCollection = true);
        $paginator->setUseOutputWalkers($this->useOutputWalkers);
        $result = [];

        foreach ($paginator as $obj) {
            $result[] = $obj;
        }

        return $result;
    }

    /**
     * @return ORMQueryBuilder|QueryBuilder
     */
    public function getFilteredQuery()
    {
        $query   = clone $this->queryBuilder;
        $columns = &$this->requestParams['columns'];
        $c       = count($columns);

        // Search
        if (array_key_exists('search', $this->requestParams)) {
            if ($value = trim($this->requestParams['search']['value'])) {
                $orX = $query->expr()->orX();

                for ($i = 0; $i < $c; $i++) {
                    $column = &$columns[$i];
                    if ($column['searchable'] === 'true') {
                        if (array_key_exists($column[$this->columnField], $this->columnAliases)) {
                            $column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];
                        }
                        if ($this->caseInsensitive) {
                            $searchColumn = 'lower(' . $column[$this->columnField] . ')';
                            $orX->add($query->expr()->like($searchColumn, 'lower(:search)'));
                        } else {
                            $orX->add($query->expr()->like($column[$this->columnField], ':search'));
                        }
                    }
                }
                if ($orX->count() >= 1) {
                    $query->andWhere($orX)
                        ->setParameter('search', "%{$value}%");
                }
            }
        }

        // Filter
        for ($i = 0; $i < $c; $i++) {
            $column = &$columns[$i];
            $andX   = $query->expr()->andX();
            if (($column['searchable'] === 'true') && ($value = trim($column['search']['value']))) {
                if (array_key_exists($column[$this->columnField], $this->columnAliases)) {
                    $column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];
                }

                // $operator = preg_match('~^\[(?<operator>[=!%<>]+)\].*$~', $value, $matches) ? $matches['operator'] : '=';
                $operator = preg_match('~^\[(?<operator>[INOR=!%<>•]+)\].*$~i', $value, $matches) ? strtoupper($matches['operator']) : '%•';
                $value    = preg_match('~^\[(?<operator>[INOR=!%<>•]+)\](?<term>.*)$~i', $value, $matches) ? $matches['term'] : $value;
                if ($this->caseInsensitive) {
                    $searchColumn = 'lower(' . $column[$this->columnField] . ')';
                    $filter       = "lower(:filter_{$i})";
                } else {
                    $searchColumn = $column[$this->columnField];
                    $filter       = ":filter_{$i}";
                }

                switch ($operator) {
                    case '!=': // Not equals; usage: [!=]search_term
                        $andX->add($query->expr()->neq($searchColumn, $filter));
                        $query->setParameter("filter_{$i}", $value);
                        break;

                    case '%%': // Like; usage: [%%]search_term
                        $andX->add($query->expr()->like($searchColumn, $filter));
                        $value = "%{$value}%";
                        $query->setParameter("filter_{$i}", $value);
                        break;

                    case '<': // Less than; usage: [>]search_term
                        $andX->add($query->expr()->lt($searchColumn, $filter));
                        $query->setParameter("filter_{$i}", $value);
                        break;

                    case '>': // Greater than; usage: [<]search_term
                        $andX->add($query->expr()->gt($searchColumn, $filter));
                        $query->setParameter("filter_{$i}", $value);
                        break;

                    case 'IN': // IN; usage: [IN]search_term,search_term  -> This equals OR with complete terms
                        $value  = explode(',', $value);
                        $params = [];

                        for ($j = 0; $j < count($value); $j++) {
                            $params[] = ":filter_{$i}_{$j}";
                        }
                        $andX->add($query->expr()->in($column[$this->columnField], implode(',', $params)));

                        for ($j = 0; $j < count($value); $j++) {
                            $query->setParameter("filter_{$i}_{$j}", trim($value[$j]));
                        }
                        break;

                    case 'OR': // OR; usage: [IN]search_term,search_term  -> This equals OR with complete terms
                        $value  = explode(',', $value);
                        $params = [];
                        $orX    = $query->expr()->orX();

                        for ($j = 0; $j < count($value); $j++) {
                            $orX->add($query->expr()->like($column[$this->columnField], ":filter_{$i}_{$j}"));
                        }
                        $andX->add($orX);

                        for ($j = 0; $j < count($value); $j++) {
                            $query->setParameter("filter_{$i}_{$j}", '%' . trim($value[$j]) . '%');
                        }
                        break;

                    case '><': // Between than; usage: [><]search_term,search_term
                        $value  = explode(',', $value);
                        $params = [];

                        for ($j = 0; $j < count($value); $j++) {
                            $params[] = ":filter_{$i}_{$j}";
                        }
                        $andX->add($query->expr()->between($column[$this->columnField], trim($params[0]), trim($params[1])));

                        for ($j = 0; $j < count($value); $j++) {
                            $query->setParameter("filter_{$i}_{$j}", $value[$j]);
                        }
                        break;

                    case '=': // Equals; usage: [=]search_term
                        $andX->add($query->expr()->eq($column[$this->columnField], ":filter_{$i}"));
                        $query->setParameter("filter_{$i}", $value);
                        break;

                    case '%': // Like(default); usage: [%]search_term
                    default:
                        $andX->add($query->expr()->like($column[$this->columnField], ":filter_{$i}"));
                        $value = "{$value}%";
                        $query->setParameter("filter_{$i}", $value);
                        break;
                }
            }
            if ($andX->count() >= 1) {
                $query->andWhere($andX);
            }
        }

        // Done
        return $query;
    }

    /**
     * @return int
     */
    public function getRecordsFiltered()
    {
        $query     = $this->getFilteredQuery();
        $paginator = new Paginator($query, $fetchJoinCollection = true);
        $paginator->setUseOutputWalkers($this->useOutputWalkers);

        return $paginator->count();
    }

    /**
     * @return int
     */
    public function getRecordsTotal()
    {
        $query     = clone $this->queryBuilder;
        $paginator = new Paginator($query, $fetchJoinCollection = true);
        $paginator->setUseOutputWalkers($this->useOutputWalkers);

        return $paginator->count();
    }

    /**
     * @return array
     */
    public function getResponse()
    {
        return [
            'data'            => $this->getData(),
            'draw'            => $this->requestParams['draw'],
            'recordsFiltered' => $this->getRecordsFiltered(),
            'recordsTotal'    => $this->getRecordsTotal(),
        ];
    }

    /**
     * @param string $indexColumn
     *
     * @return static
     */
    public function withIndexColumn($indexColumn)
    {
        $this->indexColumn = $indexColumn;

        return $this;
    }

    /**
     * @param string|null $useOutputWalkers
     *                                      return static
     */
    public function setUseOutputWalkers($useOutputWalkers)
    {
        $this->useOutputWalkers = $useOutputWalkers;

        return $this;
    }

    /**
     * @param array $columnAliases
     *
     * @return static
     */
    public function withColumnAliases($columnAliases)
    {
        $this->columnAliases = $columnAliases;

        return $this;
    }

    /**
     * @param bool $caseInsensitive
     *
     * @return static
     */
    public function withCaseInsensitive($caseInsensitive)
    {
        $this->caseInsensitive = $caseInsensitive;

        return $this;
    }

    /**
     * @param string $columnField
     *
     * @return static
     */
    public function withColumnField($columnField)
    {
        $this->columnField = $columnField;

        return $this;
    }

    /**
     * @param ORMQueryBuilder|QueryBuilder $queryBuilder
     *
     * @return static
     */
    public function withQueryBuilder($queryBuilder)
    {
        $this->queryBuilder = $queryBuilder;

        return $this;
    }

    /**
     * @param array $requestParams
     *
     * @return static
     */
    public function withRequestParams($requestParams)
    {
        $this->requestParams = $requestParams;

        return $this;
    }
}

1	<?php
2
3	namespace Daycry\Doctrine\DataTables;
4
5	use Doctrine\DBAL\Query\QueryBuilder;
6	use Doctrine\ORM\QueryBuilder as ORMQueryBuilder;
7	use Doctrine\ORM\Tools\Pagination\Paginator;
8
9	/**
10	* Class Builder
11	*/
12	class Builder
13	{
14	/**
15	* @var array
16	*/
17	protected $columnAliases = [];
18
19	/**
20	* @var string
21	*/
22	protected $columnField = 'data'; // or 'name'
23
24	/**
25	* @var string
26	*/
27	protected $indexColumn = '*';
28
29	/**
30	* @var bool
31	*/
32	protected $caseInsensitive = false;
33
34	/**
35	* @var ORMQueryBuilder\|QueryBuilder
36	*/
37	protected $queryBuilder;
38
39	/**
40	* @var array
41	*/
42	protected $requestParams;
43
44	/**
45	* @var bool
46	*/
47	protected $useOutputWalkers;
48
49	/**
50	* @return array
51	*/
52	public function getData()
53	{
54	$query = $this->getFilteredQuery();	20✔
55	$columns = &$this->requestParams['columns'];	20✔
56
57	// Order
58	if (array_key_exists('order', $this->requestParams)) {	20✔
59	$order = &$this->requestParams['order'];	20✔
60
61	foreach ($order as $sort) {	20✔
62	$column = &$columns[(int) ($sort['column'])];	20✔
63	if (array_key_exists($column[$this->columnField], $this->columnAliases)) {	20✔
64	$column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];	20✔
65	}
66	$query->addOrderBy($column[$this->columnField], $sort['dir']);	20✔
67	}
68	}
69
70	// Offset
71	if (array_key_exists('start', $this->requestParams)) {	20✔
72	$query->setFirstResult((int) ($this->requestParams['start']));	20✔
73	}
74
75	// Limit
76	if (array_key_exists('length', $this->requestParams)) {	20✔
77	$length = (int) ($this->requestParams['length']);	20✔
78	if ($length > 0) {	20✔
79	$query->setMaxResults($length);	20✔
80	}
81	}
82
83	// Fetch
84	$paginator = new Paginator($query, $fetchJoinCollection = true);	20✔
85	$paginator->setUseOutputWalkers($this->useOutputWalkers);	20✔
86	$result = [];	20✔
87
88	foreach ($paginator as $obj) {	20✔
89	$result[] = $obj;	20✔
90	}
91
92	return $result;	20✔
93	}
94
95	/**
96	* @return ORMQueryBuilder\|QueryBuilder
97	*/
98	public function getFilteredQuery()
99	{
100	$query = clone $this->queryBuilder;	20✔
101	$columns = &$this->requestParams['columns'];	20✔
102	$c = count($columns);	20✔
103
104	// Search
105	if (array_key_exists('search', $this->requestParams)) {	20✔
106	if ($value = trim($this->requestParams['search']['value'])) {	20✔
107	$orX = $query->expr()->orX();	2✔
108
109	for ($i = 0; $i < $c; $i++) {	2✔
110	$column = &$columns[$i];	2✔
111	if ($column['searchable'] === 'true') {	2✔
112	if (array_key_exists($column[$this->columnField], $this->columnAliases)) {	×
113	$column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];	×
114	}
115	if ($this->caseInsensitive) {	×
116	$searchColumn = 'lower(' . $column[$this->columnField] . ')';	×
117	$orX->add($query->expr()->like($searchColumn, 'lower(:search)'));	×
118	} else {
119	$orX->add($query->expr()->like($column[$this->columnField], ':search'));	×
120	}
121	}
122	}
123	if ($orX->count() >= 1) {	2✔
124	$query->andWhere($orX)	×
125	->setParameter('search', "%{$value}%");	×
126	}
127	}
128	}
129
130	// Filter
131	for ($i = 0; $i < $c; $i++) {	20✔
132	$column = &$columns[$i];	20✔
133	$andX = $query->expr()->andX();	20✔
134	if (($column['searchable'] === 'true') && ($value = trim($column['search']['value']))) {	20✔
135	if (array_key_exists($column[$this->columnField], $this->columnAliases)) {	×
136	$column[$this->columnField] = $this->columnAliases[$column[$this->columnField]];	×
137	}
138
139	// $operator = preg_match('~^\[(?<operator>[=!%<>]+)\].*$~', $value, $matches) ? $matches['operator'] : '=';
140	$operator = preg_match('~^\[(?<operator>[INOR=!%<>•]+)\].*$~i', $value, $matches) ? strtoupper($matches['operator']) : '%•';	×
141	$value = preg_match('~^\[(?<operator>[INOR=!%<>•]+)\](?<term>.*)$~i', $value, $matches) ? $matches['term'] : $value;	×
142	if ($this->caseInsensitive) {	×
143	$searchColumn = 'lower(' . $column[$this->columnField] . ')';	×
144	$filter = "lower(:filter_{$i})";	×
145	} else {
146	$searchColumn = $column[$this->columnField];	×
147	$filter = ":filter_{$i}";	×
148	}
149
150	switch ($operator) {
151	case '!=': // Not equals; usage: [!=]search_term	×
152	$andX->add($query->expr()->neq($searchColumn, $filter));	×
153	$query->setParameter("filter_{$i}", $value);	×
154	break;	×
155
156	case '%%': // Like; usage: [%%]search_term	×
157	$andX->add($query->expr()->like($searchColumn, $filter));	×
158	$value = "%{$value}%";	×
159	$query->setParameter("filter_{$i}", $value);	×
160	break;	×
161
162	case '<': // Less than; usage: [>]search_term	×
163	$andX->add($query->expr()->lt($searchColumn, $filter));	×
164	$query->setParameter("filter_{$i}", $value);	×
165	break;	×
166
167	case '>': // Greater than; usage: [<]search_term	×
168	$andX->add($query->expr()->gt($searchColumn, $filter));	×
169	$query->setParameter("filter_{$i}", $value);	×
170	break;	×
171
172	case 'IN': // IN; usage: [IN]search_term,search_term -> This equals OR with complete terms	×
173	$value = explode(',', $value);	×
174	$params = [];	×
175
176	for ($j = 0; $j < count($value); $j++) {	×
177	$params[] = ":filter_{$i}_{$j}";	×
178	}
179	$andX->add($query->expr()->in($column[$this->columnField], implode(',', $params)));	×
180
181	for ($j = 0; $j < count($value); $j++) {	×
182	$query->setParameter("filter_{$i}_{$j}", trim($value[$j]));	×
183	}
184	break;	×
185
186	case 'OR': // OR; usage: [IN]search_term,search_term -> This equals OR with complete terms	×
187	$value = explode(',', $value);	×
188	$params = [];	×
189	$orX = $query->expr()->orX();	×
190
191	for ($j = 0; $j < count($value); $j++) {	×
192	$orX->add($query->expr()->like($column[$this->columnField], ":filter_{$i}_{$j}"));	×
193	}
194	$andX->add($orX);	×
195
196	for ($j = 0; $j < count($value); $j++) {	×
197	$query->setParameter("filter_{$i}_{$j}", '%' . trim($value[$j]) . '%');	×
198	}
199	break;	×
200
201	case '><': // Between than; usage: [><]search_term,search_term	×
202	$value = explode(',', $value);	×
203	$params = [];	×
204
205	for ($j = 0; $j < count($value); $j++) {	×
206	$params[] = ":filter_{$i}_{$j}";	×
207	}
208	$andX->add($query->expr()->between($column[$this->columnField], trim($params[0]), trim($params[1])));	×
209
210	for ($j = 0; $j < count($value); $j++) {	×
211	$query->setParameter("filter_{$i}_{$j}", $value[$j]);	×
212	}
213	break;	×
214
215	case '=': // Equals; usage: [=]search_term	×
216	$andX->add($query->expr()->eq($column[$this->columnField], ":filter_{$i}"));	×
217	$query->setParameter("filter_{$i}", $value);	×
218	break;	×
219
220	case '%': // Like(default); usage: [%]search_term	×
221	default:
222	$andX->add($query->expr()->like($column[$this->columnField], ":filter_{$i}"));	×
223	$value = "{$value}%";	×
224	$query->setParameter("filter_{$i}", $value);	×
225	break;	×
226	}
227	}
228	if ($andX->count() >= 1) {	20✔
229	$query->andWhere($andX);	×
230	}
231	}
232
233	// Done
234	return $query;	20✔
235	}
236
237	/**
238	* @return int
239	*/
240	public function getRecordsFiltered()
241	{
242	$query = $this->getFilteredQuery();	20✔
243	$paginator = new Paginator($query, $fetchJoinCollection = true);	20✔
244	$paginator->setUseOutputWalkers($this->useOutputWalkers);	20✔
245
246	return $paginator->count();	20✔
247	}
248
249	/**
250	* @return int
251	*/
252	public function getRecordsTotal()
253	{
254	$query = clone $this->queryBuilder;	20✔
255	$paginator = new Paginator($query, $fetchJoinCollection = true);	20✔
256	$paginator->setUseOutputWalkers($this->useOutputWalkers);	20✔
257
258	return $paginator->count();	20✔
259	}
260
261	/**
262	* @return array
263	*/
264	public function getResponse()
265	{
266	return [	20✔
267	'data' => $this->getData(),	20✔
268	'draw' => $this->requestParams['draw'],	20✔
269	'recordsFiltered' => $this->getRecordsFiltered(),	20✔
270	'recordsTotal' => $this->getRecordsTotal(),	20✔
271	];	20✔
272	}
273
274	/**
275	* @param string $indexColumn
276	*
277	* @return static
278	*/
279	public function withIndexColumn($indexColumn)
280	{
281	$this->indexColumn = $indexColumn;	20✔
282
283	return $this;	20✔
284	}
285
286	/**
287	* @param string\|null $useOutputWalkers
288	* return static
289	*/
290	public function setUseOutputWalkers($useOutputWalkers)
291	{
292	$this->useOutputWalkers = $useOutputWalkers;	20✔
293
294	return $this;	20✔
295	}
296
297	/**
298	* @param array $columnAliases
299	*
300	* @return static
301	*/
302	public function withColumnAliases($columnAliases)
303	{
304	$this->columnAliases = $columnAliases;	20✔
305
306	return $this;	20✔
307	}
308
309	/**
310	* @param bool $caseInsensitive
311	*
312	* @return static
313	*/
314	public function withCaseInsensitive($caseInsensitive)
315	{
316	$this->caseInsensitive = $caseInsensitive;	20✔
317
318	return $this;	20✔
319	}
320
321	/**
322	* @param string $columnField
323	*
324	* @return static
325	*/
326	public function withColumnField($columnField)
327	{
328	$this->columnField = $columnField;	20✔
329
330	return $this;	20✔
331	}
332
333	/**
334	* @param ORMQueryBuilder\|QueryBuilder $queryBuilder
335	*
336	* @return static
337	*/
338	public function withQueryBuilder($queryBuilder)
339	{
340	$this->queryBuilder = $queryBuilder;	20✔
341
342	return $this;	20✔
343	}
344
345	/**
346	* @param array $requestParams
347	*
348	* @return static
349	*/
350	public function withRequestParams($requestParams)
351	{
352	$this->requestParams = $requestParams;	20✔
353
354	return $this;	20✔
355	}
356	}

daycry / doctrine / 13569484215

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous