Lines 87.15% 251 / 288
Methods 75.75% 25 / 33
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 writeHistoryEntry 84.21% 16 / 19 0.00% 0 / 1 4.06
 existsByHistoryKey 100.00% 8 / 8 100.00% 1 / 1 1
 readFullyResolvedProcess 71.42% 15 / 21 0.00% 0 / 1 4.37
 buildHistoryEntryData 100.00% 45 / 45 100.00% 1 / 1 1
 createHistoryKey 77.77% 14 / 18 0.00% 0 / 1 4.18
 buildServiceNames 83.33% 10 / 12 0.00% 0 / 1 4.07
 getScope 100.00% 1 / 1 100.00% 1 / 1 1
 dateTimeFromTimestamp 100.00% 4 / 4 100.00% 1 / 1 2
 getNullableString 100.00% 2 / 2 100.00% 1 / 1 2
 validateStatus 100.00% 11 / 11 100.00% 1 / 1 2
 isDuplicateKeyException 0.00% 0 / 5 0.00% 0 / 1 6
 getAppointmentAt 40.00% 4 / 10 0.00% 0 / 1 2.86
 getScopeId 33.33% 3 / 9 0.00% 0 / 1 3.19
 deleteOlderThan 100.00% 6 / 6 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] __construct 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] init 100.00% 2 / 2 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] getWriter 100.00% 4 / 4 100.00% 1 / 1 2
 [BO\Zmsbackend\Base] getReader 100.00% 5 / 5 100.00% 1 / 1 3
 [BO\Zmsbackend\Base] fetchPreparedStatement 100.00% 9 / 9 100.00% 1 / 1 3
 [BO\Zmsbackend\Base] startExecute 100.00% 5 / 5 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] pdoExceptionHandler 100.00% 13 / 13 100.00% 1 / 1 4
 [BO\Zmsbackend\Base] fetchStatement 100.00% 3 / 3 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchOne 100.00% 7 / 7 100.00% 1 / 1 2
 [BO\Zmsbackend\Base] fetchRow 100.00% 7 / 7 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchValue 100.00% 7 / 7 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchAll 100.00% 7 / 7 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchHandle 100.00% 5 / 5 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchList 100.00% 8 / 8 100.00% 1 / 1 2
 [BO\Zmsbackend\Base] writeItem 100.00% 7 / 7 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] deleteItem 100.00% 1 / 1 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] perform 100.00% 7 / 7 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] fetchAffected 100.00% 8 / 8 100.00% 1 / 1 1
 [BO\Zmsbackend\Base] readResolvedReferences n/a 0 / 0 n/a 0 / 0 1
 [BO\Zmsbackend\Base] hashStringValue 50.00% 5 / 10 0.00% 0 / 1 8.12
