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

12.73

/src/AggregationFunction/TDatagridAggregationFunction.php

<?php declare(strict_types = 1);

namespace Contributte\Datagrid\AggregationFunction;

use Contributte\Datagrid\DataModel;
use Contributte\Datagrid\DataSource\IDataSource;
use Contributte\Datagrid\Exception\DatagridException;

trait TDatagridAggregationFunction
{

        /** @var array|ISingleColumnAggregationFunction[] */
        private array $aggregationFunctions = [];

        private ?IMultipleAggregationFunction $multipleAggregationFunction = null;

        /**
         * @return static
         * @throws DatagridException
         */
        public function addAggregationFunction(
                string $key,
                ISingleColumnAggregationFunction $aggregationFunction
        ): self
        {
                if ($this->hasColumnsSummary()) {
                        throw new DatagridException('You can use either ColumnsSummary or AggregationFunctions');
                }

                if (!$this->dataModel instanceof DataModel) {
                        throw new DatagridException('You have to set a data source first.');
                }

                if (isset($this->aggregationFunctions[$key])) {
                        throw new DatagridException('There is already a AggregationFunction defined on column ' . $key);
                }

                if ($this->multipleAggregationFunction instanceof IMultipleAggregationFunction) {
                        throw new DatagridException('You can not use both AggregationFunctions and MultipleAggregationFunction');
                }

                $this->aggregationFunctions[$key] = $aggregationFunction;

                return $this;
        }

        /**
         * @return static
         * @throws DatagridException
         */
        public function setMultipleAggregationFunction(
                IMultipleAggregationFunction $multipleAggregationFunction
        ): self
        {
                if ($this->hasColumnsSummary()) {
                        throw new DatagridException('You can use either ColumnsSummary or AggregationFunctions');
                }

                if ($this->aggregationFunctions !== []) {
                        throw new DatagridException('You can not use both AggregationFunctions and MultipleAggregationFunction');
                }

                $this->multipleAggregationFunction = $multipleAggregationFunction;

                return $this;
        }

