Merge branch 'develop' into feat/ajout-notifications

src/ApiResource/WorkHourBulkSiteValidation.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\ApiResource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Post;
+use App\State\WorkHourBulkSiteValidationProcessor;
+
+#[ApiResource(
+    operations: [
+        new Post(
+            uriTemplate: '/work-hours/site-bulk-validation',
+            security: "is_granted('ROLE_USER')",
+            output: WorkHourBulkValidationResult::class,
+            processor: WorkHourBulkSiteValidationProcessor::class
+        ),
+    ]
+)]
+final class WorkHourBulkSiteValidation
+{
+    public string $workDate = '';
+
+    public bool $isSiteValid = false;
+
+    /**
+     * @var list<int>
+     */
+    public array $employeeIds = [];
+}

src/ApiResource/WorkHourBulkValidation.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\ApiResource;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Post;
+use App\State\WorkHourBulkValidationProcessor;
+
+#[ApiResource(
+    operations: [
+        new Post(
+            uriTemplate: '/work-hours/bulk-validation',
+            security: "is_granted('ROLE_ADMIN')",
+            output: WorkHourBulkValidationResult::class,
+            processor: WorkHourBulkValidationProcessor::class
+        ),
+    ]
+)]
+final class WorkHourBulkValidation
+{
+    public string $workDate = '';
+
+    public bool $isValid = false;
+
+    /**
+     * @var list<int>
+     */
+    public array $employeeIds = [];
+}

src/ApiResource/WorkHourBulkValidationResult.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\ApiResource;
+
+final class WorkHourBulkValidationResult
+{
+    public int $requested = 0;
+    public int $updated   = 0;
+    public int $skipped   = 0;
+
+    /**
+     * @var list<int>
+     */
+    public array $updatedEmployeeIds = [];
+
+    /**
+     * @var list<int>
+     */
+    public array $skippedEmployeeIds = [];
+}

