Lines 94.30% 149 / 158
Methods 84.61% 11 / 13
Classes 0.00% 0 / 1
Name Lines Methods CRAP
 readResponse 100.00% 31 / 31 100.00% 1 / 1 2
 generateResponse 100.00% 8 / 8 100.00% 1 / 1 1
 updateAvailabilityList 100.00% 6 / 6 100.00% 1 / 1 2
 updateAvailability 100.00% 36 / 36 100.00% 1 / 1 5
 resetOpeningHours 100.00% 7 / 7 100.00% 1 / 1 2
 validateAvailabilityList 100.00% 7 / 7 100.00% 1 / 1 3
 validateAvailability 100.00% 17 / 17 100.00% 1 / 1 1
 createAvailabilityList 100.00% 6 / 6 100.00% 1 / 1 2
 createSelectedDateTime 100.00% 4 / 4 100.00% 1 / 1 1
 createMergedAvailabilityList 100.00% 6 / 6 100.00% 1 / 1 2
 validateClientData 40.00% 4 / 10 0.00% 0 / 1 17.58
 validateScopeConsistency 82.35% 14 / 17 0.00% 0 / 1 6.20
 [BO\Zmsbackend\Api\BaseController] __invoke 100.00% 3 / 3 100.00% 1 / 1 1
