Lines 66.53% 497 / 747
Methods 55.38% 36 / 65
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 getUseraccountCacheVersion 28.57% 2 / 7 0.00% 0 / 1 9.83
 invalidateAllCaches 66.66% 2 / 3 0.00% 0 / 1 2.15
 registerCacheKeyForDepartments 0.00% 0 / 13 0.00% 0 / 1 56
 deleteCacheKey 0.00% 0 / 6 0.00% 0 / 1 12
 invalidateDepartmentCaches 0.00% 0 / 19 0.00% 0 / 1 90
 getCacheIndexKey 0.00% 0 / 1 0.00% 0 / 1 2
 extractDepartmentIdsFromEntity 0.00% 0 / 7 0.00% 0 / 1 42
 readDepartmentIdsForLoginName 88.88% 8 / 9 0.00% 0 / 1 4.02
 collectDepartmentIdsForInvalidation 0.00% 0 / 11 0.00% 0 / 1 6
 collectUseraccountIdentifiers 0.00% 0 / 8 0.00% 0 / 1 30
 applyWorkstationAccessFilter 91.66% 11 / 12 0.00% 0 / 1 4.01
 sanitizeCacheKey 100.00% 1 / 1 100.00% 1 / 1 1
 readIsUserExisting 100.00% 8 / 8 100.00% 1 / 1 3
 readEntity 50.00% 15 / 30 0.00% 0 / 1 22.50
 readResolvedReferences 80.00% 4 / 5 0.00% 0 / 1 4.13
 readList 58.13% 25 / 43 0.00% 0 / 1 38.20
 readListStatement 63.63% 7 / 11 0.00% 0 / 1 7.73
 readAssignedDepartmentList 100.00% 6 / 6 100.00% 1 / 1 2
 readAssignedDepartmentListsForAll 88.88% 8 / 9 0.00% 0 / 1 4.02
 separateSuperusersFromRegularUsers 100.00% 7 / 7 100.00% 1 / 1 3
 loadSuperuserDepartments 100.00% 7 / 7 100.00% 1 / 1 2
 loadRegularUserDepartments 100.00% 5 / 5 100.00% 1 / 1 1
 groupAssignmentsByUser 100.00% 7 / 7 100.00% 1 / 1 3
 buildDepartmentListsForUsers 100.00% 23 / 23 100.00% 1 / 1 10
 buildDepartmentList 100.00% 11 / 11 100.00% 1 / 1 5
 readEntityByAuthKey 100.00% 7 / 7 100.00% 1 / 1 2
 readEntityByUserId 100.00% 6 / 6 100.00% 1 / 1 2
 readCollectionByDepartmentIds 50.00% 23 / 46 0.00% 0 / 1 58.50
 writeEntity 92.85% 13 / 14 0.00% 0 / 1 3.00
 extractRequestedRoleNames 75.00% 9 / 12 0.00% 0 / 1 7.77
 replaceUserRoles 87.50% 14 / 16 0.00% 0 / 1 3.02
 writeUpdatedEntity 70.83% 17 / 24 0.00% 0 / 1 5.62
 deleteEntity 100.00% 9 / 9 100.00% 1 / 1 3
 updateAssignedDepartments 100.00% 12 / 12 100.00% 1 / 1 3
 readEntityIdByLoginName 100.00% 3 / 3 100.00% 1 / 1 1
 deleteAssignedDepartments 100.00% 3 / 3 100.00% 1 / 1 1
 buildSearchCacheKey 100.00% 6 / 6 100.00% 1 / 1 4
 getCachedResult 37.50% 3 / 8 0.00% 0 / 1 14.79
 setCachedResult 14.28% 1 / 7 0.00% 0 / 1 8.67
 executeSearchQuery 60.86% 14 / 23 0.00% 0 / 1 13.85
 executeSearchByDepartmentIdsQuery 65.21% 15 / 23 0.00% 0 / 1 14.21
 readSearch 100.00% 13 / 13 100.00% 1 / 1 3
 readSearchByDepartmentIds 100.00% 16 / 16 100.00% 1 / 1 3
 readListRole 51.28% 20 / 39 0.00% 0 / 1 28.65
 readListByRoleAndDepartmentIds 50.00% 22 / 44 0.00% 0 / 1 43.12
 removeCache 6.66% 2 / 30 0.00% 0 / 1 74.86
 [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] hashStringValue 50.00% 5 / 10 0.00% 0 / 1 8.12
