Lines 86.13% 236 / 274
Methods 82.35% 28 / 34
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 readEntity 100.00% 8 / 8 100.00% 1 / 1 2
 readEntities 0.00% 0 / 13 0.00% 0 / 1 6
 readEntitiesIds 0.00% 0 / 8 0.00% 0 / 1 2
 readList 100.00% 12 / 12 100.00% 1 / 1 2
 readListIds 0.00% 0 / 7 0.00% 0 / 1 2
 readResolvedReferences 93.75% 15 / 16 0.00% 0 / 1 4.00
 writeInQueueWithAdmin 100.00% 18 / 18 100.00% 1 / 1 1
 writeInQueue 100.00% 26 / 26 100.00% 1 / 1 7
 writeInQueueWithDailyProcessList 100.00% 16 / 16 100.00% 1 / 1 1
 writeMimeparts 100.00% 18 / 18 100.00% 1 / 1 6
 deleteEntity 100.00% 3 / 3 100.00% 1 / 1 1
 deleteEntities 0.00% 0 / 4 0.00% 0 / 1 2
 readReminderLastRun 100.00% 3 / 3 100.00% 1 / 1 2
 writeReminderLastRun 100.00% 1 / 1 100.00% 1 / 1 1
 readMultiPartByQueueId 100.00% 4 / 4 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] hashStringValue 50.00% 5 / 10 0.00% 0 / 1 8.12
