15346293061

Committed 30 May 2025 12:00PM UTC coverage: 35.433% (-0.06%) from 35.492%

Build # 15346293061

Build Type

push

github

Committed by

f3l1x

Commit Message

QA: fix phpstan

Run Details

4 of 7 new or added lines in 2 files covered. (57.14%)

127 existing lines in 9 files now uncovered.

1198 of 3381 relevant lines covered (35.43%)

0.35 hits per line

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

51.11

/src/DataSource/DibiFluentDataSource.php

<?php declare(strict_types = 1);

namespace Contributte\Datagrid\DataSource;

use Contributte\Datagrid\AggregationFunction\IAggregatable;
use Contributte\Datagrid\AggregationFunction\IAggregationFunction;
use Contributte\Datagrid\Exception\DatagridDateTimeHelperException;
use Contributte\Datagrid\Filter\FilterDate;
use Contributte\Datagrid\Filter\FilterDateRange;
use Contributte\Datagrid\Filter\FilterMultiSelect;
use Contributte\Datagrid\Filter\FilterRange;
use Contributte\Datagrid\Filter\FilterSelect;
use Contributte\Datagrid\Filter\FilterText;
use Contributte\Datagrid\Utils\DateTimeHelper;
use Contributte\Datagrid\Utils\Sorting;
use Dibi\Fluent;
use Dibi\Helpers;
use ReflectionClass;

class DibiFluentDataSource extends FilterableDataSource implements IDataSource, IAggregatable
{

        protected array $data = [];

        public function __construct(protected Fluent $dataSource, protected string $primaryKey)
        {
        }

        public function getCount(): int
        {
                return $this->dataSource->count();
        }

        /**
         * {@inheritDoc}
         */
        public function getData(): array
        {
                return $this->data !== [] ? $this->data : $this->dataSource->fetchAll();
        }

        /**
         * {@inheritDoc}
         */
        public function filterOne(array $condition): IDataSource
        {
                $this->dataSource->where($condition)->limit(1);

                return $this;
        }

        public function limit(int $offset, int $limit): IDataSource
        {
                $this->dataSource->limit($limit)->offset($offset);

                $this->data = $this->dataSource->fetchAll();

                return $this;
        }

        public function sort(Sorting $sorting): IDataSource
        {
                if (is_callable($sorting->getSortCallback())) {
                        call_user_func(
                                $sorting->getSortCallback(),
                                $this->dataSource,
                                $sorting->getSort()
                        );

                        return $this;
                }

                $sort = $sorting->getSort();

                if ($sort !== []) {
                        $this->dataSource->removeClause('ORDER BY');
                        $this->dataSource->orderBy($sort);
                } else {
                        /**
                         * Has the statement already a order by clause?
                         */
                        $this->dataSource->clause('ORDER BY');

                        $reflection = new ReflectionClass(Fluent::class);

                        $cursorProperty = $reflection->getProperty('cursor');
                        $cursorProperty->setAccessible(true);
                        $cursor = $cursorProperty->getValue($this->dataSource);

                        if (!(bool) $cursor) {
                                $this->dataSource->orderBy($this->primaryKey);
                        }
                }

                return $this;
        }

        public function processAggregation(IAggregationFunction $function): void
        {
                $function->processDataSource(clone $this->dataSource);
        }

        public function getDataSource(): Fluent
        {
                return $this->dataSource;
        }

        protected function applyFilterDate(FilterDate $filter): void
        {
                $conditions = $filter->getCondition();

                try {
                        $date = DateTimeHelper::tryConvertToDateTime($conditions[$filter->getColumn()], [$filter->getPhpFormat()]);

                        $this->dataSource->where('DATE(%n) = ?', $filter->getColumn(), $date->format('Y-m-d'));
                } catch (DatagridDateTimeHelperException) {
                        // ignore the invalid filter value
                }
        }