12class ProcessSearchHistory extends \BO\Zmsbackend\Base
13{
14    public const string STATUS_COMPLETED = 'completed';
15    public const string STATUS_MISSED = 'missed';
16    public const string STATUS_CANCELLED_BY_CITIZEN = 'cancelled_citizen';
17    public const string STATUS_CANCELLED_BY_STAFF = 'cancelled_staff';
18
19    private const array SUPPORTED_STATUSES = [
20        self::STATUS_COMPLETED,
21        self::STATUS_MISSED,
22        self::STATUS_CANCELLED_BY_CITIZEN,
23        self::STATUS_CANCELLED_BY_STAFF,
24    ];
25
26    private const int RESOLVE_REFERENCES = 2;
27    private const int DUPLICATE_KEY_ERROR_CODE = 1062;
28
29    /**
30     * Bei einem bereits vorhandenen history_key wird kein zweiter
31     * Datensatz angelegt. In beiden Fällen wird der history_key
32     * zurückgegeben.
33     */
34    public function writeHistoryEntry(
35        ProcessEntity $process,
36        string $status,
37        \DateTimeInterface $finalizedAt
38    ): string {
39        $this->validateStatus($status);
40
41        $process = $this->readFullyResolvedProcess($process);
42        $historyKey = $this->createHistoryKey($process);
43
44        if ($this->existsByHistoryKey($historyKey)) {
45            return $historyKey;
46        }
47
48        $query = new HistoryRepository(QueryBase::INSERT);
49        $query->addValuesNewHistory(
50            $this->buildHistoryEntryData(
51                $process,
52                $historyKey,
53                $status,
54                $finalizedAt
55            )
56        );
57
58        try {
59            $this->writeItem($query);
60        } catch (PDOFailed $exception) {
61            if (!$this->isDuplicateKeyException($exception)) {
62                throw $exception;
63            }
64        }
65
66        return $historyKey;
67    }
68
69    public function existsByHistoryKey(string $historyKey): bool
70    {
71        $query = new HistoryRepository(QueryBase::SELECT);
72        $query
73            ->addCountValue()
74            ->addConditionHistoryKey($historyKey);
75
76        return (int) $this->fetchValue(
77            $query,
78            $query->getParameters()
79        ) > 0;
80    }
81
82    private function readFullyResolvedProcess(
83        ProcessEntity $process
84    ): ProcessEntity {
85        if (!$process->hasProcessCredentials()) {
86            throw new \InvalidArgumentException(
87                'Process id and authKey are required for the history snapshot.'
88            );
89        }
90
91        $processService = new ProcessService(
92            $this->getWriter(),
93            $this->getReader()
94        );
95
96        $resolvedProcess = $processService->readEntity(
97            $process->getId(),
98            $process->getAuthKey(),
99            self::RESOLVE_REFERENCES
100        );
101
102        if ($resolvedProcess === null || !$resolvedProcess->hasId()) {
103            throw new \RuntimeException(
104                sprintf(
105                    'Process %d could not be loaded for the history snapshot.',
106                    $process->getId()
107                )
108            );
109        }
110
111        return $resolvedProcess;
112    }
113
114    private function buildHistoryEntryData(
115        ProcessEntity $process,
116        string $historyKey,
117        string $status,
118        \DateTimeInterface $finalizedAt
119    ): array {
120        $client = $process->getFirstClient();
121        $scope = $this->getScope($process);
122
123        return [
124            'historyKey' => $historyKey,
125
126            'processId' => (int) $process->getId(),
127            'scopeId' => $this->getScopeId($process),
128            'displayNumber' => $this->getNullableString(
129                $process->getDisplayNumber()
130            ),
131
132            'appointmentAt' => $this->getAppointmentAt($process),
133            'bookedAt' => $this->dateTimeFromTimestamp(
134                (int) $process['createTimestamp']
135            ),
136            'calledAt' => $this->dateTimeFromTimestamp(
137                (int) $process
138                    ->toProperty()
139                    ->queue
140                    ->callTime
141                    ->get(0)
142            ),
143
144            'finalizedAt' => $finalizedAt,
145            'status' => $status,
146
147            'citizenName' => (string) $client
148                ->toProperty()
149                ->familyName
150                ->get(''),
151
152            'telephone' => (string) $client
153                ->toProperty()
154                ->telephone
155                ->get(''),
156
157            'citizenEmail' => (string) $client
158                ->toProperty()
159                ->email
160                ->get(''),
161
162            'amendment' => $this->getNullableString(
163                $process->getAmendment()
164            ),
165
166            'locationName' => trim(
167                (string) $scope->getShortName()
168            ),
169
170            'providerName' => trim(
171                (string) $scope->getProvider()->getName()
172            ),
173
174            'services' => $this->buildServiceNames($process),
175        ];
176    }
177
178    private function createHistoryKey(
179        ProcessEntity $process
180    ): string {
181        $processId = (int) $process->getId();
182        $createTimestamp = (int) $process['createTimestamp'];
183        $authKey = (string) $process->getAuthKey();
184
185        if (
186            $processId <= 0
187            || $createTimestamp <= 0
188            || $authKey === ''
189        ) {
190            throw new \InvalidArgumentException(
191                'Process id, createTimestamp and authKey are required '
192                . 'to create the history key.'
193            );
194        }
195
196        return hash(
197            'sha256',
198            $processId
199                . '|'
200                . $createTimestamp
201                . '|'
202                . $authKey
203        );
204    }
205
206    private function buildServiceNames(
207        ProcessEntity $process
208    ): ?string {
209        $serviceNames = [];
210
211        foreach ($process->getRequests() as $request) {
212            $serviceName = trim((string) $request->getName());
213
214            if ($serviceName === '') {
215                continue;
216            }
217
218            $serviceNames[$serviceName] = true;
219        }
220
221        if ($serviceNames === []) {
222            return null;
223        }
224
225        return implode(
226            "\n",
227            array_keys($serviceNames)
228        );
229    }
230
231    private function getScope(
232        ProcessEntity $process
233    ): ScopeEntity {
234        return $process->getCurrentScope();
235    }
236
237    private function dateTimeFromTimestamp(
238        int $timestamp
239    ): ?\DateTimeImmutable {
240        if ($timestamp <= 0) {
241            return null;
242        }
243
244        return (new \DateTimeImmutable())
245            ->setTimestamp($timestamp);
246    }
247
248    private function getNullableString(
249        mixed $value
250    ): ?string {
251        $value = trim((string) $value);
252
253        return $value !== '' ? $value : null;
254    }
255
256    private function validateStatus(string $status): void
257    {
258        if (
259            !in_array(
260                $status,
261                self::SUPPORTED_STATUSES,
262                true
263            )
264        ) {
265            throw new \InvalidArgumentException(
266                sprintf(
267                    'Unsupported process search history status "%s".',
268                    $status
269                )
270            );
271        }
272    }
273
274    private function isDuplicateKeyException(
275        PDOFailed $exception
276    ): bool {
277        $previous = $exception->getPrevious();
278
279        if (!$previous instanceof \PDOException) {
280            return false;
281        }
282
283        return (int) ($previous->errorInfo[1] ?? 0)
284            === self::DUPLICATE_KEY_ERROR_CODE;
285    }
286
287    private function getAppointmentAt(
288        ProcessEntity $process
289    ): \DateTimeImmutable {
290        $appointment = $process->getFirstAppointment();
291        $timestamp = $appointment->toDateTime()->getTimestamp();
292
293        if ($timestamp <= 0) {
294            throw new \InvalidArgumentException(
295                sprintf(
296                    'Process %d has no valid appointment date.',
297                    $process->getId()
298                )
299            );
300        }
301
302        return $appointment->toDateTime();
303    }
304
305    private function getScopeId(ProcessEntity $process): int
306    {
307        $scopeId = (int) $process->getScopeId();
308
309        if ($scopeId <= 0) {
310            throw new \InvalidArgumentException(
311                sprintf(
312                    'Process %d has no valid scope.',
313                    $process->getId()
314                )
315            );
316        }
317
318        return $scopeId;
319    }
320
321    public function deleteOlderThan(
322        \DateTimeInterface $dateTime
323    ): bool {
324        $query = new
325            \BO\Zmsbackend\ProcessSearchHistory\Repository\ProcessSearchHistory(
326                \BO\Zmsbackend\Query\Base::DELETE
327            );
328
329        $query->addConditionOlderThan($dateTime);
330
331        return $this->deleteItem($query);
332    }
333}

