8230347368

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

Build # 8230347368

Build Type

Pull #1060

github

Committed by

radimvaculik

Commit Message

PHP 8.1 is new minimal version

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/ElasticsearchDataSource.php

<?php declare(strict_types = 1);

namespace Contributte\Datagrid\DataSource;

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 Elastic\Elasticsearch\Client;
use RuntimeException;
use UnexpectedValueException;

class ElasticsearchDataSource extends FilterableDataSource implements IDataSource
{

        protected SearchParamsBuilder $searchParamsBuilder;

        /** @var callable */
        private $rowFactory;

        public function __construct(private Client $client, string $indexName, ?callable $rowFactory = null)
        {
                $this->searchParamsBuilder = new SearchParamsBuilder($indexName);

                if ($rowFactory === null) {
                        $rowFactory = static fn (array $hit): array => $hit['_source'];
                }

                $this->rowFactory = $rowFactory;
        }

        public function getCount(): int
        {
                $searchResult = $this->client->search($this->searchParamsBuilder->buildParams());

                if (!isset($searchResult['hits'])) {
                        throw new UnexpectedValueException();
                }

                return is_array($searchResult['hits']['total'])
                        ? $searchResult['hits']['total']['value']
                        : $searchResult['hits']['total'];
        }

        /**
         * {@inheritDoc}
         */
        public function getData(): array
        {
                $searchResult = $this->client->search($this->searchParamsBuilder->buildParams());

                if (!isset($searchResult['hits'])) {
                        throw new UnexpectedValueException();
                }

                return array_map($this->rowFactory, $searchResult['hits']['hits']);
        }

        /**
         * {@inheritDoc}
         */
        public function filterOne(array $condition): IDataSource
        {
                foreach ($condition as $value) {
                        $this->searchParamsBuilder->addIdsQuery($value);
                }

                return $this;
        }

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

