Lines 97.63% 206 / 211
Methods 96.87% 31 / 32
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 readEntity 100.00% 8 / 8 100.00% 1 / 1 2
 readResolvedReferences 100.00% 6 / 6 100.00% 1 / 1 3
 readByScopeId 100.00% 6 / 6 100.00% 1 / 1 1
 readByDepartmentId 100.00% 6 / 6 100.00% 1 / 1 1
 readByClusterId 100.00% 4 / 4 100.00% 1 / 1 2
 readByOwnerId 100.00% 12 / 12 100.00% 1 / 1 4
 readByHash 100.00% 4 / 4 100.00% 1 / 1 1
 readList 100.00% 11 / 11 100.00% 1 / 1 3
 deleteEntity 100.00% 6 / 6 100.00% 1 / 1 3
 writeEntity 100.00% 9 / 9 100.00% 1 / 1 2
 updateEntity 100.00% 8 / 8 100.00% 1 / 1 2
 writeOrganisationTicketprinters 100.00% 8 / 8 100.00% 1 / 1 3
 updateOrganisationTicketprinters 100.00% 6 / 6 100.00% 1 / 1 2
 [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
13class Organisation extends \BO\Zmsbackend\Base
14{
15    /**
16     * @param false|int|string $itemId
17     *
18     */
19    public function readEntity(string|int|false $itemId, int $resolveReferences = 0)
20    {
21        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::SELECT);
22        $query->addEntityMapping()
23            ->addResolvedReferences($resolveReferences)
24            ->addConditionOrganisationId($itemId);
25        $organisation = $this->fetchOne($query, new Entity());
26        if (isset($organisation['id'])) {
27            return $this->readResolvedReferences($organisation, $resolveReferences);
28        }
29        return array();
30    }
31
32    /**
33     * @return \BO\Zmsentities\Schema\Entity
34     */
35    #[\Override]
36    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $entity, int $resolveReferences)
37    {
38        if (0 < $resolveReferences && $entity->hasId()) {
39            $entity['departments'] = (new \BO\Zmsbackend\Department\Service\Department())
40                ->readByOrganisationId($entity->id, $resolveReferences - 1);
41            $entity['ticketprinters'] = (new \BO\Zmsbackend\Ticketprinter\Service\Ticketprinter())
42                ->readByOrganisationId($entity->id, $resolveReferences - 1);
43        }
44        return $entity;
45    }
46
47    public function readByScopeId($scopeId, int $resolveReferences = 0)
48    {
49        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::SELECT);
50        $query->addEntityMapping()
51            ->addResolvedReferences($resolveReferences)
52            ->addConditionScopeId($scopeId);
53        $organisation = $this->fetchOne($query, new Entity());
54        return $this->readResolvedReferences($organisation, $resolveReferences);
55    }
56
57    public function readByDepartmentId($departmentId, int $resolveReferences = 0)
58    {
59        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::SELECT);
60        $query->addEntityMapping()
61            ->addResolvedReferences($resolveReferences)
62            ->addConditionDepartmentId($departmentId);
63        $organisation = $this->fetchOne($query, new Entity());
64        return $this->readResolvedReferences($organisation, $resolveReferences);
65    }
66
67    public function readByClusterId($clusterId, int $resolveReferences = 0)
68    {
69        $scope = (new \BO\Zmsbackend\Scope\Service\Scope())->readByClusterId($clusterId, $resolveReferences)->getFirst();
70        if (! $scope) {
71            throw new \BO\Zmsbackend\Cluster\Exception\ClusterWithoutScopes();
72        }
73        return $this->readByScopeId($scope->id, $resolveReferences);
74    }
75
76    public function readByOwnerId($ownerId, int $resolveReferences = 0): Collection
77    {
78        $organisationList = new Collection();
79        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::SELECT);
80        $query->addEntityMapping()
81            ->addResolvedReferences($resolveReferences)
82            ->addConditionOwnerId($ownerId);
83        $result = $this->fetchList($query, new Entity());
84        if (count($result)) {
85            foreach ($result as $organisation) {
86                $entity = $this->readResolvedReferences($organisation, $resolveReferences);
87                if ($entity instanceof Entity) {
88                    $organisationList->addEntity($entity);
89                }
90            }
91        }
92        return $organisationList;
93    }
94
95    public function readByHash($hash)
96    {
97        $organisationId = $this->getReader()
98            ->fetchValue((new \BO\Zmsbackend\Ticketprinter\Repository\Ticketprinter(\BO\Zmsbackend\Query\Base::SELECT))
99            ->getOrganisationIdByHash(), ['hash' => $hash]);
100
101        return $this->readEntity($organisationId);
102    }
103
104    public function readList(int $resolveReferences = 0): Collection
105    {
106        $organisationList = new Collection();
107        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::SELECT);
108        $query->addEntityMapping()
109            ->addResolvedReferences($resolveReferences);
110        $result = $this->fetchList($query, new Entity());
111        if (count($result)) {
112            foreach ($result as $organisation) {
113                $entity = new Entity($organisation);
114                $entity = $this->readResolvedReferences($entity, $resolveReferences);
115                $organisationList->addEntity($entity);
116            }
117        }
118        return $organisationList;
119    }
120
121    public function deleteEntity($itemId)
122    {
123        $entity = $this->readEntity($itemId, 1);
124        if (0 < $entity->toProperty()->departments->get()->count()) {
125            throw new \BO\Zmsbackend\Organisation\Exception\DepartmentListNotEmpty();
126        }
127        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::DELETE);
128        $query->addConditionOrganisationId($itemId);
129        return ($this->deleteItem($query)) ? $entity : null;
130    }
131
132    public function writeEntity(\BO\Zmsentities\Organisation $entity, $parentId)
133    {
134        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::INSERT);
135        $values = $query->reverseEntityMapping($entity, $parentId);
136        $query->addValues($values);
137        $this->writeItem($query);
138        $lastInsertId = $this->getWriter()
139            ->lastInsertId();
140        if ($entity->toProperty()->ticketprinters->isAvailable()) {
141            $this->writeOrganisationTicketprinters($lastInsertId, $entity->ticketprinters);
142        }
143        return $this->readEntity($lastInsertId);
144    }
145
146    public function updateEntity($organisationId, \BO\Zmsentities\Organisation $entity)
147    {
148        $query = new \BO\Zmsbackend\Organisation\Repository\Organisation(\BO\Zmsbackend\Query\Base::UPDATE);
149        $query->addConditionOrganisationId($organisationId);
150        $values = $query->reverseEntityMapping($entity);
151        $query->addValues($values);
152        $this->writeItem($query);
153        if ($entity->toProperty()->ticketprinters->isAvailable()) {
154            $this->updateOrganisationTicketprinters($entity->ticketprinters, $organisationId);
155        }
156        return $this->readEntity($organisationId, 1, true);
157    }
158
159    protected function writeOrganisationTicketprinters(string|false $organisationId, $ticketprinterList): void
160    {
161        $deleteQuery = new \BO\Zmsbackend\Ticketprinter\Repository\Ticketprinter(\BO\Zmsbackend\Query\Base::DELETE);
162        $deleteQuery->addConditionOrganisationId($organisationId);
163        $this->deleteItem($deleteQuery);
164        foreach ($ticketprinterList as $ticketprinter) {
165            $ticketprinter['enabled'] = (isset($ticketprinter['enabled']) && $ticketprinter['enabled']);
166            $ticketprinter = new \BO\Zmsentities\Ticketprinter($ticketprinter);
167            $query = new \BO\Zmsbackend\Ticketprinter\Service\Ticketprinter();
168            $query->writeEntity($ticketprinter, $organisationId);
169        }
170    }
171
172    protected function updateOrganisationTicketprinters($ticketprinterList, $organisationId): void
173    {
174        foreach ($ticketprinterList as $item) {
175            $query = new \BO\Zmsbackend\Ticketprinter\Repository\Ticketprinter(\BO\Zmsbackend\Query\Base::UPDATE);
176            $entity = new \BO\Zmsentities\Ticketprinter($item);
177            $query->addConditionHash($entity->getId());
178            $query->addValues($query->reverseEntityMapping($entity, $organisationId));
179            $this->writeItem($query);
180        }
181    }
182}

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    }