27class AvailabilityListUpdate extends \BO\Zmsbackend\Api\BaseController
28{
29    /**
30     * @SuppressWarnings(Param)
31     * @return ResponseInterface
32     */
33    #[\Override]
34    public function readResponse(
35        RequestInterface $request,
36        ResponseInterface $response,
37        array $args
38    ): ResponseInterface {
39        (new \BO\Zmsbackend\Helper\User($request))->checkPermissions('availability');
40        $input = Validator::input()->isJson()->assertValid()->getValue();
41        $resolveReferences = Validator::param('resolveReferences')->isNumber()->setDefault(2)->getValue();
42        self::validateClientData($input);
43        self::validateScopeConsistency($input['availabilityList']);
44        $newAvailabilities = $this->createAvailabilityList($input['availabilityList']);
45        $selectedDate = $this->createSelectedDateTime($input['selectedDate']);
46        $scope = new \BO\Zmsentities\Scope($input['availabilityList'][0]['scope']);
47        $existingAvailabilities = $this->createMergedAvailabilityList($scope);
48
49        $validationErrors = $this->validateAvailabilityList($newAvailabilities, $existingAvailabilities, $selectedDate);
50
51        if (count($validationErrors) > 0) {
52            $availabilityIds = array_map(
53                function ($availability) {
54                    return $availability->id;
55                },
56                $newAvailabilities->getArrayCopy()
57            );
58            App::$log->warning('AvailabilityListUpdateFailed: Validation failed', [
59                'ids' => array_filter($availabilityIds),
60                'scope_id' => $scope->getId(),
61                'errors' => $validationErrors
62            ]);
63            $message = \BO\Zmsbackend\Api\Response\Message::create($request);
64            $message->data = [];
65            $message->meta->error = true;
66            $message->meta->message = json_encode(['errors' => $validationErrors]);
67            $message->meta->exception = 'BO\\Zmsbackend\\Availability\\Exception\\AvailabilityListUpdateFailed';
68            return Render::withJson($response, $message, 400);
69        }
70
71        DbConnection::getWriteConnection();
72        $updatedAvailabilities = $this->updateAvailabilityList($newAvailabilities, $resolveReferences);
73        return $this->generateResponse($request, $response, $updatedAvailabilities);
74    }
75
76    private function generateResponse(
77        RequestInterface $request,
78        ResponseInterface $response,
79        AvailabilityList $availabilities
80    ): ResponseInterface {
81        $message = \BO\Zmsbackend\Api\Response\Message::create($request);
82        $message->data = $availabilities->getArrayCopy();
83
84        $response = Render::withLastModified($response, time(), '0');
85        return Render::withJson(
86            $response,
87            $message->setUpdatedMetaData(),
88            $message->getStatuscode()
89        );
90    }
91
92    private function updateAvailabilityList(AvailabilityList $availabilities, int $resolveReferences): AvailabilityList
93    {
94        $updatedAvailabilities = new AvailabilityList();
95        foreach ($availabilities as $availability) {
96            $updatedAvailability = $this->updateAvailability($availability, $resolveReferences);
97            AvailabilitySlotsUpdate::writeCalculatedSlots($updatedAvailability, true);
98            $updatedAvailabilities->addEntity($updatedAvailability);
99        }
100        return $updatedAvailabilities;
101    }
102
103    protected function updateAvailability(Availability $availability, int $resolveReferences): ?Availability
104    {
105        $repository = new AvailabilityRepository();
106        $history = new AvailabilityHistoryService();
107        $updatedAvailability = null;
108        if ($availability->id) {
109            $existingAvailability = $repository->readEntity($availability->id);
110            if ($existingAvailability && $existingAvailability->hasId()) {
111                $availability->version = $existingAvailability->version + 1;
112                $this->resetOpeningHours($existingAvailability);
113                $updatedAvailability = $repository->updateEntity($availability->id, $availability, $resolveReferences);
114                $history->writeUpdated($updatedAvailability);
115                App::$log->info('Updated availability', [
116                    'id' => $availability->id,
117                    'scope_id' => $availability->scope['id'],
118                    'version' => $availability->version,
119                    'startDate' => $availability->startDate,
120                    'endDate' => $availability->endDate,
121                    'startTime' => $availability->startTime,
122                    'endTime' => $availability->endTime,
123                    'type' => $availability->type,
124                    'operation' => 'update'
125                ]);
126            }
127        } else {
128            $updatedAvailability = $repository->writeEntity($availability, $resolveReferences);
129            $history->writeCreated($updatedAvailability);
130            App::$log->info('Created new availability', [
131                'id' => $updatedAvailability->id,
132                'scope_id' => $availability->scope['id'],
133                'startDate' => $availability->startDate,
134                'endDate' => $availability->endDate,
135                'startTime' => $availability->startTime,
136                'endTime' => $availability->endTime,
137                'type' => $availability->type,
138                'operation' => 'create'
139            ]);
140        }
141        if (!$updatedAvailability) {
142            throw new AvailabilityListUpdateFailed();
143        }
144        return $updatedAvailability;
145    }
146
147    protected function resetOpeningHours(Availability $availability): void
148    {
149        $doubleTypeAvailability = (new AvailabilityRepository())->readEntityDoubleTypes($availability->id);
150        if ($doubleTypeAvailability) {
151            $doubleTypeAvailability->workstationCount['intern'] = 0;
152            $doubleTypeAvailability->workstationCount['public'] = 0;
153            $doubleTypeAvailability['description'] = '';
154            $doubleTypeAvailability['type'] = 'openinghours';
155            (new AvailabilityRepository())->writeEntity($doubleTypeAvailability);
156        }
157    }
158
159    private function validateAvailabilityList(
160        AvailabilityList $newAvailabilities,
161        AvailabilityList $existingAvailabilities,
162        \DateTimeImmutable $selectedDate
163    ): array {
164        $validationErrors = [];
165        foreach ($newAvailabilities as $newAvailability) {
166            $errors = $this->validateAvailability($newAvailability, $existingAvailabilities, $selectedDate);
167            if (count($errors) > 0) {
168                $validationErrors = array_merge($validationErrors, $errors);
169            } else {
170                $existingAvailabilities->addEntity($newAvailability);
171            }
172        }
173        return $validationErrors;
174    }
175
176    private function validateAvailability(
177        Availability $availability,
178        AvailabilityList $existingAvailabilities,
179        \DateTimeImmutable $selectedDate
180    ): array {
181        $startDate = (new \DateTimeImmutable())->setTimestamp($availability->startDate);
182        $endDate = (new \DateTimeImmutable())->setTimestamp($availability->endDate);
183        $startDateTime = new \DateTimeImmutable(
184            "{$startDate->format('Y-m-d')} {$availability->startTime}"
185        );
186        $endDateTime = new \DateTimeImmutable(
187            "{$endDate->format('Y-m-d')} {$availability->endTime}"
188        );
189
190        return $existingAvailabilities->validateTimeRangesAndRules(
191            $startDateTime,
192            $endDateTime,
193            $selectedDate,
194            $availability->kind ?? 'default',
195            $availability->bookable['startInDays'],
196            $availability->bookable['endInDays'],
197            $availability->weekday
198        );
199    }
200
201    private function createAvailabilityList(array $availabilityData): AvailabilityList
202    {
203        $availabilities = new AvailabilityList();
204        foreach ($availabilityData as $data) {
205            $availability = new Availability($data);
206            $availability->testValid();
207            $availabilities->addEntity($availability);
208        }
209        return $availabilities;
210    }
211
212    private function createSelectedDateTime(string $selectedDate): \DateTimeImmutable
213    {
214        return \DateTimeImmutable::createFromFormat(
215            'Y-m-d H:i:s',
216            $selectedDate . ' 00:00:00'
217        );
218    }
219
220    private function createMergedAvailabilityList(\BO\Zmsentities\Scope $scope): AvailabilityList
221    {
222        $availabilityRepo = new AvailabilityRepository();
223        $existingAvailabilities = $availabilityRepo->readAvailabilityListByScope($scope, 1);
224
225        $mergedAvailabilities = new AvailabilityList();
226        foreach ($existingAvailabilities as $availability) {
227            $mergedAvailabilities->addEntity($availability);
228        }
229        return $mergedAvailabilities;
230    }
231
232    private static function validateClientData(array $input): void
233    {
234        if (empty($input)) {
235            App::$log->warning('No input data provided');
236            throw new BadRequestException('No input data provided');
237        }
238
239        if (!isset($input['availabilityList']) || !is_array($input['availabilityList']) || empty($input['availabilityList'])) {
240            App::$log->warning('Invalid availabilityList', [
241                'has_availabilityList' => isset($input['availabilityList']),
242                'is_array' => isset($input['availabilityList']) ? is_array($input['availabilityList']) : false,
243                'is_empty' => isset($input['availabilityList']) ? empty($input['availabilityList']) : true
244            ]);
245            throw new BadRequestException('Invalid availabilityList');
246        }
247    }
248
249    private static function validateScopeConsistency(array $availabilityList): void
250    {
251        if (empty($availabilityList)) {
252            return;
253        }
254
255        $firstScope = null;
256        foreach ($availabilityList as $index => $availability) {
257            $currentScope = $availability['scope']['id'] ?? null;
258            if (!$currentScope) {
259                App::$log->warning('Missing scope id in availability', ['index' => $index]);
260                throw new BadRequestException('Missing scope id in availability list');
261            }
262            if ($firstScope === null) {
263                $firstScope = $currentScope;
264            } elseif ($currentScope !== $firstScope) {
265                App::$log->warning('Inconsistent scopes in availability list', [
266                    'first_scope' => $firstScope,
267                    'different_scope' => $currentScope,
268                    'index' => $index
269                ]);
270                throw new BadRequestException('All availabilities must belong to the same scope');
271            }
272        }
273    }
274}

Inherited from BO\Zmsbackend\Api\BaseController

20    public function __invoke(RequestInterface $request, ResponseInterface $response, array $args)
21    {
22        $request = $this->initRequest($request);
23        $noCacheResponse = \BO\Slim\Render::withLastModified($response, time(), '0');
24        return $this->readResponse($request, $noCacheResponse, $args);
25    }