                return $this;
        }

        public function applyFilterDate(FilterDate $filter): void
        {
                foreach ($filter->getCondition() as $column => $value) {
                        $timestampFrom = null;
                        $timestampTo = null;

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

                                $timestampFrom = $dateFrom->getTimestamp();

                                $dateTo = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);
                                $dateTo->setTime(23, 59, 59);

                                $timestampTo = $dateTo->getTimestamp();

                                $this->searchParamsBuilder->addRangeQuery($column, $timestampFrom, $timestampTo);
                        }
                }
        }

        public function applyFilterDateRange(FilterDateRange $filter): void
        {
                foreach ($filter->getCondition() as $column => $values) {
                        $timestampFrom = null;
                        $timestampTo = null;

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

                                $timestampFrom = $dateFrom->getTimestamp();
                        }

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

                                $timestampTo = $dateTo->getTimestamp();
                        }

                        if (is_int($timestampFrom) || is_int($timestampTo)) {
                                $this->searchParamsBuilder->addRangeQuery($column, $timestampFrom, $timestampTo);
                        }
                }
        }

        public function applyFilterRange(FilterRange $filter): void
        {
                foreach ($filter->getCondition() as $column => $value) {
                        $this->searchParamsBuilder->addRangeQuery($column, $value['from'] ?? null, $value['to'] ?? null);
                }
        }

        public function applyFilterText(FilterText $filter): void
        {
                foreach ($filter->getCondition() as $column => $value) {
                        if ($filter->isExactSearch()) {
                                $this->searchParamsBuilder->addMatchQuery($column, $value);
                        } else {
                                $this->searchParamsBuilder->addPhrasePrefixQuery($column, $value);
                        }
                }
        }

        public function applyFilterMultiSelect(FilterMultiSelect $filter): void
        {
                foreach ($filter->getCondition() as $column => $values) {
                        $this->searchParamsBuilder->addBooleanMatchQuery($column, $values);
                }
        }

        public function applyFilterSelect(FilterSelect $filter): void
        {
                foreach ($filter->getCondition() as $column => $value) {
                        $this->searchParamsBuilder->addMatchQuery($column, $value);
                }
        }

        /**
         * {@inheritDoc}
         *
         * @throws RuntimeException
         */
        public function sort(Sorting $sorting): IDataSource
        {
                if (is_callable($sorting->getSortCallback())) {
                        throw new RuntimeException('No can do - not implemented yet');
                }

                foreach ($sorting->getSort() as $column => $order) {
                        $this->searchParamsBuilder->setSort(
                                [$column => ['order' => strtolower($order)]]
                        );
                }

                return $this;
        }

        protected function getDataSource(): SearchParamsBuilder
        {
                return $this->searchParamsBuilder;
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\Datagrid\DataSource;
4
5	use Contributte\Datagrid\Filter\FilterDate;
6	use Contributte\Datagrid\Filter\FilterDateRange;
7	use Contributte\Datagrid\Filter\FilterMultiSelect;
8	use Contributte\Datagrid\Filter\FilterRange;
9	use Contributte\Datagrid\Filter\FilterSelect;
10	use Contributte\Datagrid\Filter\FilterText;
11	use Contributte\Datagrid\Utils\DateTimeHelper;
12	use Contributte\Datagrid\Utils\Sorting;
13	use Elastic\Elasticsearch\Client;
14	use RuntimeException;
15	use UnexpectedValueException;
16
17	class ElasticsearchDataSource extends FilterableDataSource implements IDataSource
18	{
19
20	protected SearchParamsBuilder $searchParamsBuilder;
21
22	/** @var callable */
23	private $rowFactory;
24
NEW 25	public function __construct(private Client $client, string $indexName, ?callable $rowFactory = null)	×
26	{
27	$this->searchParamsBuilder = new SearchParamsBuilder($indexName);	×
28
29	if ($rowFactory === null) {	×
NEW 30	$rowFactory = static fn (array $hit): array => $hit['_source'];	×
31	}
32
33	$this->rowFactory = $rowFactory;	×
34	}
35
36	public function getCount(): int
37	{
38	$searchResult = $this->client->search($this->searchParamsBuilder->buildParams());	×
39
40	if (!isset($searchResult['hits'])) {	×
NEW 41	throw new UnexpectedValueException();	×
42	}
43
44	return is_array($searchResult['hits']['total'])	×
45	? $searchResult['hits']['total']['value']	×
46	: $searchResult['hits']['total'];	×
47	}
48
49	/**
50	* {@inheritDoc}
51	*/
52	public function getData(): array
53	{
54	$searchResult = $this->client->search($this->searchParamsBuilder->buildParams());	×
55
56	if (!isset($searchResult['hits'])) {	×
NEW 57	throw new UnexpectedValueException();	×
58	}
59
60	return array_map($this->rowFactory, $searchResult['hits']['hits']);	×
61	}
62
63	/**
64	* {@inheritDoc}
65	*/
66	public function filterOne(array $condition): IDataSource
67	{
68	foreach ($condition as $value) {	×
69	$this->searchParamsBuilder->addIdsQuery($value);	×
70	}
71
72	return $this;	×
73	}
74
75	public function limit(int $offset, int $limit): IDataSource
76	{
77	$this->searchParamsBuilder->setFrom($offset);	×
78	$this->searchParamsBuilder->setSize($limit);	×
79
80	return $this;	×
81	}
82
83	public function applyFilterDate(FilterDate $filter): void
84	{
85	foreach ($filter->getCondition() as $column => $value) {	×
86	$timestampFrom = null;	×
87	$timestampTo = null;	×
88
89	if ($value) {	×
90	$dateFrom = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);	×
91	$dateFrom->setTime(0, 0, 0);	×
92
93	$timestampFrom = $dateFrom->getTimestamp();	×
94
95	$dateTo = DateTimeHelper::tryConvertToDateTime($value, [$filter->getPhpFormat()]);	×
96	$dateTo->setTime(23, 59, 59);	×
97
98	$timestampTo = $dateTo->getTimestamp();	×
99
100	$this->searchParamsBuilder->addRangeQuery($column, $timestampFrom, $timestampTo);	×
101	}
102	}
103	}
104
105	public function applyFilterDateRange(FilterDateRange $filter): void
106	{
107	foreach ($filter->getCondition() as $column => $values) {	×
108	$timestampFrom = null;	×
109	$timestampTo = null;	×
110
111	if ($values['from']) {	×
112	$dateFrom = DateTimeHelper::tryConvertToDateTime($values['from'], [$filter->getPhpFormat()]);	×
113	$dateFrom->setTime(0, 0, 0);	×
114
115	$timestampFrom = $dateFrom->getTimestamp();	×
116	}
117
118	if ($values['to']) {	×
119	$dateTo = DateTimeHelper::tryConvertToDateTime($values['to'], [$filter->getPhpFormat()]);	×
120	$dateTo->setTime(23, 59, 59);	×
121
122	$timestampTo = $dateTo->getTimestamp();	×
123	}
124
125	if (is_int($timestampFrom) \|\| is_int($timestampTo)) {	×
126	$this->searchParamsBuilder->addRangeQuery($column, $timestampFrom, $timestampTo);	×
127	}
128	}
129	}
130
131	public function applyFilterRange(FilterRange $filter): void
132	{
133	foreach ($filter->getCondition() as $column => $value) {	×
134	$this->searchParamsBuilder->addRangeQuery($column, $value['from'] ?? null, $value['to'] ?? null);	×
135	}
136	}
137
138	public function applyFilterText(FilterText $filter): void
139	{
140	foreach ($filter->getCondition() as $column => $value) {	×
141	if ($filter->isExactSearch()) {	×
142	$this->searchParamsBuilder->addMatchQuery($column, $value);	×
143	} else {
144	$this->searchParamsBuilder->addPhrasePrefixQuery($column, $value);	×
145	}
146	}
147	}
148
149	public function applyFilterMultiSelect(FilterMultiSelect $filter): void
150	{
151	foreach ($filter->getCondition() as $column => $values) {	×
152	$this->searchParamsBuilder->addBooleanMatchQuery($column, $values);	×
153	}
154	}
155
156	public function applyFilterSelect(FilterSelect $filter): void
157	{
158	foreach ($filter->getCondition() as $column => $value) {	×
159	$this->searchParamsBuilder->addMatchQuery($column, $value);	×
160	}
161	}
162
163	/**
164	* {@inheritDoc}
165	*
166	* @throws RuntimeException
167	*/
168	public function sort(Sorting $sorting): IDataSource
169	{
170	if (is_callable($sorting->getSortCallback())) {	×
NEW 171	throw new RuntimeException('No can do - not implemented yet');	×
172	}
173
174	foreach ($sorting->getSort() as $column => $order) {	×
175	$this->searchParamsBuilder->setSort(	×
176	[$column => ['order' => strtolower($order)]]	×
177	);
178	}
179
180	return $this;	×
181	}
182
183	protected function getDataSource(): SearchParamsBuilder
184	{
NEW 185	return $this->searchParamsBuilder;	×
186	}
187
188	}

contributte / datagrid / 8230347368

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