7048127238

Committed 30 Nov 2023 02:47PM UTC coverage: 34.081%. First build

Build # 7048127238

Build Type

Pull #1060

github

Committed by

paveljanda

Commit Message

Minor CSS changes for the next verison of datagrid

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

Run Details

118 of 431 new or added lines in 54 files covered. (27.38%)

1125 of 3301 relevant lines covered (34.08%)

0.34 hits per line

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

56.59

/src/DataSource/ArrayDataSource.php

<?php declare(strict_types = 1);

namespace Contributte\Datagrid\DataSource;

use ArrayAccess;
use Contributte\Datagrid\Exception\DatagridArrayDataSourceException;
use Contributte\Datagrid\Exception\DatagridDateTimeHelperException;
use Contributte\Datagrid\Filter\Filter;
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 DateTime;
use DateTimeInterface;
use Nette\Utils\Strings;

class ArrayDataSource implements IDataSource
{

        /** @var array */
        protected array $data = [];

        protected int $count = 0;

        public function __construct(array $dataSource)
        {
                $this->setData($dataSource);
        }

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

        /**
         * {@inheritDoc}
         */
        public function getData(): array
        {
                return $this->data;
        }

        /**
         * {@inheritDoc}
         */
        public function filter(array $filters): void
        {
                foreach ($filters as $filter) {
                        if ($filter->isValueSet()) {
                                if ($filter->getConditionCallback() !== null) {
                                        $data = (array) call_user_func_array(
                                                $filter->getConditionCallback(),
                                                [$this->data, $filter->getValue()]
                                        );
                                        $this->setData($data);
                                } else {
                                        $data = array_filter($this->data, fn ($row) => $this->applyFilter($row, $filter));
                                        $this->setData($data);
                                }
                        }
                }
        }

        /**
         * {@inheritDoc}
         */
        public function filterOne(array $condition): IDataSource
        {
                foreach ($this->data as $item) {
                        foreach ($condition as $key => $value) {
                                if ($item[$key] === $value) {
                                        $this->setData([$item]);

                                        return $this;
                                }
                        }
                }

                $this->setData([]);

                return $this;
        }

        public function limit(int $offset, int $limit): IDataSource
        {
                $data = array_slice($this->data, $offset, $limit);
                $this->setData($data);

                return $this;
        }

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

                        if (!is_array($data)) {
                                throw new DatagridArrayDataSourceException('Sorting callback has to return array');
                        }

                        $this->setData($data);