Inherited from BO\Zmsbackend\Base

38    public function __construct(?Connection\Pdo $writeConnection = null, ?Connection\Pdo $readConnection = null)
39    {
40        $this->writeDb = $writeConnection;
41        $this->readDb = $readConnection;
42    }
44    public static function init(?Connection\Pdo $writeConnection = null, ?Connection\Pdo $readConnection = null): static
45    {
46        $instance = new static($writeConnection, $readConnection);
47        return $instance;
48    }
50    public function getWriter(): Connection\Pdo
51    {
52        if (null === $this->writeDb) {
53            $this->writeDb = Connection\Select::getWriteConnection();
54            $this->readDb = $this->writeDb;
55        }
56        return $this->writeDb;
57    }
59    public function getReader(): Connection\Pdo
60    {
61        if (null !== $this->writeDb) {
62            // if readDB gets a reset, still use writeDB
63            return $this->writeDb;
64        }
65        if (null === $this->readDb) {
66            $this->readDb = Connection\Select::getReadConnection();
67        }
68        return $this->readDb;
69    }
71    public function fetchPreparedStatement(Query\Base|string $query)
72    {
73        $sql = "$query";
74        $reader = $this->getReader();
75        if (spl_object_hash($reader) != static::$preparedConnectionId) {
76            // do not use prepared statements on a different connection
77            static::$preparedCache = [];
78            static::$preparedConnectionId = spl_object_hash($reader);
79        }
80        if (!isset(static::$preparedCache[$sql])) {
81            $prepared = $this->getReader()->prepare($sql);
82            static::$preparedCache[$sql] = $prepared;
83        }
84        return static::$preparedCache[$sql];
85    }
87    public function startExecute($statement, array $parameters)
88    {
89        $statement = static::pdoExceptionHandler(function () use ($statement, $parameters) {
90            $statement->execute($parameters);
91            return $statement;
92        });
93        return $statement;
94    }
96    protected static function pdoExceptionHandler(\Closure $pdoFunction, $parameters = [])
97    {
98        try {
99            $statement = $pdoFunction($parameters);
100        } catch (\PDOException $pdoException) {
101            if (stripos($pdoException->getMessage(), 'Lock wait timeout') !== false) {
102                throw new \BO\Zmsbackend\Exception\Pdo\LockTimeout();
103            }
104            //@codeCoverageIgnoreStart
105            if (stripos($pdoException->getMessage(), 'Deadlock found') !== false) {
106                throw new \BO\Zmsbackend\Exception\Pdo\DeadLockFound();
107            }
108            //@codeCoverageIgnoreEnd
109            $message = "SQL: "
110                . " Err: "
111                . $pdoException->getMessage()
112                //. " || Statement: "
113                //.$statement->queryString
114                //." || Parameters=". var_export($parameters, true)
115                ;
116            throw new \BO\Zmsbackend\Exception\Pdo\PDOFailed($message, 0, $pdoException);
117        }
118        return $statement;
119    }
121    public function fetchStatement(Query\Base $query)
122    {
123        $parameters = $query->getParameters();
124        $statement = $this->startExecute($this->fetchPreparedStatement($query), $parameters);
125        return $statement;
126    }
133    public function fetchOne(Query\Base $query, \BO\Zmsentities\Schema\Entity $entity)
134    {
135        $statement = $this->fetchStatement($query);
136        $data = $statement->fetch(\PDO::FETCH_ASSOC);
137        if ($data) {
138            $entity->exchangeArray($query->postProcessJoins($data));
139            $entity->setResolveLevel($query->getResolveLevel());
140        }
141        $statement->closeCursor();
142        return $entity;
143    }
145    public function fetchRow(Query\Base|string $query, array|null $parameters = null)
146    {
147        return static::pdoExceptionHandler(function () use ($query, $parameters) {
148            $prepared = $this->fetchPreparedStatement($query);
149            $prepared->execute($parameters);
150            $row = $prepared->fetch(\PDO::FETCH_ASSOC);
151            $prepared->closeCursor();
152            return $row;
153        });
154    }
156    public function fetchValue(Query\Base|string $query, array|null $parameters = null)
157    {
158        return static::pdoExceptionHandler(function () use ($query, $parameters) {
159            $prepared = $this->fetchPreparedStatement($query);
160            $prepared->execute($parameters);
161            $value = $prepared->fetchColumn();
162            $prepared->closeCursor();
163            return $value;
164        });
165    }
167    public function fetchAll(Query\Base|string $query, array|null $parameters = null)
168    {
169        return static::pdoExceptionHandler(function () use ($query, $parameters) {
170            $prepared = $this->fetchPreparedStatement($query);
171            $prepared->execute($parameters);
172            $list = $prepared->fetchAll(\PDO::FETCH_ASSOC);
173            $prepared->closeCursor();
174            return $list;
175        });
176    }
178    public function fetchHandle(Query\Base|string $query, array|null $parameters = null)
179    {
180        return static::pdoExceptionHandler(function () use ($query, $parameters) {
181            $prepared = $this->fetchPreparedStatement($query);
182            $prepared->execute($parameters);
183            return $prepared;
184        });
185    }
187    public function fetchList(Query\Base $query, \BO\Zmsentities\Schema\Entity $entity, array|\ArrayAccess $resultList = [])
188    {
189        $statement = $this->fetchStatement($query);
190        while ($data = $statement->fetch(\PDO::FETCH_ASSOC)) {
191            $dataEntity = clone $entity;
192            $dataEntity->exchangeArray($query->postProcessJoins($data));
193            $dataEntity->setResolveLevel($query->getResolveLevel());
194            $resultList[] = $dataEntity;
195        }
196        $statement->closeCursor();
197        return $resultList;
198    }
206    public function writeItem(Query\Base $query)
207    {
208        return static::pdoExceptionHandler(function () use ($query) {
209            $this->getWriter(); //Switch to writer for write/delete
210            $statement = $this->fetchPreparedStatement($query);
211            $status = $statement->execute($query->getParameters());
212            $statement->closeCursor();
213            return $status;
214        });
215    }
221    public function deleteItem(Query\Base $query)
222    {
223        return $this->writeItem($query);
224    }
226    public function perform(string $sql, array|null $parameters = null)
227    {
228        return static::pdoExceptionHandler(function () use ($sql, $parameters) {
229            $this->getWriter(); //Switch to writer for perform
230            $prepared = $this->fetchPreparedStatement($sql);
231            $status = $prepared->execute($parameters);
232            $prepared->closeCursor();
233            return $status;
234        });
235    }
237    public function fetchAffected(string $sql, array|null $parameters = null)
238    {
239        return static::pdoExceptionHandler(function () use ($sql, $parameters) {
240            $this->getWriter(); //Switch to writer for perform
241            $prepared = $this->fetchPreparedStatement($sql);
242            $prepared->execute($parameters);
243            $count = $prepared->rowCount();
244            $prepared->closeCursor();
245            return $count;
246        });
247    }
256    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $entity, int $resolveReferences)
257    {
258        return $entity;
259    }
268    public function hashStringValue(string $value, ?callable $callable = null): string
269    {
270        if ($callable === null) {
271            $callable = 'sha1';
272        }
273
274        if (is_callable($callable)) {
275            $hash = $callable($value);
276
277            if (is_string($callable)) {
278                return $callable . ':' . $hash;
279            }
280            if ($callable instanceof \Closure) {
281                return 'closure:' . $hash;
282            }
283            // else
284            return 'custom:' . $hash;
285        }
286
287        throw new \InvalidArgumentException('hashStringValue() should be called with a callable as second parameter.');
288    }