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

0.0

/src/DataSource/NextrasDataSource.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\ArraysHelper;
use Contributte\Datagrid\Utils\DateTimeHelper;
use Contributte\Datagrid\Utils\Sorting;
use Nextras\Orm\Collection\DbalCollection;
use Nextras\Orm\Collection\Expression\LikeExpression;
use Nextras\Orm\Collection\ICollection;
use function str_contains;

class NextrasDataSource extends FilterableDataSource implements IDataSource, IAggregatable
{

        protected array $data = [];

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

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

        /**
         * {@inheritDoc}
         */
        public function getData(): array
        {
                /**
                 * Paginator is better if the query uses ManyToMany associations
                 */
                return $this->data !== []
                        ? $this->data
                        : $this->dataSource->fetchAll();
        }

        /**
         * {@inheritDoc}
         */
        public function filterOne(array $condition): IDataSource
        {
                $cond = [];

                foreach ($condition as $key => $value) {
                        $cond[$this->prepareColumn($key)] = $value;
                }

                $this->dataSource = $this->dataSource->findBy($cond);

                return $this;
        }

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

                return $this;
        }

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

                        return $this;
                }

                $sort = $sorting->getSort();

                if ($sort !== []) {
                        foreach ($sort as $column => $order) {
                                $this->dataSource = $this->dataSource->orderBy(
                                        $this->prepareColumn((string) $column),
                                        $order
                                );
                        }
                } else {
                        if ($this->dataSource instanceof DbalCollection) {
                                $order = $this->dataSource->getQueryBuilder()->getClause('order');

                                if (ArraysHelper::testEmpty($order)) {
                                        $this->dataSource = $this->dataSource->orderBy(
                                                $this->prepareColumn($this->primaryKey)
                                        );
                                }
                        }
                }

                return $this;
        }

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

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

        protected function applyFilterDate(FilterDate $filter): void
        {
                foreach ($filter->getCondition() as $column => $value) {
                        try {
                                $date = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);
                                $date_end = clone $date;

                                $this->dataSource = $this->dataSource->findBy([
                                        $this->prepareColumn($column) . '>=' => $date->setTime(0, 0, 0),
                                        $this->prepareColumn($column) . '<=' => $date_end->setTime(23, 59, 59),
                                ]);
                        } 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'];

                $dataCondition = [];

                if ($valueFrom) {
                        try {
                                $dateFrom = DateTimeHelper::tryConvertToDateTime(
                                        $valueFrom,
                                        [$filter->getPhpFormat()]
                                );
                                $dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $dateFrom->setTime(0, 0, 0);
                        } catch (DatagridDateTimeHelperException) {
                                // ignore the invalid filter value
                        }
                }

                if ($valueTo) {
                        try {
                                $dateTo = DateTimeHelper::tryConvertToDateTime(
                                        $valueTo,
                                        [$filter->getPhpFormat()]
                                );
                                $dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $dateTo->setTime(23, 59, 59);
                        } catch (DatagridDateTimeHelperException) {
                                // ignore the invalid filter value
                        }
                }

                if ($dataCondition !== []) {
                        $this->dataSource = $this->dataSource->findBy($dataCondition);
                }
        }

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

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

                $dataCondition = [];

                if (is_numeric($valueFrom)) {
                        $dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $valueFrom;
                }

                if (is_numeric($valueTo)) {
                        $dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $valueTo;
                }

                if ($dataCondition !== []) {
                        $this->dataSource = $this->dataSource->findBy($dataCondition);
                }
        }

        protected function applyFilterText(FilterText $filter): void
        {
                $conditions = [
                        $filter->hasConjunctionSearch() ? ICollection::AND : ICollection::OR,
                ];

                foreach ($filter->getCondition() as $column => $value) {
                        $preparedColumn = $this->prepareColumn($column);

                        if ($filter->isExactSearch()) {
                                $conditions[] = [
                                        $preparedColumn => $value,
                                ];
                        } else {
                                $words = $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);

                                foreach ($words as $word) {
                                        $conditions[] = [
                                                $preparedColumn . '~' => LikeExpression::contains($word),
                                        ];
                                }
                        }
                }

                $this->dataSource = $this->dataSource->findBy($conditions);
        }

        protected function applyFilterMultiSelect(FilterMultiSelect $filter): void
        {
                $this->applyFilterSelect($filter);
        }

        protected function applyFilterSelect(FilterSelect $filter): void
        {
                $this->dataSource = $this->dataSource->findBy(
                        [$this->prepareColumn($filter->getColumn()) => $filter->getValue()]
                );
        }

        /**
         * Adjust column from Datagrid 'foreignKey.column' to Nextras 'this->foreignKey->column'
         */
        private function prepareColumn(string $column): string
        {
                if (str_contains($column, '.')) {
                        return str_replace('.', '->', $column);
                }

                return $column;
        }

}

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\ArraysHelper;
15	use Contributte\Datagrid\Utils\DateTimeHelper;
16	use Contributte\Datagrid\Utils\Sorting;
17	use Nextras\Orm\Collection\DbalCollection;
18	use Nextras\Orm\Collection\Expression\LikeExpression;
19	use Nextras\Orm\Collection\ICollection;
20	use function str_contains;
21
22	class NextrasDataSource extends FilterableDataSource implements IDataSource, IAggregatable
23	{
24
25	protected array $data = [];
26
27	public function __construct(protected ICollection $dataSource, protected string $primaryKey)	×
28	{
29	}
30
31	public function getCount(): int
32	{
33	return $this->dataSource->countStored();	×
34	}
35
36	/**
37	* {@inheritDoc}
38	*/
39	public function getData(): array
40	{
41	/**
42	* Paginator is better if the query uses ManyToMany associations
43	*/
44	return $this->data !== []	×
45	? $this->data	×
46	: $this->dataSource->fetchAll();	×
47	}
48
49	/**
50	* {@inheritDoc}
51	*/
52	public function filterOne(array $condition): IDataSource
53	{
54	$cond = [];	×
55
56	foreach ($condition as $key => $value) {	×
57	$cond[$this->prepareColumn($key)] = $value;	×
58	}
59
60	$this->dataSource = $this->dataSource->findBy($cond);	×
61
62	return $this;	×
63	}
64
65	public function limit(int $offset, int $limit): IDataSource
66	{
67	$this->dataSource = $this->dataSource->limitBy($limit, $offset);	×
68
69	return $this;	×
70	}
71
72	public function sort(Sorting $sorting): IDataSource
73	{
74	if (is_callable($sorting->getSortCallback())) {	×
75	$this->dataSource = call_user_func(	×
76	$sorting->getSortCallback(),	×
77	$this->dataSource,	×
78	$sorting->getSort()	×
79	);
80
81	return $this;	×
82	}
83
84	$sort = $sorting->getSort();	×
85
86	if ($sort !== []) {	×
87	foreach ($sort as $column => $order) {	×
88	$this->dataSource = $this->dataSource->orderBy(	×
89	$this->prepareColumn((string) $column),	×
90	$order
91	);
92	}
93	} else {
94	if ($this->dataSource instanceof DbalCollection) {	×
95	$order = $this->dataSource->getQueryBuilder()->getClause('order');	×
96
97	if (ArraysHelper::testEmpty($order)) {	×
98	$this->dataSource = $this->dataSource->orderBy(	×
99	$this->prepareColumn($this->primaryKey)	×
100	);
101	}
102	}
103	}
104
105	return $this;	×
106	}
107
108	public function processAggregation(IAggregationFunction $function): void
109	{
110	$function->processDataSource(clone $this->dataSource);	×
111	}
112
113	public function getDataSource(): ICollection
114	{
115	return $this->dataSource;	×
116	}
117
118	protected function applyFilterDate(FilterDate $filter): void
119	{
120	foreach ($filter->getCondition() as $column => $value) {	×
121	try {
122	$date = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);	×
UNCOV 123	$date_end = clone $date;	×
124
UNCOV 125	$this->dataSource = $this->dataSource->findBy([	×
UNCOV 126	$this->prepareColumn($column) . '>=' => $date->setTime(0, 0, 0),	×
UNCOV 127	$this->prepareColumn($column) . '<=' => $date_end->setTime(23, 59, 59),	×
128	]);
UNCOV 129	} catch (DatagridDateTimeHelperException) {	×
130	// ignore the invalid filter value
131	}
132	}
133	}
134
135	protected function applyFilterDateRange(FilterDateRange $filter): void
136	{
137	$conditions = $filter->getCondition();	×
138
139	$valueFrom = $conditions[$filter->getColumn()]['from'];	×
UNCOV 140	$valueTo = $conditions[$filter->getColumn()]['to'];	×
141
142	$dataCondition = [];	×
143
UNCOV 144	if ($valueFrom) {	×
145	try {
146	$dateFrom = DateTimeHelper::tryConvertToDateTime(	×
UNCOV 147	$valueFrom,	×
UNCOV 148	[$filter->getPhpFormat()]	×
149	);
UNCOV 150	$dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $dateFrom->setTime(0, 0, 0);	×
151	} catch (DatagridDateTimeHelperException) {	×
152	// ignore the invalid filter value
153	}
154	}
155
UNCOV 156	if ($valueTo) {	×
157	try {
158	$dateTo = DateTimeHelper::tryConvertToDateTime(	×
UNCOV 159	$valueTo,	×
UNCOV 160	[$filter->getPhpFormat()]	×
161	);
UNCOV 162	$dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $dateTo->setTime(23, 59, 59);	×
163	} catch (DatagridDateTimeHelperException) {	×
164	// ignore the invalid filter value
165	}
166	}
167
UNCOV 168	if ($dataCondition !== []) {	×
UNCOV 169	$this->dataSource = $this->dataSource->findBy($dataCondition);	×
170	}
171	}
172
173	protected function applyFilterRange(FilterRange $filter): void
174	{
175	$conditions = $filter->getCondition();	×
176
177	$valueFrom = $conditions[$filter->getColumn()]['from'];	×
178	$valueTo = $conditions[$filter->getColumn()]['to'];	×
179
UNCOV 180	$dataCondition = [];	×
181
182	if (is_numeric($valueFrom)) {	×
UNCOV 183	$dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $valueFrom;	×
184	}
185
186	if (is_numeric($valueTo)) {	×
UNCOV 187	$dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $valueTo;	×
188	}
189
UNCOV 190	if ($dataCondition !== []) {	×
UNCOV 191	$this->dataSource = $this->dataSource->findBy($dataCondition);	×
192	}
193	}
194
195	protected function applyFilterText(FilterText $filter): void
196	{
197	$conditions = [	×
UNCOV 198	$filter->hasConjunctionSearch() ? ICollection::AND : ICollection::OR,	×
199	];
200
201	foreach ($filter->getCondition() as $column => $value) {	×
UNCOV 202	$preparedColumn = $this->prepareColumn($column);	×
203
204	if ($filter->isExactSearch()) {	×
UNCOV 205	$conditions[] = [	×
206	$preparedColumn => $value,	×
207	];
208	} else {
UNCOV 209	$words = $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);	×
210
UNCOV 211	foreach ($words as $word) {	×
UNCOV 212	$conditions[] = [	×
UNCOV 213	$preparedColumn . '~' => LikeExpression::contains($word),	×
214	];
215	}
216	}
217	}
218
219	$this->dataSource = $this->dataSource->findBy($conditions);	×
220	}
221
222	protected function applyFilterMultiSelect(FilterMultiSelect $filter): void
223	{
224	$this->applyFilterSelect($filter);	×
225	}
226
227	protected function applyFilterSelect(FilterSelect $filter): void
228	{
UNCOV 229	$this->dataSource = $this->dataSource->findBy(	×
UNCOV 230	[$this->prepareColumn($filter->getColumn()) => $filter->getValue()]	×
231	);
232	}
233
234	/**
235	* Adjust column from Datagrid 'foreignKey.column' to Nextras 'this->foreignKey->column'
236	*/
237	private function prepareColumn(string $column): string
238	{
239	if (str_contains($column, '.')) {	×
240	return str_replace('.', '->', $column);	×
241	}
242
243	return $column;	×
244	}
245
246	}

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