Lines 97.90% 234 / 239
Methods 95.23% 20 / 21
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 readEntity 100.00% 116 / 116 100.00% 1 / 1 1
 [BO\Zmsbackend\Exchange\Service\ExchangeSimpleQuery] fetchDataSet 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] readResolvedReferences n/a 0 / 0 n/a 0 / 0 1
 [BO\Zmsbackend\Base] hashStringValue 50.00% 5 / 10 0.00% 0 / 1 8.12
7class ExchangeAvailabilityreview extends ExchangeSimpleQuery
8{
9    /**
10     * @SuppressWarnings(Length)
11     */
12    public function readEntity()
13    {
14        $entity = new Exchange();
15        $entity['title'] = "Review Öffnungszeiten";
16        $entity->addDictionaryEntry(
17            'Organisationsname',
18            'string',
19            'Name der Organisation'
20        );
21        $entity->addDictionaryEntry(
22            'Standortname',
23            'string',
24            'Name des Standorts inkl. Kürzel'
25        );
26        $entity->addDictionaryEntry(
27            'StandortID',
28            'string',
29            'ID of a scope',
30            'scope.id'
31        );
32        $entity->addDictionaryEntry(
33            'Startdatum',
34            'string',
35            'Beginn der Gültigkeit der Öffnungszeit'
36        );
37        $entity->addDictionaryEntry(
38            'Endedatum',
39            'string',
40            'Ende der Gültigkeit der Öffnungszeit'
41        );
42        $entity->addDictionaryEntry(
43            'Anfang',
44            'string',
45            'Tageszeit zum Anfang der Öffnungszeit'
46        );
47        $entity->addDictionaryEntry(
48            'Ende',
49            'string',
50            'Tageszeit zum Ende der Öffnungszeit'
51        );
52        $entity->addDictionaryEntry(
53            'jedexteWoche',
54            'string',
55            'Öffnungszeit findet nur jede x. Woche im Monat statt'
56        );
57        $entity->addDictionaryEntry(
58            'allexWochen',
59            'string',
60            'Öffnungszeit finden nur alle x Wochen statt, Referenz ist der Montag in der Woche vom Startdatum'
61        );
62        $entity->addDictionaryEntry(
63            'montag',
64            'number',
65            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
66        );
67        $entity->addDictionaryEntry(
68            'dienstag',
69            'number',
70            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
71        );
72        $entity->addDictionaryEntry(
73            'mittwoch',
74            'number',
75            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
76        );
77        $entity->addDictionaryEntry(
78            'donnerstag',
79            'number',
80            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
81        );
82        $entity->addDictionaryEntry(
83            'freitag',
84            'number',
85            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
86        );
87        $entity->addDictionaryEntry(
88            'samstag',
89            'number',
90            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
91        );
92        $entity->addDictionaryEntry(
93            'sonntag',
94            'number',
95            'Ein Wert größer als 0 bedeutet, dass die Öffnungszeit an diesem Wochentag geöffnet hat'
96        );
97        $entity->addDictionaryEntry(
98            'Timeslot',
99            'number',
100            'Anzahl der Minuten, die ein Zeitslot einnimmt'
101        );
102        $entity->addDictionaryEntry(
103            'Arbpltz',
104            'number',
105            'Anzahl der Terminarbeitsplätze'
106        );
107        $entity->addDictionaryEntry(
108            'minusOnline',
109            'number',
110            'Anzahl der Terminarbeitsplätze, um die für die Internetbuchung das Angebot reduziert wird'
111        );
112        $entity->addDictionaryEntry(
113            'mehrfach',
114            'number',
115            'Ein Wert größer als 0 bedeutet, dass für einen Termin mehr als ein Zeitslot verwendet werden darf'
116        );
117        $entity->addDictionaryEntry(
118            'buchVon',
119            'number',
120            'Anzahl der Tage, die mindestens im voraus gebucht werden muss'
121        );
122        $entity->addDictionaryEntry(
123            'buchBis',
124            'string',
125            'Anzahl der Tage, die man maximal im voraus buchen kann'
126        );
127
128        //$entity['visualization']['xlabel'] = ["StandortID"];
129        //$entity['visualization']['ylabel'] = ["buchVon", "buchBis"];
130
131
132        $sql = 'SELECT 
133                    organisation.Organisationsname,
134                    CONCAT(standort.Bezeichnung,
135                            " ",
136                            standort.standortkuerzel) Standortname,
137                    standort.StandortID,
138                    oeffnungszeit.start_date AS Startdatum,
139                    oeffnungszeit.end_date AS Endedatum,
140                    oeffnungszeit.appointment_start_time AS Anfang,
141                    oeffnungszeit.appointment_end_time AS Ende,
142                    oeffnungszeit.every_other_week AS jedexteWoche,
143                    oeffnungszeit.every_x_weeks AS allexWochen,
144                    weekday & 2 montag,
145                    weekday & 4 dienstag,
146                    weekday & 8 mittwoch,
147                    weekday & 16 donnerstag,
148                    weekday & 32 freitag,
149                    weekday & 64 samstag,
150                    weekday & 1 sonntag,
151                    oeffnungszeit.time_slot AS Timeslot,
152                    oeffnungszeit.appointment_workstation_count AS Arbpltz,
153                    oeffnungszeit.internet_reduction AS minusOnline,
154                    oeffnungszeit.multiple_slots_allowed AS mehrfach,
155                    IF(oeffnungszeit.`open_from_days`,
156                        oeffnungszeit.`open_from_days`,
157                        standort.`Termine_ab`) buchVon,
158                    IF(oeffnungszeit.`open_until_days`,
159                        oeffnungszeit.`open_until_days`,
160                        standort.`Termine_bis`) buchBis
161                FROM
162                    oeffnungszeit
163                        LEFT JOIN
164                    standort ON oeffnungszeit.scope_id = standort.StandortID
165                        LEFT JOIN
166                    behoerde ON standort.BehoerdenID = behoerde.BehoerdenID
167                        LEFT JOIN
168                    organisation ON behoerde.OrganisationsID = organisation.OrganisationsID
169                WHERE
170                    oeffnungszeit.end_date >= NOW()
171                        AND behoerde.Name = "Bürgeramt"
172                ORDER BY organisation.Organisationsname ASC,
173                    Standortname ASC,
174                    oeffnungszeit.weekday ASC,
175                    oeffnungszeit.start_date ASC,
176                    oeffnungszeit.appointment_start_time ASC;
177        ';
178        return $this->fetchDataSet($entity, $sql);
179    }
180}

Inherited from BO\Zmsbackend\Exchange\Service\ExchangeSimpleQuery

9    protected function fetchDataSet(Exchange $entity, string $sql): Exchange
10    {
11        $raw = $this
12            ->getReader()
13            ->fetchAll($sql);
14        foreach ($raw as $entry) {
15            $entity->addDataSet(array_values($entry));
16        }
17        return $entity;
18    }

Inherited from BO\Zmsbackend\Base

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