Lines 94.27% 214 / 227
Methods 90.24% 37 / 41
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] getEntityMapping 100.00% 27 / 27 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionArchiveId 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionScopeId 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionScopeIds 100.00% 6 / 6 100.00% 1 / 1 2
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionTime 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionTimes 100.00% 6 / 6 100.00% 1 / 1 2
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionIsMissed 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionWithAppointment 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addJoinStatisticFailed 100.00% 15 / 15 100.00% 1 / 1 1
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addValuesNewArchive 77.77% 21 / 27 0.00% 0 / 1 11.10
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] postProcess 100.00% 12 / 12 100.00% 1 / 1 6
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] getArchivedServices 83.33% 5 / 6 0.00% 0 / 1 3.04
 [BO\Zmsbackend\Process\Repository\ProcessStatusArchived] addConditionOlderThanDate 0.00% 0 / 2 0.00% 0 / 1 2
 [BO\Zmsbackend\Query\Base] __construct 88.23% 30 / 34 0.00% 0 / 1 10.16
 [BO\Zmsbackend\Query\Base] __toString n/a 0 / 0 n/a 0 / 0 4
 [BO\Zmsbackend\Query\Base] getName 100.00% 1 / 1 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] addSelect 100.00% 4 / 4 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] setDistinctSelect 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] setResolveLevel 100.00% 3 / 3 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] getResolveLevel 100.00% 3 / 3 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] getAlias 100.00% 5 / 5 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] getTablename 100.00% 3 / 3 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addTable 100.00% 4 / 4 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addTableAlias 100.00% 4 / 4 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addRequiredJoins 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addResolvedReferences 100.00% 11 / 11 100.00% 1 / 1 3
 [BO\Zmsbackend\Query\Base] setWithEntities 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addJoin 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] leftJoin 100.00% 5 / 5 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] innerJoin 100.00% 5 / 5 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] getSql 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] getParameters 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] getReferenceMapping 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] expression 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addEntityMapping 100.00% 3 / 3 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] getPrefixed 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] getPrefixedList 100.00% 4 / 4 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] addReferenceMapping 100.00% 3 / 3 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] addLimit 100.00% 4 / 4 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] addValues 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Query\Base] postProcessJoins 100.00% 4 / 4 100.00% 1 / 1 2
 [BO\Zmsbackend\Query\Base] shouldLoadEntity 100.00% 3 / 3 100.00% 1 / 1 2
10class ProcessStatusArchivedToday extends ProcessStatusArchived
11{
12    /**
13     *
14     * @var String TABLE mysql table reference
15     */
16    public const string TABLE = 'buergerarchivtoday';
17    const string DELETE_BEFORE_DATE = 'DELETE FROM buergerarchivtoday WHERE Datum < :theDay';
18}

Inherited from BO\Zmsbackend\Process\Repository\ProcessStatusArchived

