8230157862

Committed 11 Mar 2024 09:02AM UTC coverage: 34.102%. First build

Build # 8230157862

Build Type

Pull #1060

github

Committed by

radimvaculik

Commit Message

Fix failing tests

Pull Request Pull Request #1060: [7.x] Next

Run Details

117 of 435 new or added lines in 54 files covered. (26.9%)

1124 of 3296 relevant lines covered (34.1%)

0.34 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())) {
                        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);
        }

        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 = [
                        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()]
                );
        }

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

        /**
         * 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
NEW 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	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 {
NEW 94	if ($this->dataSource instanceof DbalCollection) {	×
NEW 95	$order = $this->dataSource->getQueryBuilder()->getClause('order');	×
96
NEW 97	if (ArraysHelper::testEmpty($order)) {	×
NEW 98	$this->dataSource = $this->dataSource->orderBy(	×
NEW 99	$this->prepareColumn($this->primaryKey)	×
100	);
101	}
102	}
103	}
104
105	return $this;	×
106	}
107
108	public function processAggregation(IAggregationFunction $function): void
109	{
NEW 110	$function->processDataSource(clone $this->dataSource);	×
111	}
112
113	protected function applyFilterDate(FilterDate $filter): void
114	{
115	foreach ($filter->getCondition() as $column => $value) {	×
116	try {
117	$date = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);	×
118	$date_end = clone $date;	×
119
120	$this->dataSource = $this->dataSource->findBy([	×
121	$this->prepareColumn($column) . '>=' => $date->setTime(0, 0, 0),	×
122	$this->prepareColumn($column) . '<=' => $date_end->setTime(23, 59, 59),	×
123	]);
NEW 124	} catch (DatagridDateTimeHelperException) {	×
125	// ignore the invalid filter value
126	}
127	}
128	}
129
130	protected function applyFilterDateRange(FilterDateRange $filter): void
131	{
132	$conditions = $filter->getCondition();	×
133
134	$valueFrom = $conditions[$filter->getColumn()]['from'];	×
135	$valueTo = $conditions[$filter->getColumn()]['to'];	×
136
137	$dataCondition = [];	×
138
139	if ($valueFrom) {	×
140	try {
141	$dateFrom = DateTimeHelper::tryConvertToDateTime(	×
142	$valueFrom,	×
143	[$filter->getPhpFormat()]	×
144	);
145	$dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $dateFrom->setTime(0, 0, 0);	×
NEW 146	} catch (DatagridDateTimeHelperException) {	×
147	// ignore the invalid filter value
148	}
149	}
150
151	if ($valueTo) {	×
152	try {
153	$dateTo = DateTimeHelper::tryConvertToDateTime(	×
154	$valueTo,	×
155	[$filter->getPhpFormat()]	×
156	);
157	$dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $dateTo->setTime(23, 59, 59);	×
NEW 158	} catch (DatagridDateTimeHelperException) {	×
159	// ignore the invalid filter value
160	}
161	}
162
163	if ($dataCondition !== []) {	×
164	$this->dataSource = $this->dataSource->findBy($dataCondition);	×
165	}
166	}
167
168	protected function applyFilterRange(FilterRange $filter): void
169	{
170	$conditions = $filter->getCondition();	×
171
172	$valueFrom = $conditions[$filter->getColumn()]['from'];	×
173	$valueTo = $conditions[$filter->getColumn()]['to'];	×
174
175	$dataCondition = [];	×
176
177	if (is_numeric($valueFrom)) {	×
178	$dataCondition[$this->prepareColumn($filter->getColumn()) . '>='] = $valueFrom;	×
179	}
180
181	if (is_numeric($valueTo)) {	×
182	$dataCondition[$this->prepareColumn($filter->getColumn()) . '<='] = $valueTo;	×
183	}
184
185	if ($dataCondition !== []) {	×
186	$this->dataSource = $this->dataSource->findBy($dataCondition);	×
187	}
188	}
189
190	protected function applyFilterText(FilterText $filter): void
191	{
NEW 192	$conditions = [	×
NEW 193	ICollection::OR,	×
194	];
195
NEW 196	foreach ($filter->getCondition() as $column => $value) {	×
NEW 197	$preparedColumn = $this->prepareColumn($column);	×
198
NEW 199	if ($filter->isExactSearch()) {	×
NEW 200	$conditions[] = [	×
NEW 201	$preparedColumn => $value,	×
202	];
203	} else {
NEW 204	$words = $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);	×
205
NEW 206	foreach ($words as $word) {	×
207	$conditions[] = [	×
NEW 208	$preparedColumn . '~' => LikeExpression::contains($word),	×
209	];
210	}
211	}
212	}
213
NEW 214	$this->dataSource = $this->dataSource->findBy($conditions);	×
215	}
216
217	protected function applyFilterMultiSelect(FilterMultiSelect $filter): void
218	{
219	$this->applyFilterSelect($filter);	×
220	}
221
222	protected function applyFilterSelect(FilterSelect $filter): void
223	{
224	$this->dataSource = $this->dataSource->findBy(	×
225	[$this->prepareColumn($filter->getColumn()) => $filter->getValue()]	×
226	);
227	}
228
229	protected function getDataSource(): ICollection
230	{
231	return $this->dataSource;	×
232	}
233
234	/**
235	* Adjust column from Datagrid 'foreignKey.column' to Nextras 'this->foreignKey->column'
236	*/
237	private function prepareColumn(string $column): string
238	{
NEW 239	if (str_contains($column, '.')) {	×
NEW 240	return str_replace('.', '->', $column);	×
241	}
242
243	return $column;	×
244	}
245
246	}

contributte / datagrid / 8230157862

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