Lines 94.81% 183 / 193
Methods 88.23% 30 / 34
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 buildCapacityMetricsQuery 85.00% 17 / 20 0.00% 0 / 1 3.03
 buildScopeSlotTimeQuery 100.00% 7 / 7 100.00% 1 / 1 1
 slotFilterSql 90.90% 10 / 11 0.00% 0 / 1 3.01
 scopeInClause 100.00% 6 / 6 100.00% 1 / 1 2
 monthRangeSql 93.75% 30 / 32 0.00% 0 / 1 5.01
 [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] postProcess 100.00% 1 / 1 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
5class ExchangeCapacityscope extends \BO\Zmsbackend\Query\Base
6{
7    /**
8     * @var String TABLE mysql table reference
9     */
10    const string TABLE = 'slot_process';
11
12    /**
13     * Scope picker list. Min/max dates are index lookups per scope, not a scan of every slot.
14     */
15    const string QUERY_CAPACITY_REPORT_SCOPE_SUBJECT_LIST = '
16      SELECT
17          scope.`StandortID` as subject,
18          (
19              SELECT CONCAT(s.year, "-", LPAD(s.month, 2, "0"), "-", LPAD(s.day, 2, "0"))
20              FROM slot AS s
21              WHERE s.scopeID = scope.`StandortID`
22              ORDER BY s.year, s.month, s.day
23              LIMIT 1
24          ) AS periodstart,
25          (
26              SELECT CONCAT(s.year, "-", LPAD(s.month, 2, "0"), "-", LPAD(s.day, 2, "0"))
27              FROM slot AS s
28              WHERE s.scopeID = scope.`StandortID`
29              ORDER BY s.year DESC, s.month DESC, s.day DESC
30              LIMIT 1
31          ) AS periodend,
32          CONCAT(scope.`Bezeichnung`, " ", scope.`standortinfozeile`) AS description
33      FROM ' . \BO\Zmsbackend\Query\Scope::TABLE . ' AS scope
34      HAVING periodstart IS NOT NULL
35      ORDER BY description ASC
36    ';
37
38    /**
39     * Planned totals from slot, booked totals from appointments on those slots.
40     * All scopes are one statement. Bookings are reached from those slots, not from every row in slot_process.
41     *
42     * @param array<int, int> $scopeIds
43     * @param array<string, int> $parameters
44     */
45    public static function buildCapacityMetricsQuery(
46        array $scopeIds,
47        ?\DateTimeInterface $dateStart,
48        ?\DateTimeInterface $dateEnd,
49        string $period,
50        array &$parameters
51    ): string {
52        $parameters = [];
53        $plannedFilter = self::slotFilterSql('s', 'o', $scopeIds, $dateStart, $dateEnd, $parameters);
54        $bookedFilter = self::slotFilterSql('s', 'i', $scopeIds, $dateStart, $dateEnd, $parameters);
55        $hourly = $period === 'hour';
56        $dateExpression = $hourly
57            ? 'CONCAT(s.year, "-", LPAD(s.month, 2, "0"), "-", LPAD(s.day, 2, "0"), " ", '
58                . 'LPAD(HOUR(s.`time`), 2, "0"), ":00")'
59            : 'CONCAT(s.year, "-", LPAD(s.month, 2, "0"), "-", LPAD(s.day, 2, "0"))';
60        $groupBy = $hourly
61            ? 's.scopeID, s.year, s.month, s.day, HOUR(s.`time`)'
62            : 's.scopeID, s.year, s.month, s.day';
63
64        return '
65        SELECT
66            planned.subjectid,
67            planned.date,
68            COALESCE(booked.slotcount, 0),
69            planned.plannedcount,
70            COALESCE(booked.bookedminutes, 0),
71            planned.plannedminutes,
72            COALESCE(booked.slotcount_public, 0),
73            planned.plannedpublic,
74            COALESCE(booked.bookedminutes_public, 0),
75            planned.plannedminutes_public
76        FROM (
77            SELECT
78                s.scopeID as subjectid,
79                ' . $dateExpression . ' as date,
80                SUM(s.intern) as plannedcount,
81                SUM(COALESCE(s.intern, 0) * COALESCE(s.slotTimeInMinutes, 0)) as plannedminutes,
82                SUM(s.`public`) as plannedpublic,
83                SUM(COALESCE(s.`public`, 0) * COALESCE(s.slotTimeInMinutes, 0)) as plannedminutes_public
84            FROM slot AS s
85            WHERE ' . $plannedFilter . '
86            GROUP BY ' . $groupBy . '
87        ) AS planned
88        LEFT JOIN (
89            SELECT
90                s.scopeID as subjectid,
91                ' . $dateExpression . ' as date,
92                COUNT(*) as slotcount,
93                SUM(COALESCE(s.slotTimeInMinutes, 0)) as bookedminutes,
94                SUM(CASE WHEN ac.accesslevel = "public" THEN 1 ELSE 0 END) as slotcount_public,
95                SUM(CASE WHEN ac.accesslevel = "public" THEN COALESCE(s.slotTimeInMinutes, 0) ELSE 0 END)
96                    as bookedminutes_public
97            FROM slot AS s
98            STRAIGHT_JOIN slot_process AS sp ON sp.slotID = s.slotID
99            LEFT JOIN buerger b ON sp.processID = b.BuergerID
100            LEFT JOIN apiclient ac ON b.apiClientID = ac.apiClientID
101            WHERE ' . $bookedFilter . '
102            GROUP BY ' . $groupBy . '
103        ) AS booked ON booked.subjectid = planned.subjectid AND booked.date = planned.date
104        ORDER BY planned.date ASC, FIELD(planned.subjectid, ' . implode(', ', array_map('intval', $scopeIds)) . ')
105        ';
106    }
107
108    /**
109     * Distinct slot lengths in the same range, for the duration hint.
110     *
111     * @param array<int, int> $scopeIds
112     * @param array<string, int> $parameters
113     */
114    public static function buildScopeSlotTimeQuery(
115        array $scopeIds,
116        ?\DateTimeInterface $dateStart,
117        ?\DateTimeInterface $dateEnd,
118        array &$parameters
119    ): string {
120        $parameters = [];
121        $filter = self::slotFilterSql('s', 't', $scopeIds, $dateStart, $dateEnd, $parameters);
122
123        return '
124            SELECT
125                s.scopeID as subjectid,
126                s.slotTimeInMinutes as slotminutes,
127                TRIM(CONCAT(IFNULL(scopeprovider.name, ""), " ", IFNULL(scope.standortkuerzel, ""))) as scopename
128            FROM slot AS s
129            INNER JOIN ' . \BO\Zmsbackend\Query\Scope::TABLE . ' AS scope
130                ON scope.StandortID = s.scopeID
131            LEFT JOIN ' . \BO\Zmsbackend\Provider\Repository\Provider::TABLE . ' AS scopeprovider
132                ON scope.InfoDienstleisterID = scopeprovider.id
133                AND scope.source = scopeprovider.source
134            WHERE ' . $filter . '
135            GROUP BY s.scopeID, s.slotTimeInMinutes, scopename
136        ';
137    }
138
139    /**
140     * @param array<int, int> $scopeIds
141     * @param array<string, int> $parameters
142     */
143    private static function slotFilterSql(
144        string $alias,
145        string $parameterPrefix,
146        array $scopeIds,
147        ?\DateTimeInterface $dateStart,
148        ?\DateTimeInterface $dateEnd,
149        array &$parameters
150    ): string {
151        $filter = self::scopeInClause($alias, $parameterPrefix, $scopeIds, $parameters)
152            . ' AND ' . $alias . '.status = "free"';
153
154        if ($dateStart === null || $dateEnd === null) {
155            return $filter;
156        }
157
158        return $filter . ' AND (' . self::monthRangeSql(
159            $alias,
160            $parameterPrefix,
161            $dateStart,
162            $dateEnd,
163            $parameters
164        ) . ')';
165    }
166
167    /**
168     * @param array<int, int> $scopeIds
169     * @param array<string, int> $parameters
170     */
171    private static function scopeInClause(
172        string $alias,
173        string $parameterPrefix,
174        array $scopeIds,
175        array &$parameters
176    ): string {
177        $placeholders = [];
178        foreach (array_values($scopeIds) as $index => $scopeId) {
179            $name = $parameterPrefix . 'scope' . $index;
180            $parameters[$name] = $scopeId;
181            $placeholders[] = ':' . $name;
182        }
183
184        return $alias . '.scopeID IN (' . implode(', ', $placeholders) . ')';
185    }
186
187    /**
188     * @param array<string, int> $parameters
189     */
190    private static function monthRangeSql(
191        string $alias,
192        string $parameterPrefix,
193        \DateTimeInterface $dateStart,
194        \DateTimeInterface $dateEnd,
195        array &$parameters
196    ): string {
197        $start = \DateTimeImmutable::createFromInterface($dateStart)->setTime(0, 0);
198        $end = \DateTimeImmutable::createFromInterface($dateEnd)->setTime(0, 0);
199        if ($end < $start) {
200            return '0';
201        }
202
203        $clauses = [];
204        $cursor = $start->modify('first day of this month');
205        $lastMonth = $end->modify('first day of this month');
206        $index = 0;
207        while ($cursor <= $lastMonth) {
208            $dayStart = $cursor->format('Y-m') === $start->format('Y-m') ? (int) $start->format('j') : 1;
209            $dayEnd = $cursor->format('Y-m') === $end->format('Y-m')
210                ? (int) $end->format('j')
211                : (int) $cursor->format('t');
212            $yearKey = $parameterPrefix . 'y' . $index;
213            $monthKey = $parameterPrefix . 'm' . $index;
214            $dayStartKey = $parameterPrefix . 'ds' . $index;
215            $dayEndKey = $parameterPrefix . 'de' . $index;
216            $parameters[$yearKey] = (int) $cursor->format('Y');
217            $parameters[$monthKey] = (int) $cursor->format('n');
218            $parameters[$dayStartKey] = $dayStart;
219            $parameters[$dayEndKey] = $dayEnd;
220            $clauses[] = sprintf(
221                '(%1$s.year = :%2$s AND %1$s.month = :%3$s AND %1$s.day BETWEEN :%4$s AND :%5$s)',
222                $alias,
223                $yearKey,
224                $monthKey,
225                $dayStartKey,
226                $dayEndKey
227            );
228            $cursor = $cursor->modify('+1 month');
229            $index++;
230        }
231
232        return implode(' OR ', $clauses);
233    }
234}

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    }
434    public function postProcess($data)
435    {
436        return $data;
437    }
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    }