        protected function applyFilterDateRange(FilterDateRange $filter): void
        {
                $conditions = $filter->getCondition();

                $valueFrom = $conditions[$filter->getColumn()]['from'];
                $valueTo = $conditions[$filter->getColumn()]['to'];

                if ($valueFrom) {
                        try {
                                $dateFrom = DateTimeHelper::tryConvertToDateTime($valueFrom, [$filter->getPhpFormat()]);
                                $dateFrom->setTime(0, 0, 0);

                                $this->dataSource->where('DATE(%n) >= ?', $filter->getColumn(), $dateFrom);
                        } catch (DatagridDateTimeHelperException) {
                                // ignore the invalid filter value
                        }
                }

                if ($valueTo) {
                        try {
                                $dateTo = DateTimeHelper::tryConvertToDateTime($valueTo, [$filter->getPhpFormat()]);
                                $dateTo->setTime(23, 59, 59);

                                $this->dataSource->where('DATE(%n) <= ?', $filter->getColumn(), $dateTo);
                        } catch (DatagridDateTimeHelperException) {
                                // ignore the invalid filter value
                        }
                }
        }

        protected function applyFilterRange(FilterRange $filter): void
        {
                $conditions = $filter->getCondition();

                $valueFrom = $conditions[$filter->getColumn()]['from'];
                $valueTo = $conditions[$filter->getColumn()]['to'];

                if ($valueFrom || $valueFrom !== '') {
                        $this->dataSource->where('%n >= ?', $filter->getColumn(), $valueFrom);
                }

                if ($valueTo || $valueTo !== '') {
                        $this->dataSource->where('%n <= ?', $filter->getColumn(), $valueTo);
                }
        }

        protected function applyFilterText(FilterText $filter): void
        {
                $condition = $filter->getCondition();
                $driver = $this->dataSource->getConnection()->getDriver();
                $or = [];

                foreach ($condition as $column => $value) {
                        $column = Helpers::escape($driver, $column, Fluent::Identifier);

                        if ($filter->isExactSearch()) {
                                $this->dataSource->where(sprintf('%s = %%s', $column), $value);

                                continue;
                        }

                        $words = $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);

                        foreach ($words as $word) {
                                $or[] = [sprintf('%s LIKE %%~like~', $column), $word];
                        }
                }