40    public function getEntityMapping()
41    {
42        return [
43            'archiveId' => 'process.BuergerarchivID',
44            'status' => self::expression('"archived"'),
45            'appointments__0__date' => self::expression(
46                'CONCAT(`process`.`Datum`, " ", `process`.`Timestamp`)'
47            ),
48            'scope__id' => 'process.StandortID',
49            '__clientsCount' => 'process.AnzahlPersonen',
50            'waitingTime' => 'process.waiting_time',
51            'wayTime' => 'process.way_time',
52            'processingTime' => 'process.processing_time',
53            'name' => 'process.name',
54            'services' => 'process.dienstleistungen',
55            'queue__arrivalTime' => self::expression(
56                'CONCAT(`process`.`Datum`, " 00:00:00")'
57            ),
58            'queue__callTime' => self::expression(
59                'CONCAT(`process`.`Datum`, " ", SEC_TO_TIME(`waiting_time` * 60))'
60            ),
61            'queue__withAppointment' => 'process.mitTermin',
62            'withAppointment' => 'process.mitTermin',
63            'queue__status' => self::expression(
64                'IF(`process`.`nicht_erschienen`,
65                    "missed",
66                    "finished"
67                )'
68            ),
69            'isTicketprinter' => 'process.is_ticketprinter',
70        ];
71    }
73    public function addConditionArchiveId($archiveId): static
74    {
75        $this->query->where('process.BuergerarchivID', '=', $archiveId);
76        return $this;
77    }
79    public function addConditionScopeId($scopeId): static
80    {
81        $this->query->where('process.StandortID', '=', $scopeId);
82        return $this;
83    }
85    public function addConditionScopeIds($scopeIds): static
86    {
87        $this->query->where(function (\BO\Zmsbackend\Query\Builder\ConditionBuilder $condition) use ($scopeIds) {
88            foreach ($scopeIds as $scopeId) {
89                $condition
90                    ->orWith('process.StandortID', '=', $scopeId);
91            }
92        });
93        return $this;
94    }
97    public function addConditionTime(\DateTimeInterface $now): static
98    {
99        $this->query->where('process.Datum', '=', $now->format('Y-m-d'));
100        return $this;
101    }
106    public function addConditionTimes(array $dateTimes): static
107    {
108        $this->query->where(function (\BO\Zmsbackend\Query\Builder\ConditionBuilder $condition) use ($dateTimes) {
109            foreach ($dateTimes as $dateTime) {
110                $condition
111                    ->orWith('process.Datum', '=', $dateTime->format('Y-m-d'));
112            }
113        });
114        return $this;
115    }
117    public function addConditionIsMissed(int $missed): static
118    {
119        $this->query->where('process.nicht_erschienen', '=', $missed);
120        return $this;
121    }
123    public function addConditionWithAppointment(int $withAppointment): static
124    {
125        $this->query->where('process.mitTermin', '=', $withAppointment);
126        return $this;
127    }
129    public function addJoinStatisticFailed($dateTime, \BO\Zmsentities\Scope $scope): static
130    {
131        //use existing index with StandortID and Datum
132        $this->leftJoin(
133            new \BO\Zmsbackend\Query\Alias(self::STATISTIC_TABLE, 'statistic'),
134            self::expression('
135                statistic.StandortID = process.StandortID
136                AND statistic.Datum = process.Datum
137                AND `statistic`.`lastbuergerarchivid` = `process`.`BuergerarchivID`
138            ')
139        );
140        $this->query->where(function (\BO\Zmsbackend\Query\Builder\ConditionBuilder $query) use ($dateTime, $scope) {
141            $query->andWith(
142                self::expression('statistic.lastbuergerarchivid IS NULL AND process.Datum'),
143                '>',
144                $dateTime->format('Y-m-d')
145            );
146            $query->andWith('process.nicht_erschienen', '=', 0);
147            $query->andWith('process.StandortID', '=', $scope->id);
148        });
149        return $this;
150    }
151    public function addValuesNewArchive(\BO\Zmsentities\Process $process, \DateTimeInterface $now): void
152    {
153        $processingTimeStr = $process->getProcessingTime();
154        $bearbeitungszeit = null;
155
156        if (!empty($processingTimeStr)) {
157            list($hours, $minutes, $seconds) = explode(':', $processingTimeStr);
158            $totalMinutes = (double) ($hours * 60 + $minutes + $seconds / 60);
159            $bearbeitungszeit = $totalMinutes;
160        }
161
162        $waitingTimeStr = $process->getWaitingTime();
163        $warteZeit = null;
164
165        if (!empty($waitingTimeStr)) {
166            list($hours, $minutes, $seconds) = explode(':', $waitingTimeStr);
167            $totalMinutes = (double) ($hours * 60 + $minutes + $seconds / 60);
168            $warteZeit = $totalMinutes;
169        }
170
171        $isTicketprinter = isset($process->isTicketprinter) && $process->isTicketprinter ? 1 : 0;
172
173        $this->addValues([
174            'StandortID' => $process->scope['id'],
175            'name' => $process->getFirstClient()['familyName'],
176            'dienstleistungen' => $this->getArchivedServices($process),
177            'Datum' => $process->getFirstAppointment()->toDateTime()->format('Y-m-d'),
178            'mitTermin' => ($process->toQueue($now)->withAppointment) ? 1 : 0,
179            'nicht_erschienen' => ('missed' == $process->queue['status']) ? 1 : 0,
180            'Timestamp' => $process->getArrivalTime()->format('H:i:s'),
181            'waiting_time' => ($warteZeit > 0) ? $warteZeit : 0,
182            'way_time' => ($process->getWayMinutes() > 0) ? $process->getWayMinutes() : 0,
183            'processing_time' => ($bearbeitungszeit > 0) ? $bearbeitungszeit : 0,
184            'AnzahlPersonen' => $process->getClients()->count(),
185            'is_ticketprinter' => $isTicketprinter
186        ]);
187    }
190    public function postProcess($data)
191    {
192        $date = $data[$this->getPrefixed("appointments__0__date")] ?? '';
193        $data[$this->getPrefixed("appointments__0__date")] = strtotime($date === null ? '' : $date);
194        $callTime = $data[$this->getPrefixed("queue__callTime")] ?? '';
195        $data[$this->getPrefixed("queue__callTime")] = strtotime($callTime === null ? '' : $callTime);
196        $arrivalTime = $data[$this->getPrefixed("queue__arrivalTime")] ?? '';
197        $data[$this->getPrefixed("queue__arrivalTime")] = strtotime($arrivalTime === null ? '' : $arrivalTime);
198        if (isset($data[$this->getPrefixed('__clientsCount')])) {
199            $clientsCount = $data[$this->getPrefixed('__clientsCount')];
200            unset($data[$this->getPrefixed('__clientsCount')]);
201            while ($clientsCount-- > 0) {
202                $data[$this->getPrefixed('clients__' . $clientsCount . '__familyName')] = 'Unknown';
203            }
204        }
205        return $data;
206    }
208    private function getArchivedServices(\BO\Zmsentities\Process $process)
209    {
210        if ($process->getRequests()->count() === 0) {
211            return '';
212        }
213
214        $services = $process->getRequests()->getFirst()->name;
215
216        if ($process->getRequests()->count() > 1) {
217            $services .= ' +' . ($process->getRequests()->count() - 1);
218        }
219
220        return $services;
221    }
223    public function addConditionOlderThanDate(\DateTimeInterface $dateTime): static
224    {
225        // Assuming 'Datum' is the column name that holds the date of the record
226        // and you want to select records older than the specified $dateTime
227        $this->query->where('Datum', '<', $dateTime->format('Y-m-d'));
228        return $this;
229    }

Inherited from BO\Zmsbackend\Query\Base

96    public function __construct(
97        $queryType,
98        $prefix = '',
99        string|false $name = false,
100        mixed $resolveLevel = null,
101        array $withEntities = []
102    ) {
103        $this->prefix = $prefix;
104        $this->name = $name;
105        $this->withEntities = $withEntities;
106        $this->setResolveLevel($resolveLevel);
107        $dialect = new MySQL();
108        if (self::SELECT === $queryType) {
109            $this->query = new Select($dialect);
110            $this->addSelect();
111        } elseif (self::INSERT === $queryType) {
112            $this->query = new Insert($dialect);
113            $this->addTable();
114        } elseif (self::UPDATE === $queryType) {
115            $this->query = new Update($dialect);
116            $this->addTableAlias();
117        } elseif (self::REPLACE === $queryType) {
118            $this->query = new INSERT($dialect);
119            $this->query->queryBaseStatement('REPLACE INTO');
120            $this->addTable();
121        } elseif (self::DELETE === $queryType) {
122            $this->query = new Delete($dialect);
123            $this->query->queryBaseStatement('DELETE ' . $this::getAlias() . ' FROM');
124            $this->addTableAlias();
125        } elseif ($queryType instanceof self) {
126            $this->query = $queryType->query;
127            // Share join-alias state with the parent query (intentional by-ref).
128            /** @psalm-suppress UnsupportedPropertyReferenceUsage */
129            $this->joinedAliasList =& $queryType->joinedAliasList;
130            $this->resolveLevel = $queryType->resolveLevel - 1;
131        } elseif ($queryType instanceof QueryBuilder) {
132            $this->query = $queryType;
133        } else {
134            throw new \InvalidArgumentException(
135                'Unsupported query type for ' . static::class . ': '
136                . (is_object($queryType) ? $queryType::class : gettype($queryType))
137            );
138        }
139        if ($this->query instanceof Select) {
140            $this->addRequiredJoins();
141        }
142    }
147    public function __toString()
148    {
149        if ($this->name) {
150            $name = $this->name . '_' . $this->prefix . (string) $this->resolveLevel;
151            if (!isset(static::$sqlCache[$name])) {
152                static::$sqlCache[$name] = $this->getSql();
153            }
154            return static::$sqlCache[$name];
155        }
156        if ($this->currentSqlString) {
157            $sql = $this->currentSqlString;
158        } else {
159            $sql = $this->getSql();
160        }
161        return $sql;
162    }
164    public function getName()
165    {
166        return $this->name ? $this->name : get_class($this);
167    }
174    protected function addSelect(): static
175    {
176        $table = $this::getTablename();
177        $alias = $this::getAlias();
178        $this->query->from($table, $alias);
179        return $this;
180    }
182    public function setDistinctSelect(): void
183    {
184        $this->query->queryBaseStatement('SELECT DISTINCT');
185    }
187    public function setResolveLevel(int|null $resolveLevel): static
188    {
189        if ($resolveLevel !== null) {
190            $this->resolveLevel = $resolveLevel;
191        }
192        return $this;
193    }
195    public function getResolveLevel()
196    {
197        if (null === $this->resolveLevel) {
198            throw new \Exception("Required setting for resolveReferenceLevel missing in " . get_class($this));
199        }
200        return $this->resolveLevel;
201    }
210    public static function getAlias()
211    {
212        $class = get_called_class();
213        $alias = constant($class . '::ALIAS');
214        if (null === $alias) {
215            $alias = lcfirst(preg_replace('#^.*\\\#', '', $class));
216        }
217        return $alias;
218    }
225    public static function getTablename()
226    {
227        $class = get_called_class();
228        $table = constant($class . '::TABLE');
229        return $table;
230    }
237    protected function addTable(): static
238    {
239        $table = $this::getTablename();
240        $alias = $this::getAlias();
241        $this->query->table($table, $alias);
242        return $this;
243    }
250    protected function addTableAlias(): static
251    {
252        $table = $this::getTablename();
253        $alias = $this::getAlias();
254        $this->query->table(self::expression($table . ' ' . $alias));
255        return $this;
256    }
264    protected function addRequiredJoins()
265    {
266    }
273    public function addResolvedReferences($depth): static
274    {
275        $this->setResolveLevel($depth);
276        if ($depth > 0) {
277            $queryList = $this->addJoin();
278            foreach ($queryList as $query) {
279                $query->setResolveLevel($depth);
280                $query->setWithEntities($this->withEntities);
281                $query->addResolvedReferences($depth - 1);
282                $query->addEntityMapping();
283            }
284            $this->joinedQueryList = $queryList;
285        } else {
286            $this->addReferenceMapping();
287        }
288        return $this;
289    }
294    public function setWithEntities($withEntities = []): void
295    {
296        $this->withEntities = $withEntities;
297    }
304    protected function addJoin()
305    {
306        return [];
307    }
309    protected function leftJoin(Alias $alias, string|Expression|null $left = null, string|null $operator = null, string|null $right = null): QueryBuilder
310    {
311        $aliasId = $alias->getAliasIdentifier();
312        if (!in_array($aliasId, $this->joinedAliasList)) {
313            $this->joinedAliasList[] = $aliasId;
314            $this->query->leftJoin($alias, $left, $operator, $right);
315        } else {
316            //throw new \Exception("Tried to add Alias ".$aliasId);
317        }
318        return $this->query;
319    }
321    protected function innerJoin(Alias $alias, string|null $left = null, string|null $operator = null, string|null $right = null): QueryBuilder
322    {
323        $aliasId = $alias->getAliasIdentifier();
324        if (!in_array($aliasId, $this->joinedAliasList)) {
325            $this->joinedAliasList[] = $aliasId;
326            $this->query->join($alias, $left, $operator, $right);
327        }
328        return $this->query;
329    }
337    public function getSql()
338    {
339        $this->currentSqlString = (string)$this->query;
340        return $this->currentSqlString;
341    }
348    public function getParameters()
349    {
350        return $this->query->params();
351    }
357    public function getReferenceMapping()
358    {
359        return [
360        ];
361    }
368    protected static function expression(string $string)
369    {
370        return new Expression($string);
371    }
379    public function addEntityMapping(mixed $type = null): static
380    {
381        // Concrete query classes provide getEntityMapping(); not all declare MappingInterface.
382        /** @psalm-suppress UndefinedMethod, TooManyArguments */
383        $entityMapping = $this->getPrefixedList($this->getEntityMapping($type));
384        $this->query->select($entityMapping);
385        return $this;
386    }
388    protected function getPrefixed($prefix): string
389    {
390        return $this->prefix . $prefix;
391    }
393    protected function getPrefixedList(array $unprefixedList): array
394    {
395        $prefixed = [];
396        foreach ($unprefixedList as $key => $value) {
397            $prefixed[$this->getPrefixed($key)] = $value;
398        }
399        return $prefixed;
400    }
405    protected function addReferenceMapping(): static
406    {
407        $referenceMapping = $this->getPrefixedList($this->getReferenceMapping());
408        $this->query->select($referenceMapping);
409        return $this;
410    }
412    public function addLimit(int $count, ?int $offset = null): static
413    {
414        $this->query->limit($count);
415        if ($offset) {
416            $this->query->offset($offset);
417        }
418        return $this;
419    }
424    public function addValues(array $values): static
425    {
426        $this->query->values($values);
427        return $this;
428    }
445    public function postProcessJoins(array $data)
446    {
447        $data = $this->postProcess($data);
448        foreach ($this->joinedQueryList as $query) {
449            $data = $query->postProcess($data);
450        }
451        return $data;
452    }
454    public function shouldLoadEntity(string $name): bool
455    {
456        if (empty($this->withEntities)) {
457            return true;
458        }
459
460        return in_array($name, $this->withEntities);
461    }