src/Service/WorkHours/WorkHourBulkValidationExecutor.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service\WorkHours;
+
+use App\ApiResource\WorkHourBulkValidationResult;
+use App\Entity\User;
+use App\Entity\WorkHour;
+use App\Repository\EmployeeRepository;
+use App\Repository\WorkHourRepository;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+final readonly class WorkHourBulkValidationExecutor
+{
+    public function __construct(
+        private EntityManagerInterface $entityManager,
+        private EmployeeRepository $employeeRepository,
+        private WorkHourRepository $workHourRepository,
+    ) {}
+
+    /**
+     * @param list<mixed>                    $employeeIds
+     * @param callable(?WorkHour, int): bool $shouldSkip
+     * @param callable(WorkHour, int): void  $applyUpdate
+     */
+    public function execute(
+        User $user,
+        string $workDateValue,
+        array $employeeIds,
+        callable $shouldSkip,
+        callable $applyUpdate
+    ): WorkHourBulkValidationResult {
+        $workDate = DateTimeImmutable::createFromFormat('Y-m-d', $workDateValue);
+        if (!$workDate || $workDate->format('Y-m-d') !== $workDateValue) {
+            throw new UnprocessableEntityHttpException('workDate must use Y-m-d format.');
+        }
+
+        $normalizedEmployeeIds = $this->normalizeEmployeeIds($employeeIds);
+        if ([] === $normalizedEmployeeIds) {
+            throw new UnprocessableEntityHttpException('employeeIds must contain at least one employee.');
+        }
+
+        $employeesById = $this->employeeRepository->findAccessibleByIds($normalizedEmployeeIds, $user);
+        if (count($employeesById) !== count($normalizedEmployeeIds)) {
+            throw new AccessDeniedHttpException('At least one employee is unknown or outside your scope.');
+        }
+
+        $existingByEmployeeId = $this->workHourRepository
+            ->findByDateAndEmployeesIndexedByEmployeeId($workDate, array_values($employeesById))
+        ;
+
+        $result            = new WorkHourBulkValidationResult();
+        $result->requested = count($normalizedEmployeeIds);
+
+        foreach ($normalizedEmployeeIds as $employeeId) {
+            $workHour = $existingByEmployeeId[$employeeId] ?? null;
+            if (null === $workHour || $shouldSkip($workHour, $employeeId)) {
+                ++$result->skipped;
+                $result->skippedEmployeeIds[] = $employeeId;
+
+                continue;
+            }
+
+            $applyUpdate($workHour, $employeeId);
+            ++$result->updated;
+            $result->updatedEmployeeIds[] = $employeeId;
+        }
+
+        if ($result->updated > 0) {
+            $this->entityManager->flush();
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param list<mixed> $employeeIds
+     *
+     * @return list<int>
+     */
+    private function normalizeEmployeeIds(array $employeeIds): array
+    {
+        $normalized = [];
+        foreach ($employeeIds as $index => $rawId) {
+            $employeeId = (int) $rawId;
+            if ($employeeId <= 0) {
+                throw new UnprocessableEntityHttpException(sprintf('employeeIds[%d] must be a positive integer.', $index));
+            }
+
+            if (isset($normalized[$employeeId])) {
+                throw new UnprocessableEntityHttpException(sprintf('Employee %d appears multiple times in payload.', $employeeId));
+            }
+
+            $normalized[$employeeId] = $employeeId;
+        }
+
+        return array_values($normalized);
+    }
+}

src/State/WorkHourBulkSiteValidationProcessor.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\ApiResource\WorkHourBulkSiteValidation;
+use App\ApiResource\WorkHourBulkValidationResult;
+use App\Entity\User;
+use App\Entity\WorkHour;
+use App\Service\WorkHours\WorkHourBulkValidationExecutor;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+final readonly class WorkHourBulkSiteValidationProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private Security $security,
+        private WorkHourBulkValidationExecutor $executor,
+    ) {}
+
+    public function process(
+        mixed $data,
+        Operation $operation,
+        array $uriVariables = [],
+        array $context = []
+    ): WorkHourBulkValidationResult {
+        if (!$data instanceof WorkHourBulkSiteValidation) {
+            throw new BadRequestHttpException('Invalid payload.');
+        }
+
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            throw new AccessDeniedHttpException('Authentication required.');
+        }
+
+        if (in_array('ROLE_ADMIN', $user->getRoles(), true) || in_array('ROLE_SELF', $user->getRoles(), true)) {
+            throw new AccessDeniedHttpException('Only site managers can bulk update site validation.');
+        }
+
+        return $this->executor->execute(
+            user: $user,
+            workDateValue: $data->workDate,
+            employeeIds: $data->employeeIds,
+            shouldSkip: static fn (WorkHour $workHour): bool => $workHour->isValid() || $workHour->isSiteValid() === $data->isSiteValid,
+            applyUpdate: static function (WorkHour $workHour) use ($data): void {
+                $workHour->setIsSiteValid($data->isSiteValid);
+            }
+        );
+    }
+}

src/State/WorkHourBulkValidationProcessor.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\ApiResource\WorkHourBulkValidation;
+use App\ApiResource\WorkHourBulkValidationResult;
+use App\Entity\User;
+use App\Entity\WorkHour;
+use App\Service\WorkHours\WorkHourBulkValidationExecutor;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+final readonly class WorkHourBulkValidationProcessor implements ProcessorInterface
+{
+    public function __construct(
+        private Security $security,
+        private WorkHourBulkValidationExecutor $executor,
+    ) {}
+
+    public function process(
+        mixed $data,
+        Operation $operation,
+        array $uriVariables = [],
+        array $context = []
+    ): WorkHourBulkValidationResult {
+        if (!$data instanceof WorkHourBulkValidation) {
+            throw new BadRequestHttpException('Invalid payload.');
+        }
+
+        $user = $this->security->getUser();
+        if (!$user instanceof User) {
+            throw new AccessDeniedHttpException('Authentication required.');
+        }
+
+        if (!in_array('ROLE_ADMIN', $user->getRoles(), true)) {
+            throw new AccessDeniedHttpException('Only admins can bulk validate work hours.');
+        }
+
+        return $this->executor->execute(
+            user: $user,
+            workDateValue: $data->workDate,
+            employeeIds: $data->employeeIds,
+            shouldSkip: static fn (WorkHour $workHour): bool => $workHour->isValid() === $data->isValid,
+            applyUpdate: static function (WorkHour $workHour) use ($data): void {
+                $workHour->setIsValid($data->isValid);
+            }
+        );
+    }
+}