14class Mail extends \BO\Zmsbackend\Base
15{
16    /**
17     * Fetch status from db
18     *
19     * @return \BO\Zmsentities\Mail
20     *
21     * @param false|string $itemId
22     */
23    public function readEntity(string|false $itemId, int $resolveReferences = 1)
24    {
25        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::SELECT);
26        $query->addEntityMapping()
27            ->addResolvedReferences($resolveReferences)
28            ->addConditionItemId($itemId);
29        $mail = $this->fetchOne($query, new Entity());
30        if ($mail->hasId()) {
31            $mail = $this->readResolvedReferences($mail, $resolveReferences);
32        }
33        return $mail;
34    }
35
36    public function readEntities(array $itemIds, int $resolveReferences = 1, int $limit = 300, string $order = 'ASC'): Collection
37    {
38        $mailList = new Collection();
39        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::SELECT);
40        $query->addEntityMapping()
41              ->addResolvedReferences($resolveReferences)
42              ->addWhereIn('id', $itemIds)
43              ->addOrderBy('createTimestamp', $order)
44              ->addLimit($limit);
45        $result = $this->fetchList($query, new Entity());
46
47        foreach ($result as $item) {
48            $entity = new Entity($item);
49            $entity = $this->readResolvedReferences($entity, $resolveReferences);
50            $mailList->addEntity($entity);
51        }
52
53        return $mailList;
54    }
55
56
57    public function readEntitiesIds(array $itemIds, int $resolveReferences = 1, int $limit = 300, string $order = 'ASC')
58    {
59
60        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::SELECT);
61        $query->selectFields(['id', 'createTimestamp'])
62              ->addEntityMapping()
63              ->addResolvedReferences($resolveReferences)
64              ->addWhereIn('id', $itemIds)
65              ->addOrderBy('createTimestamp', $order)
66              ->addLimit($limit);
67
68        return $this->fetchList($query, new Entity());
69    }
70
71    public function readList(int $resolveReferences = 1, int $limit = 300, string $order = 'ASC'): Collection
72    {
73        $mailList = new Collection();
74        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::SELECT);
75        $query->addEntityMapping()
76              ->addResolvedReferences($resolveReferences)
77              ->addOrderBy('createTimestamp', $order)
78              ->addLimit($limit);
79        $result = $this->fetchList($query, new Entity());
80
81        foreach ($result as $item) {
82            $entity = new Entity($item);
83            $entity = $this->readResolvedReferences($entity, $resolveReferences);
84            $mailList->addEntity($entity);
85        }
86
87        return $mailList;
88    }
89
90
91    public function readListIds(int $resolveReferences = 1, int $limit = 300, string $order = 'ASC')
92    {
93        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::SELECT);
94        $query->selectFields(['id', 'createTimestamp'])
95              ->addEntityMapping()
96              ->addResolvedReferences($resolveReferences)
97              ->addOrderBy('createTimestamp', $order)
98              ->addLimit($limit);
99
100        return $this->fetchList($query, new Entity());
101    }
102
103
104
105    /**
106     * @return Entity
107     */
108    #[\Override]
109    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $entity, int $resolveReferences)
110    {
111        if (!$entity instanceof Entity) {
112            throw new \InvalidArgumentException('Expected ' . Entity::class);
113        }
114        $multiPart = $this->readMultiPartByQueueId($entity->id);
115        $entity->addMultiPart($multiPart);
116        if (1 <= $resolveReferences) {
117            $processQuery = new \BO\Zmsbackend\Process\Service\Process();
118            $authData = $processQuery->readAuthKeyByProcessId($entity->process['id']);
119            $entity->process = $processQuery
120                ->readEntity(
121                    $entity->process['id'],
122                    is_array($authData) ? $authData['authKey'] : null,
123                    $resolveReferences - 1
124                );
125            $entity->department = (new \BO\Zmsbackend\Department\Service\Department())
126                ->readEntity($entity->department['id'], $resolveReferences - 1);
127        }
128        return $entity;
129    }
130
131    public function writeInQueueWithAdmin(Entity $mail): Entity
132    {
133        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::INSERT);
134        $process = new \BO\Zmsentities\Process($mail->process);
135        $department = (new \BO\Zmsbackend\Department\Service\Department())->readByScopeId($process->getScopeId(), 0);
136        $query->addValues(
137            array(
138                'processID' => $mail->process['id'],
139                'departmentID' => $department->toProperty()->id->get(),
140                'createIP' => $mail->createIP,
141                'createTimestamp' => time(),
142                'subject' => $mail->subject,
143                'clientFamilyName' => $process->scope['contact']['name'],
144                'clientEmail' => $process->scope['contact']['email']
145            )
146        );
147        $this->writeItem($query);
148        $queueId = $this->getWriter()->lastInsertId();
149        $this->writeMimeparts($queueId, $mail->multipart);
150        return $this->readEntity($queueId);
151    }
152
153    public function writeInQueue(Entity $mail, \DateTimeInterface $dateTime, bool $count = true): Entity
154    {
155        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::INSERT);
156        $process = new \BO\Zmsentities\Process($mail->process);
157        $client = $mail->getFirstClient();
158        if (! $client->hasEmail()) {
159            throw new \BO\Zmsbackend\Mail\Exception\ClientWithoutEmail();
160        }
161        $department = ($mail->department && $mail->department->hasId()) ?
162            $mail->department :
163            (new \BO\Zmsbackend\Department\Service\Department())->readByScopeId($process->getScopeId(), 0);
164        $query->addValues(
165            array(
166                'processID' => $mail->process['id'],
167                'departmentID' => $department->getId(),
168                'createIP' => $mail->createIP,
169                'createTimestamp' => ($dateTime) ? $dateTime->format('U') : time(),
170                'subject' => $mail->subject,
171                'clientFamilyName' => $client->familyName,
172                'clientEmail' => $client->email
173            )
174        );
175        $success = $this->writeItem($query);
176        $queueId = $this->getWriter()->lastInsertId();
177        if ($count && $success) {
178            $client->emailSendCount += 1;
179            (new \BO\Zmsbackend\Process\Service\Process())->updateEntity($process, $dateTime);
180        }
181        $this->writeMimeparts($queueId, $mail->multipart);
182        return $this->readEntity($queueId);
183    }
184
185    public function writeInQueueWithDailyProcessList(
186        \BO\Zmsentities\Scope $scope,
187        Entity $mail
188    ): Entity {
189        $query = new \BO\Zmsbackend\Mail\Repository\MailQueue(\BO\Zmsbackend\Query\Base::INSERT);
190        $department = (new \BO\Zmsbackend\Department\Service\Department())->readByScopeId($scope->getId(), 0);
191        $query->addValues(
192            array(
193                'departmentID' => $department->toProperty()->id->get(),
194                'createTimestamp' => time(),
195                'createIP' => $mail->createIP,
196                'subject' => $mail->subject,
197                'clientFamilyName' => $mail->client->familyName,
198                'clientEmail' => $mail->client->email
199            )
200        );
201        $this->writeItem($query);
202        $queueId = $this->getWriter()->lastInsertId();
203        $this->writeMimeparts($queueId, $mail->multipart);
204        return $this->readEntity($queueId);
205    }
206
207    /**
208     * @param false|string $queueId
209     *
210     * @return true
211     */
212    protected function writeMimeparts(string|false $queueId, $multipart): bool
213    {
214        $success = true;
215        foreach ($multipart as $part) {
216            $query = new \BO\Zmsbackend\Mail\Repository\Mimepart(\BO\Zmsbackend\Query\Base::INSERT);
217            $query->addValues(
218                array(
219                    'queueId' => $queueId,
220                    'mime' => $part['mime'],
221                    'content' => $part['content'],
222                    'base64' => $part['base64'] ? 1 : 0
223                )
224            );
225            if (! isset($part['content']) || ! isset($part['mime']) || ! $success) {
226                $this->deleteEntity($queueId);
227                throw new \BO\Zmsbackend\Mail\Exception\MailWritePartFailed(
228                    'Failed to write part (' . $part['mime'] . ') of mail with id ' . $queueId
229                );
230            }
231            $success = $this->writeItem($query);
232        }
233        return true;
234    }
235
236    public function deleteEntity($itemId)
237    {
238        $query = \BO\Zmsbackend\Mail\Repository\MailQueue::QUERY_DELETE;
239        $status = $this->perform($query, [$itemId]);
240        return $status;
241    }
242
243    public function deleteEntities(array $itemIds)
244    {
245        $query = \BO\Zmsbackend\Mail\Repository\MailQueue::QUERY_MULTI_DELETE;
246        $placeholders = implode(',', array_fill(0, count($itemIds), '?'));
247        $query = str_replace('?', $placeholders, $query);
248        return $this->perform($query, $itemIds);
249    }
250
251    public function readReminderLastRun(\DateTimeInterface $now)
252    {
253        $lastRun = (new \BO\Zmsbackend\Config\Service\Config())->readProperty('status__mailReminderLastRun', false);
254        $lastRunDateTime = ($lastRun) ? new \DateTimeImmutable($lastRun) : $now;
255        return $lastRunDateTime;
256    }
257
258    public function writeReminderLastRun(\DateTimeInterface $now): void
259    {
260        (new \BO\Zmsbackend\Config\Service\Config())->replaceProperty('status__mailReminderLastRun', $now->format('Y-m-d H:i:s'));
261    }
262
263    protected function readMultiPartByQueueId($queueId)
264    {
265        $query = new \BO\Zmsbackend\Mail\Repository\Mimepart(\BO\Zmsbackend\Query\Base::SELECT);
266        $query->addEntityMapping()
267            ->addConditionQueueId($queueId);
268        return $this->fetchList($query, new Mimepart());
269    }
270}

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    }