                if (count($or) > 1) {
                        $this->dataSource->where($filter->hasConjunctionSearch() ? '(%and)' : '(%or)', $or);
                } else {
                        $this->dataSource->where($or);
                }
        }

        protected function applyFilterMultiSelect(FilterMultiSelect $filter): void
        {
                $condition = $filter->getCondition();
                $values = $condition[$filter->getColumn()];

                if ((is_countable($values) ? count($values) : 0) > 1) {
                        $value1 = array_shift($values);
                        $length = count($values);
                        $i = 1;

                        $this->dataSource->where('(%n = ?', $filter->getColumn(), $value1);

                        foreach ($values as $value) {
                                if ($i === $length) {
                                        $this->dataSource->__call('or', ['%n = ?)', $filter->getColumn(), $value]);
                                } else {
                                        $this->dataSource->__call('or', ['%n = ?', $filter->getColumn(), $value]);
                                }

                                $i++;
                        }
                } else {
                        $this->dataSource->where('%n = ?', $filter->getColumn(), reset($values));
                }
        }

        protected function applyFilterSelect(FilterSelect $filter): void
        {
                $this->dataSource->where($filter->getCondition());
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\Datagrid\DataSource;
4
5	use Contributte\Datagrid\AggregationFunction\IAggregatable;
6	use Contributte\Datagrid\AggregationFunction\IAggregationFunction;
7	use Contributte\Datagrid\Exception\DatagridDateTimeHelperException;
8	use Contributte\Datagrid\Filter\FilterDate;
9	use Contributte\Datagrid\Filter\FilterDateRange;
10	use Contributte\Datagrid\Filter\FilterMultiSelect;
11	use Contributte\Datagrid\Filter\FilterRange;
12	use Contributte\Datagrid\Filter\FilterSelect;
13	use Contributte\Datagrid\Filter\FilterText;
14	use Contributte\Datagrid\Utils\DateTimeHelper;
15	use Contributte\Datagrid\Utils\Sorting;
16	use Dibi\Fluent;
17	use Dibi\Helpers;
18	use ReflectionClass;
19
20	class DibiFluentDataSource extends FilterableDataSource implements IDataSource, IAggregatable
21	{
22
23	protected array $data = [];
24
25	public function __construct(protected Fluent $dataSource, protected string $primaryKey)	1✔
26	{
27	}	1✔
28
29	public function getCount(): int
30	{
31	return $this->dataSource->count();	1✔
32	}
33
34	/**
35	* {@inheritDoc}
36	*/
37	public function getData(): array
38	{
39	return $this->data !== [] ? $this->data : $this->dataSource->fetchAll();	1✔
40	}
41
42	/**
43	* {@inheritDoc}
44	*/
45	public function filterOne(array $condition): IDataSource	1✔
46	{
47	$this->dataSource->where($condition)->limit(1);	1✔
48
49	return $this;	1✔
50	}
51
52	public function limit(int $offset, int $limit): IDataSource	1✔
53	{
54	$this->dataSource->limit($limit)->offset($offset);	1✔
55
56	$this->data = $this->dataSource->fetchAll();	1✔
57
58	return $this;	1✔
59	}
60
61	public function sort(Sorting $sorting): IDataSource	1✔
62	{
63	if (is_callable($sorting->getSortCallback())) {	1✔
64	call_user_func(	×
65	$sorting->getSortCallback(),	×
66	$this->dataSource,	×
67	$sorting->getSort()	×
68	);
69
70	return $this;	×
71	}
72
73	$sort = $sorting->getSort();	1✔
74
75	if ($sort !== []) {	1✔
76	$this->dataSource->removeClause('ORDER BY');	1✔
77	$this->dataSource->orderBy($sort);	1✔
78	} else {
79	/**
80	* Has the statement already a order by clause?
81	*/
82	$this->dataSource->clause('ORDER BY');	×
83
84	$reflection = new ReflectionClass(Fluent::class);	×
85
86	$cursorProperty = $reflection->getProperty('cursor');	×
87	$cursorProperty->setAccessible(true);	×
88	$cursor = $cursorProperty->getValue($this->dataSource);	×
89
90	if (!(bool) $cursor) {	×
91	$this->dataSource->orderBy($this->primaryKey);	×
92	}
93	}
94
95	return $this;	1✔
96	}
97
98	public function processAggregation(IAggregationFunction $function): void
99	{
100	$function->processDataSource(clone $this->dataSource);	×
101	}
102
103	public function getDataSource(): Fluent
104	{
105	return $this->dataSource;	×
106	}
107
108	protected function applyFilterDate(FilterDate $filter): void
109	{
110	$conditions = $filter->getCondition();	×
111
112	try {
UNCOV 113	$date = DateTimeHelper::tryConvertToDateTime($conditions[$filter->getColumn()], [$filter->getPhpFormat()]);	×
114
UNCOV 115	$this->dataSource->where('DATE(%n) = ?', $filter->getColumn(), $date->format('Y-m-d'));	×
UNCOV 116	} catch (DatagridDateTimeHelperException) {	×
117	// ignore the invalid filter value
118	}
119	}
120
121	protected function applyFilterDateRange(FilterDateRange $filter): void
122	{
123	$conditions = $filter->getCondition();	×
124
125	$valueFrom = $conditions[$filter->getColumn()]['from'];	×
126	$valueTo = $conditions[$filter->getColumn()]['to'];	×
127
128	if ($valueFrom) {	×
129	try {
UNCOV 130	$dateFrom = DateTimeHelper::tryConvertToDateTime($valueFrom, [$filter->getPhpFormat()]);	×
UNCOV 131	$dateFrom->setTime(0, 0, 0);	×
132
UNCOV 133	$this->dataSource->where('DATE(%n) >= ?', $filter->getColumn(), $dateFrom);	×
134	} catch (DatagridDateTimeHelperException) {	×
135	// ignore the invalid filter value
136	}
137	}
138
139	if ($valueTo) {	×
140	try {
UNCOV 141	$dateTo = DateTimeHelper::tryConvertToDateTime($valueTo, [$filter->getPhpFormat()]);	×
UNCOV 142	$dateTo->setTime(23, 59, 59);	×
143
UNCOV 144	$this->dataSource->where('DATE(%n) <= ?', $filter->getColumn(), $dateTo);	×
UNCOV 145	} catch (DatagridDateTimeHelperException) {	×
146	// ignore the invalid filter value
147	}
148	}
149	}
150
151	protected function applyFilterRange(FilterRange $filter): void	1✔
152	{
153	$conditions = $filter->getCondition();	1✔
154
155	$valueFrom = $conditions[$filter->getColumn()]['from'];	1✔
156	$valueTo = $conditions[$filter->getColumn()]['to'];	1✔
157
158	if ($valueFrom \|\| $valueFrom !== '') {	1✔
159	$this->dataSource->where('%n >= ?', $filter->getColumn(), $valueFrom);	1✔
160	}
161
162	if ($valueTo \|\| $valueTo !== '') {	1✔
163	$this->dataSource->where('%n <= ?', $filter->getColumn(), $valueTo);	1✔
164	}
165	}	1✔
166
167	protected function applyFilterText(FilterText $filter): void	1✔
168	{
169	$condition = $filter->getCondition();	1✔
170	$driver = $this->dataSource->getConnection()->getDriver();	1✔
171	$or = [];	1✔
172
173	foreach ($condition as $column => $value) {	1✔
174	$column = Helpers::escape($driver, $column, Fluent::Identifier);	1✔
175
176	if ($filter->isExactSearch()) {	1✔
177	$this->dataSource->where(sprintf('%s = %%s', $column), $value);	1✔
178
179	continue;	1✔
180	}
181
182	$words = $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);	1✔
183
184	foreach ($words as $word) {	1✔
185	$or[] = [sprintf('%s LIKE %%~like~', $column), $word];	1✔
186	}
187	}
188
189	if (count($or) > 1) {	1✔
190	$this->dataSource->where($filter->hasConjunctionSearch() ? '(%and)' : '(%or)', $or);	1✔
191	} else {
192	$this->dataSource->where($or);	1✔
193	}
194	}	1✔
195
196	protected function applyFilterMultiSelect(FilterMultiSelect $filter): void
197	{
198	$condition = $filter->getCondition();	×
199	$values = $condition[$filter->getColumn()];	×
200
201	if ((is_countable($values) ? count($values) : 0) > 1) {	×
UNCOV 202	$value1 = array_shift($values);	×
203	$length = count($values);	×
204	$i = 1;	×
205
UNCOV 206	$this->dataSource->where('(%n = ?', $filter->getColumn(), $value1);	×
207
UNCOV 208	foreach ($values as $value) {	×
UNCOV 209	if ($i === $length) {	×
210	$this->dataSource->__call('or', ['%n = ?)', $filter->getColumn(), $value]);	×
211	} else {
UNCOV 212	$this->dataSource->__call('or', ['%n = ?', $filter->getColumn(), $value]);	×
213	}
214
UNCOV 215	$i++;	×
216	}
217	} else {
UNCOV 218	$this->dataSource->where('%n = ?', $filter->getColumn(), reset($values));	×
219	}
220	}
221
222	protected function applyFilterSelect(FilterSelect $filter): void	1✔
223	{
224	$this->dataSource->where($filter->getCondition());	1✔
225	}	1✔
226
227	}

contributte / datagrid / 15346293061

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