        /**
         * @throws DatagridException
         */
        public function beforeDataModelFilter(IDataSource $dataSource): void
        {
                if (!$this->hasSomeAggregationFunction()) {
                        return;
                }

                if (!$dataSource instanceof IAggregatable) {
                        throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');
                }

                if ($this->multipleAggregationFunction !== null) {
                        $type = $this->multipleAggregationFunction->getFilterDataType();

                        if ($type === IAggregationFunction::DATA_TYPE_ALL) {
                                $dataSource->processAggregation($this->multipleAggregationFunction);
                        }

                        return;
                }

                foreach ($this->aggregationFunctions as $aggregationFunction) {
                        if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_ALL) {
                                $dataSource->processAggregation($aggregationFunction);
                        }
                }
        }

        /**
         * @throws DatagridException
         */
        public function afterDataModelFilter(IDataSource $dataSource): void
        {
                if (!$this->hasSomeAggregationFunction()) {
                        return;
                }

                if (!$dataSource instanceof IAggregatable) {
                        throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');
                }

                if ($this->multipleAggregationFunction !== null) {
                        if ($this->multipleAggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_FILTERED) {
                                $dataSource->processAggregation($this->multipleAggregationFunction);
                        }

                        return;
                }

                foreach ($this->aggregationFunctions as $aggregationFunction) {
                        if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_FILTERED) {
                                $dataSource->processAggregation($aggregationFunction);
                        }
                }
        }

        /**
         * @throws DatagridException
         */
        public function afterDataModelPaginated(IDataSource $dataSource): void
        {
                if (!$this->hasSomeAggregationFunction()) {
                        return;
                }

                if (!$dataSource instanceof IAggregatable) {
                        throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');
                }

                if ($this->multipleAggregationFunction !== null) {
                        if ($this->multipleAggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_PAGINATED) {
                                $dataSource->processAggregation($this->multipleAggregationFunction);
                        }

                        return;
                }

                foreach ($this->aggregationFunctions as $aggregationFunction) {
                        if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_PAGINATED) {
                                $dataSource->processAggregation($aggregationFunction);
                        }
                }
        }

        public function hasSomeAggregationFunction(): bool
        {
                return $this->aggregationFunctions !== [] || $this->multipleAggregationFunction !== null;
        }

        /**
         * @return array<ISingleColumnAggregationFunction>
         */
        public function getAggregationFunctions(): array
        {
                return $this->aggregationFunctions;
        }

        public function getMultipleAggregationFunction(): ?IMultipleAggregationFunction
        {
                return $this->multipleAggregationFunction;
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\Datagrid\AggregationFunction;
4
5	use Contributte\Datagrid\DataModel;
6	use Contributte\Datagrid\DataSource\IDataSource;
7	use Contributte\Datagrid\Exception\DatagridException;
8
9	trait TDatagridAggregationFunction
10	{
11
12	/** @var array\|ISingleColumnAggregationFunction[] */
13	private array $aggregationFunctions = [];
14
15	private ?IMultipleAggregationFunction $multipleAggregationFunction = null;
16
17	/**
18	* @return static
19	* @throws DatagridException
20	*/
21	public function addAggregationFunction(
22	string $key,
23	ISingleColumnAggregationFunction $aggregationFunction
24	): self
25	{
26	if ($this->hasColumnsSummary()) {	×
NEW 27	throw new DatagridException('You can use either ColumnsSummary or AggregationFunctions');	×
28	}
29
30	if (!$this->dataModel instanceof DataModel) {	×
NEW 31	throw new DatagridException('You have to set a data source first.');	×
32	}
33
34	if (isset($this->aggregationFunctions[$key])) {	×
NEW 35	throw new DatagridException('There is already a AggregationFunction defined on column ' . $key);	×
36	}
37
38	if ($this->multipleAggregationFunction instanceof IMultipleAggregationFunction) {	×
NEW 39	throw new DatagridException('You can not use both AggregationFunctions and MultipleAggregationFunction');	×
40	}
41
42	$this->aggregationFunctions[$key] = $aggregationFunction;	×
43
44	return $this;	×
45	}
46
47	/**
48	* @return static
49	* @throws DatagridException
50	*/
51	public function setMultipleAggregationFunction(
52	IMultipleAggregationFunction $multipleAggregationFunction
53	): self
54	{
55	if ($this->hasColumnsSummary()) {	×
NEW 56	throw new DatagridException('You can use either ColumnsSummary or AggregationFunctions');	×
57	}
58
59	if ($this->aggregationFunctions !== []) {	×
NEW 60	throw new DatagridException('You can not use both AggregationFunctions and MultipleAggregationFunction');	×
61	}
62
63	$this->multipleAggregationFunction = $multipleAggregationFunction;	×
64
65	return $this;	×
66	}
67
68	/**
69	* @throws DatagridException
70	*/
71	public function beforeDataModelFilter(IDataSource $dataSource): void	1✔
72	{
73	if (!$this->hasSomeAggregationFunction()) {	1✔
74	return;	1✔
75	}
76
77	if (!$dataSource instanceof IAggregatable) {	×
NEW 78	throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');	×
79	}
80
81	if ($this->multipleAggregationFunction !== null) {	×
82	$type = $this->multipleAggregationFunction->getFilterDataType();	×
83
84	if ($type === IAggregationFunction::DATA_TYPE_ALL) {	×
85	$dataSource->processAggregation($this->multipleAggregationFunction);	×
86	}
87
88	return;	×
89	}
90
91	foreach ($this->aggregationFunctions as $aggregationFunction) {	×
92	if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_ALL) {	×
93	$dataSource->processAggregation($aggregationFunction);	×
94	}
95	}
96	}
97
98	/**
99	* @throws DatagridException
100	*/
101	public function afterDataModelFilter(IDataSource $dataSource): void	1✔
102	{
103	if (!$this->hasSomeAggregationFunction()) {	1✔
104	return;	1✔
105	}
106
107	if (!$dataSource instanceof IAggregatable) {	×
NEW 108	throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');	×
109	}
110
111	if ($this->multipleAggregationFunction !== null) {	×
112	if ($this->multipleAggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_FILTERED) {	×
113	$dataSource->processAggregation($this->multipleAggregationFunction);	×
114	}
115
116	return;	×
117	}
118
119	foreach ($this->aggregationFunctions as $aggregationFunction) {	×
120	if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_FILTERED) {	×
121	$dataSource->processAggregation($aggregationFunction);	×
122	}
123	}
124	}
125
126	/**
127	* @throws DatagridException
128	*/
129	public function afterDataModelPaginated(IDataSource $dataSource): void
130	{
131	if (!$this->hasSomeAggregationFunction()) {	×
132	return;	×
133	}
134
135	if (!$dataSource instanceof IAggregatable) {	×
NEW 136	throw new DatagridException('Used DataSource has to implement IAggregatable for aggegations to work');	×
137	}
138
139	if ($this->multipleAggregationFunction !== null) {	×
140	if ($this->multipleAggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_PAGINATED) {	×
141	$dataSource->processAggregation($this->multipleAggregationFunction);	×
142	}
143
144	return;	×
145	}
146
147	foreach ($this->aggregationFunctions as $aggregationFunction) {	×
148	if ($aggregationFunction->getFilterDataType() === IAggregationFunction::DATA_TYPE_PAGINATED) {	×
149	$dataSource->processAggregation($aggregationFunction);	×
150	}
151	}
152	}
153
154	public function hasSomeAggregationFunction(): bool
155	{
156	return $this->aggregationFunctions !== [] \|\| $this->multipleAggregationFunction !== null;	1✔
157	}
158
159	/**
160	* @return array<ISingleColumnAggregationFunction>
161	*/
162	public function getAggregationFunctions(): array
163	{
164	return $this->aggregationFunctions;	×
165	}
166
167	public function getMultipleAggregationFunction(): ?IMultipleAggregationFunction
168	{
169	return $this->multipleAggregationFunction;	×
170	}
171
172	}

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