                        return $this;
                }

                $sort = $sorting->getSort();

                foreach ($sort as $column => $order) {
                        $data = [];

                        foreach ($this->data as $item) {
                                $sort_by = is_object($item[$column]) && $item[$column] instanceof DateTimeInterface
                                        ? $item[$column]->format('Y-m-d H:i:s')
                                        : (string) $item[$column];

                                $data[$sort_by][] = $item;
                        }

                        if ($order === 'ASC') {
                                ksort($data);
                        } else {
                                krsort($data);
                        }

                        $dataSource = [];

                        foreach ($data as $i) {
                                foreach ($i as $item) {
                                        $dataSource[] = $item;
                                }
                        }

                        $this->setData($dataSource);
                }

                return $this;
        }

        protected function applyFilter(mixed $row, Filter $filter): mixed
        {
                if (is_array($row) || $row instanceof ArrayAccess) {
                        if ($filter instanceof FilterDate) {
                                return $this->applyFilterDate($row, $filter);
                        }

                        if ($filter instanceof FilterMultiSelect) {
                                return $this->applyFilterMultiSelect($row, $filter);
                        }

                        if ($filter instanceof FilterDateRange) {
                                return $this->applyFilterDateRange($row, $filter);
                        }

                        if ($filter instanceof FilterRange) {
                                return $this->applyFilterRange($row, $filter);
                        }

                        $condition = $filter->getCondition();

                        foreach ($condition as $column => $value) {
                                $value = (string) $value;
                                $rowVal = (string) $row[$column];

                                if ($filter instanceof FilterSelect) {
                                        return $rowVal === $value;
                                }

                                if ($filter instanceof FilterText && $filter->isExactSearch()) {
                                        return $rowVal === $value;
                                }

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

                                $row_value = strtolower(Strings::toAscii((string) $row[$column]));

                                foreach ($words as $word) {
                                        if (str_contains($row_value, strtolower(Strings::toAscii($word)))) {
                                                return $row;
                                        }
                                }
                        }
                }

                return false;
        }

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

                return in_array($row[$filter->getColumn()], $values, true);
        }

        protected function applyFilterRange(mixed $row, FilterRange $filter): bool
        {
                $condition = $filter->getCondition();
                $values = $condition[$filter->getColumn()];

                if ($values['from'] !== null && $values['from'] !== '') {
                        if ($values['from'] > $row[$filter->getColumn()]) {
                                return false;
                        }
                }

                if ($values['to'] !== null && $values['to'] !== '') {
                        if ($values['to'] < $row[$filter->getColumn()]) {
                                return false;
                        }
                }

                return true;
        }

        protected function applyFilterDateRange(mixed $row, FilterDateRange $filter): bool
        {
                $format = $filter->getPhpFormat();
                $condition = $filter->getCondition();
                $values = $condition[$filter->getColumn()];
                $row_value = $row[$filter->getColumn()];

                if ($values['from'] !== null && $values['from'] !== '') {
                        $date_from = DateTimeHelper::tryConvertToDate($values['from'], [$format]);
                        $date_from->setTime(0, 0, 0);

                        if (!($row_value instanceof DateTime)) {
                                /**
                                 * Try to convert string to DateTime object
                                 */
                                try {
                                        $row_value = DateTimeHelper::tryConvertToDate($row_value);
                                } catch (DatagridDateTimeHelperException) {
                                        /**
                                         * Otherwise just return raw string
                                         */
                                        return false;
                                }
                        }

                        if ($row_value->getTimestamp() < $date_from->getTimestamp()) {
                                return false;
                        }
                }

                if ($values['to'] !== null && $values['to'] !== '') {
                        $date_to = DateTimeHelper::tryConvertToDate($values['to'], [$format]);
                        $date_to->setTime(23, 59, 59);

                        if (!($row_value instanceof DateTime)) {
                                /**
                                 * Try to convert string to DateTime object
                                 */
                                try {
                                        $row_value = DateTimeHelper::tryConvertToDate($row_value);
                                } catch (DatagridDateTimeHelperException) {
                                        /**
                                         * Otherwise just return raw string
                                         */
                                        return false;
                                }
                        }

                        if ($row_value->getTimestamp() > $date_to->getTimestamp()) {
                                return false;
                        }
                }

                return true;
        }

        /**
         * Apply fitler date and tell whether row value matches or not
         */
        protected function applyFilterDate(mixed $row, FilterDate $filter): bool
        {
                $format = $filter->getPhpFormat();
                $condition = $filter->getCondition();

                foreach ($condition as $column => $value) {
                        $row_value = $row[$column];

                        $date = DateTimeHelper::tryConvertToDateTime($value, [$format]);

                        if (!($row_value instanceof DateTime)) {
                                /**
                                 * Try to convert string to DateTime object
                                 */
                                try {
                                        $row_value = DateTimeHelper::tryConvertToDateTime($row_value);
                                } catch (DatagridDateTimeHelperException) {
                                        /**
                                         * Otherwise just return raw string
                                         */
                                        return false;
                                }
                        }

                        return $row_value->format($format) === $date->format($format);
                }

                return false;
        }

        /**
         * Set the data
         */
        private function setData(array $dataSource): IDataSource
        {
                $this->data = $dataSource;

                return $this;
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\Datagrid\DataSource;
4
5	use ArrayAccess;
6	use Contributte\Datagrid\Exception\DatagridArrayDataSourceException;
7	use Contributte\Datagrid\Exception\DatagridDateTimeHelperException;
8	use Contributte\Datagrid\Filter\Filter;
9	use Contributte\Datagrid\Filter\FilterDate;
10	use Contributte\Datagrid\Filter\FilterDateRange;
11	use Contributte\Datagrid\Filter\FilterMultiSelect;
12	use Contributte\Datagrid\Filter\FilterRange;
13	use Contributte\Datagrid\Filter\FilterSelect;
14	use Contributte\Datagrid\Filter\FilterText;
15	use Contributte\Datagrid\Utils\DateTimeHelper;
16	use Contributte\Datagrid\Utils\Sorting;
17	use DateTime;
18	use DateTimeInterface;
19	use Nette\Utils\Strings;
20
21	class ArrayDataSource implements IDataSource
22	{
23
24	/** @var array */
25	protected array $data = [];
26
27	protected int $count = 0;
28
29	public function __construct(array $dataSource)	1✔
30	{
31	$this->setData($dataSource);	1✔
32	}	1✔
33
34	public function getCount(): int
35	{
36	return count($this->data);	1✔
37	}
38
39	/**
40	* {@inheritDoc}
41	*/
42	public function getData(): array
43	{
44	return $this->data;	1✔
45	}
46
47	/**
48	* {@inheritDoc}
49	*/
50	public function filter(array $filters): void	1✔
51	{
52	foreach ($filters as $filter) {	1✔
53	if ($filter->isValueSet()) {	1✔
54	if ($filter->getConditionCallback() !== null) {	1✔
55	$data = (array) call_user_func_array(	×
56	$filter->getConditionCallback(),	×
57	[$this->data, $filter->getValue()]	×
58	);
59	$this->setData($data);	×
60	} else {
61	$data = array_filter($this->data, fn ($row) => $this->applyFilter($row, $filter));	1✔
62	$this->setData($data);	1✔
63	}
64	}
65	}
66	}	1✔
67
68	/**
69	* {@inheritDoc}
70	*/
71	public function filterOne(array $condition): IDataSource	1✔
72	{
73	foreach ($this->data as $item) {	1✔
74	foreach ($condition as $key => $value) {	1✔
75	if ($item[$key] === $value) {	1✔
76	$this->setData([$item]);	1✔
77
78	return $this;	1✔
79	}
80	}
81	}
82
83	$this->setData([]);	×
84
85	return $this;	×
86	}
87
88	public function limit(int $offset, int $limit): IDataSource	1✔
89	{
90	$data = array_slice($this->data, $offset, $limit);	1✔
91	$this->setData($data);	1✔
92
93	return $this;	1✔
94	}
95
96	public function sort(Sorting $sorting): IDataSource	1✔
97	{
98	if (is_callable($sorting->getSortCallback())) {	1✔
99	$data = call_user_func(	×
100	$sorting->getSortCallback(),	×
101	$this->data,	×
102	$sorting->getSort()	×
103	);
104
105	if (!is_array($data)) {	×
NEW 106	throw new DatagridArrayDataSourceException('Sorting callback has to return array');	×
107	}
108
109	$this->setData($data);	×
110
111	return $this;	×
112	}
113
114	$sort = $sorting->getSort();	1✔
115
116	foreach ($sort as $column => $order) {	1✔
117	$data = [];	1✔
118
119	foreach ($this->data as $item) {	1✔
120	$sort_by = is_object($item[$column]) && $item[$column] instanceof DateTimeInterface	1✔
121	? $item[$column]->format('Y-m-d H:i:s')	×
122	: (string) $item[$column];	1✔
123
124	$data[$sort_by][] = $item;	1✔
125	}
126
127	if ($order === 'ASC') {	1✔
128	ksort($data);	×
129	} else {
130	krsort($data);	1✔
131	}
132
133	$dataSource = [];	1✔
134
135	foreach ($data as $i) {	1✔
136	foreach ($i as $item) {	1✔
137	$dataSource[] = $item;	1✔
138	}
139	}
140
141	$this->setData($dataSource);	1✔
142	}
143
144	return $this;	1✔
145	}
146
147	protected function applyFilter(mixed $row, Filter $filter): mixed	1✔
148	{
149	if (is_array($row) \|\| $row instanceof ArrayAccess) {	1✔
150	if ($filter instanceof FilterDate) {	1✔
151	return $this->applyFilterDate($row, $filter);	×
152	}
153
154	if ($filter instanceof FilterMultiSelect) {	1✔
155	return $this->applyFilterMultiSelect($row, $filter);	×
156	}
157
158	if ($filter instanceof FilterDateRange) {	1✔
159	return $this->applyFilterDateRange($row, $filter);	×
160	}
161
162	if ($filter instanceof FilterRange) {	1✔
163	return $this->applyFilterRange($row, $filter);	1✔
164	}
165
166	$condition = $filter->getCondition();	1✔
167
168	foreach ($condition as $column => $value) {	1✔
169	$value = (string) $value;	1✔
170	$rowVal = (string) $row[$column];	1✔
171
172	if ($filter instanceof FilterSelect) {	1✔
173	return $rowVal === $value;	1✔
174	}
175
176	if ($filter instanceof FilterText && $filter->isExactSearch()) {	1✔
177	return $rowVal === $value;	1✔
178	}
179
180	$words = $filter instanceof FilterText && $filter->hasSplitWordsSearch() === false ? [$value] : explode(' ', $value);	1✔
181
182	$row_value = strtolower(Strings::toAscii((string) $row[$column]));	1✔
183
184	foreach ($words as $word) {	1✔
185	if (str_contains($row_value, strtolower(Strings::toAscii($word)))) {	1✔
186	return $row;	1✔
187	}
188	}
189	}
190	}
191
192	return false;	1✔
193	}
194
195	protected function applyFilterMultiSelect(mixed $row, FilterMultiSelect $filter): bool
196	{
197	$condition = $filter->getCondition();	×
198	$values = $condition[$filter->getColumn()];	×
199
200	return in_array($row[$filter->getColumn()], $values, true);	×
201	}
202
203	protected function applyFilterRange(mixed $row, FilterRange $filter): bool	1✔
204	{
205	$condition = $filter->getCondition();	1✔
206	$values = $condition[$filter->getColumn()];	1✔
207
208	if ($values['from'] !== null && $values['from'] !== '') {	1✔
209	if ($values['from'] > $row[$filter->getColumn()]) {	1✔
210	return false;	1✔
211	}
212	}
213
214	if ($values['to'] !== null && $values['to'] !== '') {	1✔
215	if ($values['to'] < $row[$filter->getColumn()]) {	1✔
216	return false;	1✔
217	}
218	}
219
220	return true;	1✔
221	}
222
223	protected function applyFilterDateRange(mixed $row, FilterDateRange $filter): bool
224	{
225	$format = $filter->getPhpFormat();	×
226	$condition = $filter->getCondition();	×
227	$values = $condition[$filter->getColumn()];	×
228	$row_value = $row[$filter->getColumn()];	×
229
230	if ($values['from'] !== null && $values['from'] !== '') {	×
231	$date_from = DateTimeHelper::tryConvertToDate($values['from'], [$format]);	×
232	$date_from->setTime(0, 0, 0);	×
233
234	if (!($row_value instanceof DateTime)) {	×
235	/**
236	* Try to convert string to DateTime object
237	*/
238	try {
239	$row_value = DateTimeHelper::tryConvertToDate($row_value);	×
NEW 240	} catch (DatagridDateTimeHelperException) {	×
241	/**
242	* Otherwise just return raw string
243	*/
244	return false;	×
245	}
246	}
247
248	if ($row_value->getTimestamp() < $date_from->getTimestamp()) {	×
249	return false;	×
250	}
251	}
252
253	if ($values['to'] !== null && $values['to'] !== '') {	×
254	$date_to = DateTimeHelper::tryConvertToDate($values['to'], [$format]);	×
255	$date_to->setTime(23, 59, 59);	×
256
257	if (!($row_value instanceof DateTime)) {	×
258	/**
259	* Try to convert string to DateTime object
260	*/
261	try {
262	$row_value = DateTimeHelper::tryConvertToDate($row_value);	×
NEW 263	} catch (DatagridDateTimeHelperException) {	×
264	/**
265	* Otherwise just return raw string
266	*/
267	return false;	×
268	}
269	}
270
271	if ($row_value->getTimestamp() > $date_to->getTimestamp()) {	×
272	return false;	×
273	}
274	}
275
276	return true;	×
277	}
278
279	/**
280	* Apply fitler date and tell whether row value matches or not
281	*/
282	protected function applyFilterDate(mixed $row, FilterDate $filter): bool
283	{
284	$format = $filter->getPhpFormat();	×
285	$condition = $filter->getCondition();	×
286
287	foreach ($condition as $column => $value) {	×
288	$row_value = $row[$column];	×
289
290	$date = DateTimeHelper::tryConvertToDateTime($value, [$format]);	×
291
292	if (!($row_value instanceof DateTime)) {	×
293	/**
294	* Try to convert string to DateTime object
295	*/
296	try {
297	$row_value = DateTimeHelper::tryConvertToDateTime($row_value);	×
NEW 298	} catch (DatagridDateTimeHelperException) {	×
299	/**
300	* Otherwise just return raw string
301	*/
302	return false;	×
303	}
304	}
305
306	return $row_value->format($format) === $date->format($format);	×
307	}
308
309	return false;	×
310	}
311
312	/**
313	* Set the data
314	*/
315	private function setData(array $dataSource): IDataSource	1✔
316	{
317	$this->data = $dataSource;	1✔
318
319	return $this;	1✔
320	}
321
322	}

contributte / datagrid / 7048127238

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