15class Useraccount extends \BO\Zmsbackend\Base
16{
17    private const string CACHE_VERSION_KEY = 'useraccountCacheVersion';
18    private const string CACHE_INDEX_PREFIX = 'useraccountCacheIndex-';
19    private const string CACHE_INDEX_GLOBAL = 'all';
20
21    /**
22     * Read or initialize the cache version for all useraccount-related cache entries.
23     */
24    protected function getUseraccountCacheVersion(): int
25    {
26        if (!App::$cache) {
27            return 1;
28        }
29
30        $version = App::$cache->get(self::CACHE_VERSION_KEY);
31        if (!is_int($version) || $version < 1) {
32            $version = 1;
33            App::$cache->set(self::CACHE_VERSION_KEY, $version);
34        }
35
36        return $version;
37    }
38
39    public function invalidateAllCaches(): void
40    {
41        if (!App::$cache) {
42            return;
43        }
44        App::$cache->set(self::CACHE_VERSION_KEY, $this->getUseraccountCacheVersion() + 1);
45    }
46
47    /**
48     * Register a cache key for one or more department IDs so we can invalidate
49     * only the affected department-based caches later on.
50     *
51     * Note: This method uses a non-atomic read-modify-write pattern which may
52     * experience race conditions under high concurrency. Lost index entries are
53     * handled by the version-bump fallback in removeCache(), ensuring eventual
54     * consistency at the cost of a full cache invalidation.
55     *
56     * @see https://github.com/it-at-m/eappointment/issues/1804
57     *      Migration to Redis for atomic operations is tracked in issue #1804.
58     *
59     * @param array $departmentIds Department IDs to associate with the cache key
60     * @param string $cacheKey The cache key to register
61     */
62    protected function registerCacheKeyForDepartments(array $departmentIds, string $cacheKey): void
63    {
64        if (!App::$cache || empty($departmentIds)) {
65            return;
66        }
67
68        $departmentIds = array_values(array_unique(array_filter($departmentIds, function ($id) {
69            return $id !== null && $id !== '';
70        })));
71
72        foreach ($departmentIds as $departmentId) {
73            $indexKey = $this->getCacheIndexKey($departmentId);
74            $existing = App::$cache->get($indexKey);
75            if (!is_array($existing)) {
76                $existing = [];
77            }
78            if (!in_array($cacheKey, $existing, true)) {
79                $existing[] = $cacheKey;
80                App::$cache->set($indexKey, $existing);
81            }
82        }
83    }
84
85    protected function deleteCacheKey(string $cacheKey): bool
86    {
87        if (!App::$cache) {
88            return false;
89        }
90
91        if (App::$cache->has($cacheKey)) {
92            App::$cache->delete($cacheKey);
93            return true;
94        }
95
96        return false;
97    }
98
99    protected function invalidateDepartmentCaches(array $departmentIds): bool
100    {
101        if (!App::$cache) {
102            return false;
103        }
104
105        $departmentIds = array_values(array_unique(array_filter($departmentIds, function ($id) {
106            return $id !== null && $id !== '';
107        })));
108
109        $foundAny = false;
110
111        foreach ($departmentIds as $departmentId) {
112            $indexKey = $this->getCacheIndexKey($departmentId);
113            $indexExists = App::$cache->has($indexKey);
114            $cacheKeys = $indexExists ? App::$cache->get($indexKey) : [];
115            if (!is_array($cacheKeys)) {
116                $cacheKeys = [];
117            }
118
119            if ($indexExists) {
120                $foundAny = true;
121            }
122
123            foreach ($cacheKeys as $cacheKey) {
124                if ($this->deleteCacheKey($cacheKey)) {
125                    $foundAny = true;
126                }
127            }
128
129            App::$cache->delete($indexKey);
130        }
131
132        return $foundAny;
133    }
134
135    protected function getCacheIndexKey($departmentId): string
136    {
137        return self::CACHE_INDEX_PREFIX . $departmentId;
138    }
139
140    protected function extractDepartmentIdsFromEntity($useraccount): array
141    {
142        $ids = [];
143        foreach ($useraccount->getDepartmentList() as $department) {
144            if (is_object($department) && isset($department->id)) {
145                $ids[] = $department->id;
146            } elseif (is_array($department) && isset($department['id'])) {
147                $ids[] = $department['id'];
148            }
149        }
150
151        return array_values(array_unique(array_filter($ids)));
152    }
153
154    protected function readDepartmentIdsForLoginName($loginName): array
155    {
156        if (!$loginName) {
157            return [];
158        }
159
160        $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_ASSIGNED_DEPARTMENTS;
161        $departmentData = $this->getReader()->fetchAll($query, ['useraccountName' => $loginName]);
162
163        $ids = [];
164        foreach ($departmentData as $row) {
165            if (isset($row['id'])) {
166                $ids[] = $row['id'];
167            }
168        }
169
170        return array_values(array_unique($ids));
171    }
172
173    protected function collectDepartmentIdsForInvalidation($useraccount, array $previousDepartmentIds = []): array
174    {
175        $currentFromEntity = $this->extractDepartmentIdsFromEntity($useraccount);
176        $currentFromDatabase = $this->readDepartmentIdsForLoginName($useraccount->id ?? null);
177
178        $departmentIds = array_merge(
179            $previousDepartmentIds,
180            $currentFromEntity,
181            $currentFromDatabase
182        );
183
184        $departmentIds[] = self::CACHE_INDEX_GLOBAL;
185
186        return array_values(array_unique(array_filter($departmentIds, function ($id) {
187            return $id !== null && $id !== '';
188        })));
189    }
190
191    protected function collectUseraccountIdentifiers($useraccount): array
192    {
193        $identifiers = [];
194
195        if (isset($useraccount->id)) {
196            $identifiers[] = $useraccount->id;
197        }
198
199        if (isset($useraccount->loginname) && $useraccount->loginname !== $useraccount->id) {
200            $identifiers[] = $useraccount->loginname;
201        }
202
203        return array_values(array_unique(array_filter($identifiers, function ($identifier) {
204            return $identifier !== null && $identifier !== '';
205        })));
206    }
207
208    protected function applyWorkstationAccessFilter(\BO\Zmsbackend\Useraccount\Repository\Useraccount $query, $workstation): bool
209    {
210        if (!$workstation || $workstation->getUseraccount()->isSuperUser()) {
211            return true; // No filtering needed for superusers
212        }
213
214        $workstationUserId = $this->readEntityIdByLoginName($workstation->getUseraccount()->id);
215        $workstationDepartmentIds = $workstation->getDepartmentList()->getIds();
216
217        // If no departments loaded, return empty result for security
218        if (empty($workstationDepartmentIds)) {
219            return false; // Signal to return empty collection
220        }
221
222        $query->addConditionWorkstationAccess(
223            $workstationUserId,
224            $workstationDepartmentIds,
225            false // We already checked isSuperUser above
226        );
227
228        return true;
229    }
230    /**
231     * Sanitize cache key by replacing reserved characters
232     * Reserved characters: {}()/\@:
233     *
234     * @return string|string[]
235     *
236     */
237    protected function sanitizeCacheKey(string $key): array|string
238    {
239        return str_replace(['{', '}', '(', ')', '/', '\\', '@', ':'], '_', $key);
240    }
241
242    public function readIsUserExisting($loginName, $password = false): bool
243    {
244        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
245        $query->addEntityMapping()
246            ->setResolveLevel(0)
247            ->addConditionLoginName($loginName);
248        if ($password) {
249            $query->addConditionPassword($password);
250        }
251        $useraccount = $this->fetchOne($query, new Entity());
252        return ($useraccount->hasId()) ? true : false;
253    }
254
255    public function readEntity($loginname, int $resolveReferences = 1, bool $disableCache = false)
256    {
257        $version = $this->getUseraccountCacheVersion();
258        $cacheKey = $this->sanitizeCacheKey("useraccount-v{$version}-$loginname-$resolveReferences");
259        $useraccount = null;
260
261        if (!$disableCache && App::$cache && App::$cache->has($cacheKey)) {
262            $useraccount = App::$cache->get($cacheKey);
263            if ($useraccount && App::$log) {
264                App::$log->info('Useraccount cache hit', [
265                    'cache_key' => $cacheKey,
266                    'loginname' => $loginname,
267                    'resolveReferences' => $resolveReferences,
268                ]);
269            }
270        }
271
272        if (empty($useraccount)) {
273            $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
274            $query->addEntityMapping()
275            ->addResolvedReferences($resolveReferences)
276            ->addConditionLoginName($loginname);
277            $useraccount = $this->fetchOne($query, new Entity());
278            if (!$useraccount->hasId()) {
279                return null;
280            }
281
282            $useraccount = $this->readResolvedReferences($useraccount, $resolveReferences);
283
284            if (App::$cache) {
285                App::$cache->set($cacheKey, $useraccount);
286                if (App::$log) {
287                    App::$log->info('Useraccount cache set', [
288                        'cache_key' => $cacheKey,
289                        'loginname' => $loginname,
290                        'resolveReferences' => $resolveReferences,
291                        'useraccount_id' => $useraccount->id
292                    ]);
293                }
294            }
295        }
296
297        return $useraccount;
298    }
299
300    /**
301     * @return Entity
302     */
303    #[\Override]
304    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $entity, int $resolveReferences): Entity
305    {
306        if (!$entity instanceof Entity) {
307            throw new \InvalidArgumentException('Expected ' . Entity::class);
308        }
309        if (0 < $resolveReferences && $entity->toProperty()->id->get()) {
310            $entity->departments = $this->readAssignedDepartmentList($entity, $resolveReferences);
311        }
312        return $entity;
313    }
314
315    /**
316     * @SuppressWarnings(NPathComplexity)
317     */
318    public function readList(int $resolveReferences = 0, bool $disableCache = false, $workstation = null)
319    {
320        $version = $this->getUseraccountCacheVersion();
321        $workstationKey = '';
322        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
323            $workstationKey = '-workstation-' . $workstation->getUseraccount()->id;
324        }
325        $cacheKey = "useraccountReadList-v{$version}-$resolveReferences$workstationKey";
326        $result = null;
327
328        if (!$disableCache && App::$cache && App::$cache->has($cacheKey)) {
329            $result = App::$cache->get($cacheKey);
330            if ($result && App::$log) {
331                App::$log->info('Useraccount list cache hit', [
332                    'cache_key' => $cacheKey,
333                    'resolveReferences' => $resolveReferences,
334                    'count' => $result->count()
335                ]);
336            }
337        }
338
339        if (empty($result)) {
340            $collection = new Collection();
341            $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
342            $query->addResolvedReferences($resolveReferences)
343            ->addEntityMapping()
344            ->addOrderByName();
345
346            // Apply workstation access filtering if provided
347            if (!$this->applyWorkstationAccessFilter($query, $workstation)) {
348                $result = new Collection();
349                return $result;
350            }
351
352            $result = $this->fetchList($query, new Entity());
353            if (count($result)) {
354                foreach ($result as $entity) {
355                    $collection->addEntity($entity);
356                }
357                if (0 < $resolveReferences) {
358                    $departmentMap = $this->readAssignedDepartmentListsForAll($collection, $resolveReferences - 1);
359                    foreach ($collection as $entity) {
360                        if (isset($departmentMap[$entity->id])) {
361                            $entity->departments = $departmentMap[$entity->id];
362                        }
363                    }
364                }
365            }
366            $result = $collection;
367
368            if (App::$cache) {
369                App::$cache->set($cacheKey, $result);
370                $this->registerCacheKeyForDepartments([self::CACHE_INDEX_GLOBAL], $cacheKey);
371                if (App::$log) {
372                    App::$log->info('Useraccount list cache set', [
373                        'cache_key' => $cacheKey,
374                        'resolveReferences' => $resolveReferences,
375                        'count' => $result->count()
376                    ]);
377                }
378            }
379        }
380
381        return $result;
382    }
383
384    protected function readListStatement($statement, int $resolveReferences): Collection
385    {
386        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
387        $collection = new Collection();
388        while ($userAccountData = $statement->fetch(\PDO::FETCH_ASSOC)) {
389            $entity = new Entity($query->postProcessJoins($userAccountData));
390            $collection->addEntity($entity);
391        }
392        if (0 < $resolveReferences && count($collection) > 0) {
393            $departmentMap = $this->readAssignedDepartmentListsForAll($collection, $resolveReferences - 1);
394            foreach ($collection as $entity) {
395                if (isset($departmentMap[$entity->id])) {
396                    $entity->departments = $departmentMap[$entity->id];
397                }
398            }
399        }
400        return $collection;
401    }
402
403    public function readAssignedDepartmentList(Entity $useraccount, int $resolveReferences = 0)
404    {
405        if ($useraccount->isSuperUser()) {
406            $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_SUPERUSER_DEPARTMENTS;
407            $departmentData = $this->getReader()->fetchAll($query);
408        } else {
409            $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_ASSIGNED_DEPARTMENTS;
410            $departmentData = $this->getReader()->fetchAll($query, ['useraccountName' => $useraccount->id]);
411        }
412        return $this->buildDepartmentList($departmentData, $resolveReferences);
413    }
414
415    protected function readAssignedDepartmentListsForAll(Collection $useraccounts, int $resolveReferences = 0): array
416    {
417        if (count($useraccounts) === 0) {
418            return [];
419        }
420
421        list($superusers, $regularUsers) = $this->separateSuperusersFromRegularUsers($useraccounts);
422        $result = [];
423
424        if (count($superusers) > 0) {
425            $result = array_merge($result, $this->loadSuperuserDepartments($superusers, $resolveReferences));
426        }
427
428        if (count($regularUsers) > 0) {
429            $result = array_merge($result, $this->loadRegularUserDepartments($regularUsers, $resolveReferences));
430        }
431
432        return $result;
433    }
434
435    /**
436     * @return array[]
437     *
438     */
439    protected function separateSuperusersFromRegularUsers(Collection $useraccounts): array
440    {
441        $superusers = [];
442        $regularUsers = [];
443        foreach ($useraccounts as $useraccount) {
444            if ($useraccount->isSuperUser()) {
445                $superusers[] = $useraccount->id;
446            } else {
447                $regularUsers[] = $useraccount->id;
448            }
449        }
450        return [$superusers, $regularUsers];
451    }
452
453    protected function loadSuperuserDepartments(array $superusers, int $resolveReferences = 0): array
454    {
455        // Load all departments once - all superusers have access to all departments
456            $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_SUPERUSER_DEPARTMENTS;
457            $departmentIds = $this->getReader()->fetchAll($query);
458        $departmentList = $this->buildDepartmentList($departmentIds, $resolveReferences);
459
460        // Reuse the same list for all superusers - no need to clone since they all get the same departments
461        $result = [];
462        foreach ($superusers as $useraccountName) {
463            $result[$useraccountName] = $departmentList;
464        }
465        return $result;
466    }
467
468    protected function loadRegularUserDepartments(array $regularUsers, int $resolveReferences = 0)
469    {
470        $placeholders = str_repeat('?,', count($regularUsers) - 1) . '?';
471        $query = str_replace(':useraccountNames', $placeholders, \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_ASSIGNED_DEPARTMENTS_FOR_ALL);
472        $allAssignments = $this->getReader()->fetchAll($query, $regularUsers);
473
474        $assignmentsByUser = $this->groupAssignmentsByUser($allAssignments);
475        return $this->buildDepartmentListsForUsers($regularUsers, $assignmentsByUser, $resolveReferences);
476    }
477
478    /**
479     * @return array[]
480     *
481     */
482    protected function groupAssignmentsByUser(array $allAssignments): array
483    {
484        $assignmentsByUser = [];
485        foreach ($allAssignments as $assignment) {
486            $useraccountName = $assignment['useraccountName'];
487            if (!isset($assignmentsByUser[$useraccountName])) {
488                $assignmentsByUser[$useraccountName] = [];
489            }
490            $assignmentsByUser[$useraccountName][] = $assignment;
491        }
492        return $assignmentsByUser;
493    }
494
495    /**
496     * @return \BO\Zmsentities\Collection\DepartmentList[]
497     *
498     */
499    protected function buildDepartmentListsForUsers(array $useraccountNames, array $assignmentsByUser, int $resolveReferences = 0): array
500    {
501        // Collect ALL unique department IDs from all useraccounts
502        $allDepartmentIds = [];
503        $departmentIdsByUser = [];
504
505        foreach ($useraccountNames as $useraccountName) {
506            $departmentIdsByUser[$useraccountName] = [];
507            if (isset($assignmentsByUser[$useraccountName])) {
508                foreach ($assignmentsByUser[$useraccountName] as $item) {
509                    $departmentId = $item['id'];
510                    if (!isset($allDepartmentIds[$departmentId])) {
511                        $allDepartmentIds[$departmentId] = true;
512                    }
513                    $departmentIdsByUser[$useraccountName][] = $departmentId;
514                }
515            }
516        }
517
518        // Load ALL departments in ONE query
519        $allDepartments = [];
520        if (!empty($allDepartmentIds)) {
521            $uniqueDepartmentIds = array_keys($allDepartmentIds);
522            $allDepartments = (new \BO\Zmsbackend\Department\Service\Department())->readEntitiesByIds($uniqueDepartmentIds, $resolveReferences);
523        }
524
525        // Build department lists for each useraccount from the pre-loaded departments
526        $result = [];
527        foreach ($useraccountNames as $useraccountName) {
528            $departmentList = new \BO\Zmsentities\Collection\DepartmentList();
529            if (isset($departmentIdsByUser[$useraccountName])) {
530                foreach ($departmentIdsByUser[$useraccountName] as $departmentId) {
531                    if (isset($allDepartments[$departmentId])) {
532                        // Clone department so each useraccount gets its own instance
533                        $departmentList->addEntity(clone $allDepartments[$departmentId]);
534                    }
535                }
536            }
537            $result[$useraccountName] = $departmentList;
538        }
539
540        return $result;
541    }
542
543    protected function buildDepartmentList(array $items, int $resolveReferences = 0): \BO\Zmsentities\Collection\DepartmentList
544    {
545        $departmentList = new \BO\Zmsentities\Collection\DepartmentList();
546
547        if (empty($items)) {
548            return $departmentList;
549        }
550
551        $departmentIds = [];
552        foreach ($items as $item) {
553            $departmentIds[] = $item['id'];
554        }
555
556        $departments = (new \BO\Zmsbackend\Department\Service\Department())->readEntitiesByIds($departmentIds, $resolveReferences);
557
558        foreach ($departmentIds as $id) {
559            if (isset($departments[$id])) {
560                // Clone department so the list has its own instances
561                $departmentList->addEntity(clone $departments[$id]);
562            }
563        }
564
565        return $departmentList;
566    }
567
568    public function readEntityByAuthKey(string $xAuthKey, int $resolveReferences = 0)
569    {
570        $hashedAuthKey = hash('sha256', $xAuthKey);
571        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
572        $query->addEntityMapping()
573            ->addResolvedReferences($resolveReferences)
574            ->addConditionXauthKey($hashedAuthKey);
575        $entity = ($hashedAuthKey) ? $this->fetchOne($query, new Entity()) : new Entity();
576        return $this->readResolvedReferences($entity, $resolveReferences);
577    }
578
579    public function readEntityByUserId($userId, int $resolveReferences = 0)
580    {
581        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
582        $query->addEntityMapping()
583            ->addResolvedReferences($resolveReferences)
584            ->addConditionUserId($userId);
585        $entity = ($userId) ? $this->fetchOne($query, new Entity()) : new Entity();
586        return $this->readResolvedReferences($entity, $resolveReferences);
587    }
588
589    /**
590     * @SuppressWarnings(NPathComplexity)
591     */
592    public function readCollectionByDepartmentIds($departmentIds, int $resolveReferences = 0, bool $disableCache = false, $workstation = null)
593    {
594        sort($departmentIds);
595        $version = $this->getUseraccountCacheVersion();
596        $workstationKey = '';
597        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
598            $workstationKey = '-workstation-' . $workstation->getUseraccount()->id;
599        }
600        $cacheKey = "useraccountReadByDepartmentIds-v{$version}-" . implode(',', $departmentIds) . "-$resolveReferences$workstationKey";
601        $result = null;
602
603        if (!$disableCache && App::$cache && App::$cache->has($cacheKey)) {
604            $result = App::$cache->get($cacheKey);
605            if ($result && App::$log) {
606                App::$log->info('Useraccount department list cache hit', [
607                    'cache_key' => $cacheKey,
608                    'department_ids' => $departmentIds,
609                    'resolveReferences' => $resolveReferences,
610                    'count' => $result->count()
611                ]);
612            }
613        }
614
615        if (empty($result)) {
616            $collection = new Collection();
617            $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
618            $query->addResolvedReferences($resolveReferences)
619            ->addConditionDepartmentIds($departmentIds)
620            ->addEntityMapping()
621            ->addOrderByName();
622
623            // Exclude superusers if workstation user is not superuser
624            if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
625                $query->addConditionExcludeSuperusers();
626            }
627
628            $result = $this->fetchList($query, new Entity());
629            if (count($result)) {
630                foreach ($result as $entity) {
631                    $collection->addEntity($entity);
632                }
633                if (0 < $resolveReferences) {
634                    $departmentMap = $this->readAssignedDepartmentListsForAll($collection, $resolveReferences - 1);
635                    foreach ($collection as $entity) {
636                        if (isset($departmentMap[$entity->id])) {
637                            $entity->departments = $departmentMap[$entity->id];
638                        }
639                    }
640                }
641            }
642            $result = $collection;
643
644            if (App::$cache) {
645                App::$cache->set($cacheKey, $result);
646                $this->registerCacheKeyForDepartments($departmentIds, $cacheKey);
647                if (App::$log) {
648                    App::$log->info('Useraccount department list cache set', [
649                        'cache_key' => $cacheKey,
650                        'department_ids' => $departmentIds,
651                        'resolveReferences' => $resolveReferences,
652                        'count' => $result->count()
653                    ]);
654                }
655            }
656        }
657
658        return $result;
659    }
660
661    public function writeEntity(\BO\Zmsentities\Useraccount $entity, int $resolveReferences = 0)
662    {
663        if ($this->readIsUserExisting($entity->id)) {
664            throw new \BO\Zmsbackend\Useraccount\Exception\DuplicateEntry();
665        }
666
667        $roleNames = $this->extractRequestedRoleNames($entity);
668        if (count($roleNames) !== 1) {
669            throw new \BO\Zmsbackend\Useraccount\Exception\RoleAssignmentFailed();
670        }
671
672        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::INSERT);
673        $values = $query->reverseEntityMapping($entity);
674        $query->addValues($values);
675        $this->writeItem($query);
676
677        $userId = (int) $this->readEntityIdByLoginName($entity->id);
678        $this->replaceUserRoles($userId, $roleNames);
679        $this->updateAssignedDepartments($entity);
680
681        $this->removeCache($entity);
682
683        return $this->readEntity($entity->getId(), $resolveReferences, true);
684    }
685
686    protected function extractRequestedRoleNames(Entity $entity): array
687    {
688        $roles = $entity->offsetExists('roles') ? $entity['roles'] : [];
689        if (!is_array($roles)) {
690            return [];
691        }
692
693        $requestedRoles = [];
694        foreach ($roles as $roleName) {
695            if (!is_string($roleName)) {
696                continue;
697            }
698
699            $roleName = trim($roleName);
700            if ($roleName === '' || isset($requestedRoles[$roleName])) {
701                continue;
702            }
703
704            $requestedRoles[$roleName] = true;
705        }
706
707        return array_keys($requestedRoles);
708    }
709
710    protected function replaceUserRoles(int $userId, array $roleNames): void
711    {
712        if (count($roleNames) !== 1) {
713            throw new \BO\Zmsbackend\Useraccount\Exception\RoleAssignmentFailed();
714        }
715
716        $this->perform(\BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_DELETE_USER_ROLES, [$userId]);
717
718        $placeholders = implode(', ', array_fill(0, count($roleNames), '?'));
719        $query = str_replace(
720            ':roleNames',
721            $placeholders,
722            \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_INSERT_USER_ROLES_BY_NAME
723        );
724
725        $this->perform($query, array_merge([$userId], $roleNames));
726
727        $count = (int) $this->fetchValue(
728            'SELECT COUNT(*) FROM user_role WHERE user_id = ?',
729            [$userId]
730        );
731
732        if ($count !== 1) {
733            throw new \BO\Zmsbackend\Useraccount\Exception\RoleAssignmentFailed();
734        }
735    }
736
737    public function writeUpdatedEntity($loginName, Entity $entity, int $resolveReferences = 0)
738    {
739        $previousDepartmentIds = $this->readDepartmentIdsForLoginName($loginName);
740        $userId = null;
741        $roleNames = [];
742
743        // Extract requested role names (if present)
744        $requestedRoles = $this->extractRequestedRoleNames($entity);
745
746        if (count($requestedRoles) > 0) {
747            $userId = (int) $this->readEntityIdByLoginName($loginName);
748            $roleNames = $requestedRoles;
749        }
750
751        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::UPDATE);
752        $query->addConditionLoginName($loginName);
753        $values = $query->reverseEntityMapping($entity);
754        $query->addValues($values);
755        $this->writeItem($query);
756        $this->updateAssignedDepartments($entity);
757
758        if (count($roleNames) > 0) {
759            try {
760                $this->replaceUserRoles($userId, $roleNames);
761            } catch (\Throwable $e) {
762                if (App::$log) {
763                    App::$log->warning('user_role update on useraccount save failed', [
764                        'login' => $loginName,
765                        'message' => $e->getMessage(),
766                    ]);
767                }
768                throw $e;
769            }
770        }
771
772        $this->removeCache($entity, $previousDepartmentIds, $loginName);
773
774        return $this->readEntity($entity->getId(), $resolveReferences, true);
775    }
776
777    public function deleteEntity($loginName): bool
778    {
779        // Read entity before deletion to get cache info
780        $entity = $this->readEntity($loginName, 0, true);
781        $previousDepartmentIds = $this->readDepartmentIdsForLoginName($loginName);
782
783        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::DELETE);
784        $query->addConditionLoginName($loginName);
785        $this->deleteAssignedDepartments($loginName);
786        $result = $this->deleteItem($query);
787
788        if ($entity && $entity->hasId()) {
789            $this->removeCache($entity, $previousDepartmentIds, $loginName);
790        }
791
792        return $result;
793    }
794
795    protected function updateAssignedDepartments(Entity $entity): void
796    {
797        $loginName = $entity->id;
798        if (!$entity->isSuperUser()) {
799            $this->deleteAssignedDepartments($loginName);
800            $userId = $this->readEntityIdByLoginName($loginName);
801            foreach ($entity->getDepartmentList() as $department) {
802                $this->perform(
803                    \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_WRITE_ASSIGNED_DEPARTMENTS,
804                    array(
805                        $userId,
806                        $department['id']
807                    )
808                );
809            }
810        }
811    }
812
813    protected function readEntityIdByLoginName($loginName)
814    {
815        $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_READ_ID_BY_USERNAME;
816        $result = $this->getReader()->fetchOne($query, [$loginName]);
817        return $result['id'];
818    }
819
820    protected function deleteAssignedDepartments($loginName)
821    {
822        $query = \BO\Zmsbackend\Useraccount\Repository\Useraccount::QUERY_DELETE_ASSIGNED_DEPARTMENTS;
823        $userId = $this->readEntityIdByLoginName($loginName);
824        return $this->perform($query, [$userId]);
825    }
826
827    protected function buildSearchCacheKey(string $prefix, int $resolveReferences, $workstation, $queryString, array $departmentIds = []): string
828    {
829        $version = $this->getUseraccountCacheVersion();
830        $workstationKey = '';
831        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
832            $workstationKey = '-workstation-' . $workstation->getUseraccount()->id;
833        }
834        $departmentKey = empty($departmentIds) ? '' : '-' . implode(',', $departmentIds);
835        return "{$prefix}-v{$version}{$departmentKey}-$resolveReferences$workstationKey-query-" . md5($queryString);
836    }
837
838    protected function getCachedResult($cacheKey, bool $disableCache, string $logMessage, array $logContext = [])
839    {
840        $result = null;
841        if (!$disableCache && App::$cache && App::$cache->has($cacheKey)) {
842            $result = App::$cache->get($cacheKey);
843            if ($result && App::$log) {
844                $logContext['cache_key'] = $cacheKey;
845                $logContext['count'] = $result->count();
846                App::$log->info($logMessage, $logContext);
847            }
848        }
849        return $result;
850    }
851
852    protected function setCachedResult($cacheKey, $result, array $departmentIds, string $logMessage, array $logContext = []): void
853    {
854        if (App::$cache) {
855            App::$cache->set($cacheKey, $result);
856            $this->registerCacheKeyForDepartments($departmentIds, $cacheKey);
857            if (App::$log) {
858                $logContext['cache_key'] = $cacheKey;
859                $logContext['count'] = $result->count();
860                App::$log->info($logMessage, $logContext);
861            }
862        }
863    }
864
865    protected function executeSearchQuery(array $parameter, int $resolveReferences, $workstation): Collection
866    {
867        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
868        $query
869            ->addResolvedReferences($resolveReferences)
870            ->addEntityMapping()
871            ->addOrderByName();
872
873        // For superusers: select all users without department filtering
874        // For non-superusers: apply department-based access filtering
875        if (!$this->applyWorkstationAccessFilter($query, $workstation)) {
876            return new Collection();
877        }
878
879        if (isset($parameter['query'])) {
880            if (preg_match('#^\d+$#', $parameter['query'])) {
881                $query->addConditionUserId($parameter['query']);
882                $query->addConditionSearch($parameter['query'], true);
883            } else {
884                $query->addConditionSearch($parameter['query']);
885            }
886        }
887
888        $collection = new Collection();
889        $result = $this->fetchList($query, new Entity());
890        if (count($result)) {
891            foreach ($result as $entity) {
892                $collection->addEntity($entity);
893            }
894            if (0 < $resolveReferences) {
895                $departmentMap = $this->readAssignedDepartmentListsForAll($collection, $resolveReferences - 1);
896                foreach ($collection as $entity) {
897                    if (isset($departmentMap[$entity->id])) {
898                        $entity->departments = $departmentMap[$entity->id];
899                    }
900                }
901            }
902        }
903        return $collection;
904    }
905
906    protected function executeSearchByDepartmentIdsQuery(array $departmentIds, array $parameter, int $resolveReferences, $workstation): Collection
907    {
908        $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
909        $query->addResolvedReferences($resolveReferences)
910            ->addEntityMapping()
911            ->addOrderByName();
912
913        if (isset($parameter['query'])) {
914            if (preg_match('#^\d+$#', $parameter['query'])) {
915                $query->addConditionUserId($parameter['query']);
916                $query->addConditionDepartmentIdsAndSearch($departmentIds, $parameter['query'], true);
917            } else {
918                $query->addConditionDepartmentIdsAndSearch($departmentIds, $parameter['query']);
919            }
920        } else {
921            $query->addConditionDepartmentIds($departmentIds);
922        }
923
924        // Exclude superusers if workstation user is not superuser
925        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
926            $query->addConditionExcludeSuperusers();
927        }
928
929        $collection = new Collection();
930        $result = $this->fetchList($query, new Entity());
931        if (count($result)) {
932            foreach ($result as $entity) {
933                $collection->addEntity($entity);
934            }
935            if (0 < $resolveReferences) {
936                $departmentMap = $this->readAssignedDepartmentListsForAll($collection, $resolveReferences - 1);
937                foreach ($collection as $entity) {
938                    if (isset($departmentMap[$entity->id])) {
939                        $entity->departments = $departmentMap[$entity->id];
940                    }
941                }
942            }
943        }
944        return $collection;
945    }
946
947    /**
948     * @SuppressWarnings(NPathComplexity)
949     *
950     */
951    public function readSearch(array $parameter, int $resolveReferences = 0, $workstation = null, bool $disableCache = false)
952    {
953        $queryString = isset($parameter['query']) ? $parameter['query'] : '';
954        $cacheKey = $this->buildSearchCacheKey('useraccountReadSearch', $resolveReferences, $workstation, $queryString);
955        $result = $this->getCachedResult($cacheKey, $disableCache, 'Useraccount search cache hit', [
956            'query' => $queryString,
957            'resolveReferences' => $resolveReferences
958        ]);
959
960        if (empty($result)) {
961            $result = $this->executeSearchQuery($parameter, $resolveReferences, $workstation);
962            $this->setCachedResult($cacheKey, $result, [self::CACHE_INDEX_GLOBAL], 'Useraccount search cache set', [
963                'query' => $queryString,
964                'resolveReferences' => $resolveReferences
965            ]);
966        }
967
968        return $result;
969    }
970
971    /**
972     * @SuppressWarnings(NPathComplexity)
973     *
974     */
975    public function readSearchByDepartmentIds(array $departmentIds, array $parameter, int $resolveReferences = 0, $workstation = null, bool $disableCache = false)
976    {
977        sort($departmentIds);
978        $queryString = isset($parameter['query']) ? $parameter['query'] : '';
979        $cacheKey = $this->buildSearchCacheKey('useraccountReadSearchByDepartmentIds', $resolveReferences, $workstation, $queryString, $departmentIds);
980        $result = $this->getCachedResult($cacheKey, $disableCache, 'Useraccount search by department cache hit', [
981            'department_ids' => $departmentIds,
982            'query' => $queryString,
983            'resolveReferences' => $resolveReferences
984        ]);
985
986        if (empty($result)) {
987            $result = $this->executeSearchByDepartmentIdsQuery($departmentIds, $parameter, $resolveReferences, $workstation);
988            $this->setCachedResult($cacheKey, $result, $departmentIds, 'Useraccount search by department cache set', [
989                'department_ids' => $departmentIds,
990                'query' => $queryString,
991                'resolveReferences' => $resolveReferences
992            ]);
993        }
994
995        return $result;
996    }
997
998    public function readListRole($roleName, int $resolveReferences = 0, $workstation = null)
999    {
1000        $version = $this->getUseraccountCacheVersion();
1001        $workstationKey = '';
1002        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
1003            $workstationKey = '-workstation-' . $workstation->getUseraccount()->id;
1004        }
1005
1006        $cacheKey = $this->sanitizeCacheKey(
1007            "useraccountReadByRole-v{$version}-" . ($roleName ?? 'null') . "-$resolveReferences$workstationKey"
1008        );
1009        $result = null;
1010
1011        if (App::$cache && App::$cache->has($cacheKey)) {
1012            $result = App::$cache->get($cacheKey);
1013            if ($result && App::$log) {
1014                App::$log->info('Useraccount role list cache hit', [
1015                    'cache_key' => $cacheKey,
1016                    'role_name' => $roleName,
1017                    'resolveReferences' => $resolveReferences,
1018                    'count' => $result->count()
1019                ]);
1020            }
1021        }
1022
1023        if (empty($result)) {
1024            $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
1025            $query->addResolvedReferences($resolveReferences)
1026                ->addEntityMapping()
1027                ->addOrderByName();
1028
1029            if (!empty($roleName)) {
1030                $query->addConditionRoleName($roleName);
1031            }
1032
1033            if (!$this->applyWorkstationAccessFilter($query, $workstation)) {
1034                return new Collection();
1035            }
1036
1037            $statement = $this->fetchStatement($query);
1038            $result = $this->readListStatement($statement, $resolveReferences);
1039
1040            if (App::$cache) {
1041                App::$cache->set($cacheKey, $result);
1042                $this->registerCacheKeyForDepartments([self::CACHE_INDEX_GLOBAL], $cacheKey);
1043                if (App::$log) {
1044                    App::$log->info('Useraccount role list cache set', [
1045                        'cache_key' => $cacheKey,
1046                        'role_name' => $roleName,
1047                        'resolveReferences' => $resolveReferences,
1048                        'count' => $result->count()
1049                    ]);
1050                }
1051            }
1052        }
1053
1054        return $result;
1055    }
1056
1057    /**
1058     * @SuppressWarnings(NPathComplexity)
1059     *
1060     * @param bool $disableCache
1061     *
1062     */
1063    public function readListByRoleAndDepartmentIds($roleName, array $departmentIds, int $resolveReferences = 0, bool $disableCache = false, $workstation = null)
1064    {
1065        sort($departmentIds);
1066        $version = $this->getUseraccountCacheVersion();
1067        $workstationKey = '';
1068        if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
1069            $workstationKey = '-workstation-' . $workstation->getUseraccount()->id;
1070        }
1071
1072        $cacheKey = $this->sanitizeCacheKey(
1073            "useraccountReadByRoleAndDepartmentIds-v{$version}-$roleName-" . implode(',', $departmentIds) . "-$resolveReferences$workstationKey"
1074        );
1075        $result = null;
1076
1077        if (!$disableCache && App::$cache && App::$cache->has($cacheKey)) {
1078            $result = App::$cache->get($cacheKey);
1079            if ($result && App::$log) {
1080                App::$log->info('Useraccount role and department list cache hit', [
1081                    'cache_key' => $cacheKey,
1082                    'role_name' => $roleName,
1083                    'department_ids' => $departmentIds,
1084                    'resolveReferences' => $resolveReferences,
1085                    'count' => $result->count()
1086                ]);
1087            }
1088        }
1089
1090        if (empty($result)) {
1091            if (empty($roleName) || empty($departmentIds)) {
1092                return new Collection();
1093            }
1094
1095            $query = new \BO\Zmsbackend\Useraccount\Repository\Useraccount(\BO\Zmsbackend\Query\Base::SELECT);
1096            $query->addResolvedReferences($resolveReferences)
1097                ->addEntityMapping()
1098                ->addOrderByName();
1099
1100            $query->addConditionRoleName($roleName);
1101            $query->addConditionDepartmentIds($departmentIds);
1102
1103            if ($workstation && !$workstation->getUseraccount()->isSuperUser()) {
1104                $query->addConditionExcludeSuperusers();
1105            }
1106
1107            $statement = $this->fetchStatement($query);
1108            $result = $this->readListStatement($statement, $resolveReferences);
1109
1110            if (App::$cache) {
1111                App::$cache->set($cacheKey, $result);
1112                $this->registerCacheKeyForDepartments($departmentIds, $cacheKey);
1113                if (App::$log) {
1114                    App::$log->info('Useraccount role and department list cache set', [
1115                        'cache_key' => $cacheKey,
1116                        'role_name' => $roleName,
1117                        'department_ids' => $departmentIds,
1118                        'resolveReferences' => $resolveReferences,
1119                        'count' => $result->count()
1120                    ]);
1121                }
1122            }
1123        }
1124
1125        return $result;
1126    }
1127
1128    /**
1129     * @return void
1130     */
1131    public function removeCache(Entity $useraccount, array $previousDepartmentIds = [], ?string $oldLoginName = null)
1132    {
1133        if (!App::$cache) {
1134            return;
1135        }
1136
1137        $currentVersion = $this->getUseraccountCacheVersion();
1138        $identifiers = $this->collectUseraccountIdentifiers($useraccount);
1139        // Add old loginname to identifiers if provided and not already in the list
1140        // This ensures cache keys for the old loginname are invalidated when loginname changes
1141        if ($oldLoginName !== null && !in_array($oldLoginName, $identifiers, true)) {
1142            $identifiers[] = $oldLoginName;
1143        }
1144        $removedEntityKeys = [];
1145
1146        foreach ($identifiers as $identifier) {
1147            for ($i = 0; $i <= 2; $i++) {
1148                $cacheKey = $this->sanitizeCacheKey("useraccount-v{$currentVersion}-{$identifier}-$i");
1149                if ($this->deleteCacheKey($cacheKey)) {
1150                    $removedEntityKeys[] = $cacheKey;
1151                }
1152            }
1153        }
1154
1155        $departmentIds = $this->collectDepartmentIdsForInvalidation($useraccount, $previousDepartmentIds);
1156        $removedDepartmentCaches = $this->invalidateDepartmentCaches($departmentIds);
1157
1158        $versionBumped = false;
1159        $newVersion = $currentVersion;
1160
1161        if (!$removedDepartmentCaches) {
1162            $newVersion = $currentVersion + 1;
1163            App::$cache->set(self::CACHE_VERSION_KEY, $newVersion);
1164            $versionBumped = true;
1165        }
1166
1167        if (App::$log) {
1168            App::$log->info('Useraccount caches invalidated after mutation', [
1169                'useraccount_id' => $useraccount->id,
1170                'identifiers' => $identifiers,
1171                'removed_entity_cache_keys' => $removedEntityKeys,
1172                'department_ids' => $departmentIds,
1173                'version_bumped' => $versionBumped,
1174                'old_version' => $currentVersion,
1175                'new_version' => $newVersion,
1176            ]);
1177        }
1178    }
1179}

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    }
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    }