feat : ajout des suspensions et des jours de présence

src/State/ContractSuspensionWriteProcessor.php

@@ -0,0 +1,122 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\State;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Entity\ContractSuspension;
+use App\Entity\EmployeeContractPeriod;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+final readonly class ContractSuspensionWriteProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private ProcessorInterface $persistProcessor,
+        private EntityManagerInterface $entityManager,
+    ) {}
+
+    public function process(
+        mixed $data,
+        Operation $operation,
+        array $uriVariables = [],
+        array $context = []
+    ): mixed {
+        if (!$data instanceof ContractSuspension) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $period = $data->getContractPeriod();
+
+        if (!$period instanceof EmployeeContractPeriod && null !== $data->getContractPeriodId()) {
+            $period = $this->entityManager->find(EmployeeContractPeriod::class, $data->getContractPeriodId());
+            if ($period instanceof EmployeeContractPeriod) {
+                $data->setContractPeriod($period);
+            }
+        }
+
+        if (!$period instanceof EmployeeContractPeriod) {
+            throw new UnprocessableEntityHttpException('contractPeriodId is required.');
+        }
+
+        $this->validate($data, $period);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    private function validate(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        // Compare as Y-m-d strings to avoid timezone issues between Doctrine and API Platform DateTimeImmutable
+        $startDate   = $suspension->getStartDate()->format('Y-m-d');
+        $endDate     = $suspension->getEndDate()?->format('Y-m-d');
+        $periodStart = $period->getStartDate()->format('Y-m-d');
+        $periodEnd   = $period->getEndDate()?->format('Y-m-d');
+
+        if (null !== $periodEnd && $periodEnd < new DateTimeImmutable('today')->format('Y-m-d')) {
+            throw new UnprocessableEntityHttpException('Impossible de suspendre une période de contrat clôturée.');
+        }
+
+        if (null !== $endDate && $endDate < $startDate) {
+            throw new UnprocessableEntityHttpException('La date de fin doit être postérieure à la date de début.');
+        }
+
+        if ($startDate < $periodStart) {
+            throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer avant le début du contrat.');
+        }
+
+        if (null !== $periodEnd) {
+            if ($startDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas commencer après la fin du contrat.');
+            }
+            if (null !== $endDate && $endDate > $periodEnd) {
+                throw new UnprocessableEntityHttpException('La suspension ne peut pas se terminer après la fin du contrat.');
+            }
+        }
+
+        $this->validateNoOverlap($suspension, $period);
+    }
+
+    private function validateNoOverlap(ContractSuspension $suspension, EmployeeContractPeriod $period): void
+    {
+        $start = $suspension->getStartDate()->format('Y-m-d');
+        $end   = $suspension->getEndDate()?->format('Y-m-d');
+
+        foreach ($period->getSuspensions() as $existing) {
+            if ($existing->getId() === $suspension->getId() && null !== $suspension->getId()) {
+                continue;
+            }
+
+            $existingStart = $existing->getStartDate()->format('Y-m-d');
+            $existingEnd   = $existing->getEndDate()?->format('Y-m-d');
+
+            if (null === $end && null === $existingEnd) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+
+            if (null === $end) {
+                if ($start <= $existingEnd) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+
+                continue;
+            }
+
+            if (null === $existingEnd) {
+                if ($existingStart <= $end) {
+                    throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+                }
+
+                continue;
+            }
+
+            if ($start <= $existingEnd && $end >= $existingStart) {
+                throw new UnprocessableEntityHttpException('Les suspensions ne peuvent pas se chevaucher.');
+            }
+        }
+    }
+}

src/State/EmployeeLeaveSummaryProvider.php

@@ -8,6 +8,7 @@ use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProviderInterface;
 use App\ApiResource\EmployeeLeaveSummary;
 use App\Entity\Absence;
+use App\Entity\ContractSuspension;
 use App\Entity\Employee;
 use App\Entity\User;
 use App\Enum\ContractNature;
@@ -17,8 +18,10 @@ use App\Repository\AbsenceRepository;
 use App\Repository\EmployeeContractPeriodRepository;
 use App\Repository\EmployeeLeaveBalanceRepository;
 use App\Repository\EmployeeRepository;
+use App\Repository\WorkHourRepository;
 use App\Security\EmployeeScopeService;
 use App\Service\Leave\LeaveBalanceComputationService;
+use App\Service\Leave\SuspensionDaysCalculator;
 use App\Service\PublicHolidayServiceInterface;
 use DateTimeImmutable;
 use Symfony\Bundle\SecurityBundle\Security;
@@ -50,6 +53,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         private EmployeeLeaveBalanceRepository $leaveBalanceRepository,
         private LeaveBalanceComputationService $leaveBalanceComputationService,
         private PublicHolidayServiceInterface $publicHolidayService,
+        private SuspensionDaysCalculator $suspensionDaysCalculator,
+        private WorkHourRepository $workHourRepository,
     ) {}
 
     public function provide(Operation $operation, array $uriVariables = [], array $context = []): EmployeeLeaveSummary
@@ -97,6 +102,9 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         $summary->remainingDays      = $yearSummary['remainingDays'] + $fractionedDays;
         $summary->remainingSaturdays = $yearSummary['remainingSaturdays'];
 
+        [$periodFrom, $periodTo]      = $this->resolvePeriodBounds($employee, $year);
+        $summary->presenceDaysByMonth = $this->workHourRepository->countPresenceDaysByMonth($employee, $periodFrom, $periodTo);
+
         return $summary;
     }
 
@@ -170,12 +178,14 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
 
             $accrualCalculationEnd = $this->resolveAccrualCalculationEndDate($leavePolicy['ruleCode'], $year, $to, $employee);
             $takenCalculationEnd   = $this->resolveTakenCalculationEndDate($to, $employee);
+            $suspensions           = $this->resolveSuspensionsForPeriod($employee, $effectiveFrom, $to);
             $generatedDays         = $leavePolicy['accrualPerMonth'] > 0.0
                 ? $this->computeAccruedDaysFromStart(
                     $leavePolicy['acquiredDays'],
                     $leavePolicy['accrualPerMonth'],
                     $effectiveFrom,
-                    $accrualCalculationEnd
+                    $accrualCalculationEnd,
+                    $suspensions
                 )
                 : 0.0;
             $generatedSaturdays = $leavePolicy['saturdayAccrualPerMonth'] > 0.0
@@ -183,7 +193,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
                     $leavePolicy['acquiredSaturdays'],
                     $leavePolicy['saturdayAccrualPerMonth'],
                     $effectiveFrom,
-                    $accrualCalculationEnd
+                    $accrualCalculationEnd,
+                    $suspensions
                 )
                 : 0.0;
             $absences                     = $this->absenceRepository->findByEmployeeAndOverlappingDateRange($employee, $from, $to);
@@ -224,7 +235,16 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
                 $previousRemainingSaturdays = $remainingAcquiredSaturdays + $remainingGeneratedSaturdays;
             } else {
                 // Forfait: no "en cours d'acquisition" counter, all rights are in acquired.
-                $acquiredDays       = $carryDays + $leavePolicy['acquiredDays'];
+                $acquiredDays = $carryDays + $leavePolicy['acquiredDays'];
+                $suspensions  = $this->resolveSuspensionsForPeriod($employee, $from, $to);
+                if ([] !== $suspensions) {
+                    $totalMonths     = $this->countFractionalMonths($from, $to);
+                    $suspendedMonths = $this->countSuspendedFractionalMonths($from, $to, $suspensions);
+                    if ($totalMonths > 0) {
+                        $ratio        = max(0.0, ($totalMonths - $suspendedMonths) / $totalMonths);
+                        $acquiredDays = $carryDays + $leavePolicy['acquiredDays'] * $ratio;
+                    }
+                }
                 $accruingDays       = 0.0;
                 $remainingDays      = max(0.0, $acquiredDays - $takenDays);
                 $acquiredSaturdays  = 0.0;
@@ -334,7 +354,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         float $acquiredDays,
         float $accrualPerMonth,
         DateTimeImmutable $periodStart,
-        ?DateTimeImmutable $periodEnd
+        ?DateTimeImmutable $periodEnd,
+        array $suspensions = []
     ): float {
         if ($accrualPerMonth <= 0.0) {
             return $acquiredDays;
@@ -356,6 +377,10 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
             }
 
             $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            if ([] !== $suspensions) {
+                $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+                $coveredDays   = max(0, $coveredDays - $suspendedDays);
+            }
             $daysInMonth = (int) $cursor->format('t');
             $coveredMonths += $coveredDays / $daysInMonth;
 
@@ -706,6 +731,80 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         return [$takenDays, $takenSaturdays];
     }
 
+    private function countFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            $daysInMonth = (int) $cursor->format('t');
+            $months += $coveredDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @param list<ContractSuspension> $suspensions
+     */
+    private function countSuspendedFractionalMonths(DateTimeImmutable $from, DateTimeImmutable $to, array $suspensions): float
+    {
+        $from   = $this->normalizeDate($from);
+        $to     = $this->normalizeDate($to);
+        $months = 0.0;
+        $cursor = $from->modify('first day of this month')->setTime(0, 0);
+
+        while ($cursor <= $to) {
+            $monthStart = $cursor > $from ? $cursor : $from;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $to) {
+                $monthEnd = $to;
+            }
+            $daysInMonth   = (int) $cursor->format('t');
+            $suspendedDays = $this->suspensionDaysCalculator->countSuspendedDaysInMonth($monthStart, $monthEnd, $suspensions);
+            $months += $suspendedDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return $months;
+    }
+
+    /**
+     * @return list<ContractSuspension>
+     */
+    private function resolveSuspensionsForPeriod(Employee $employee, DateTimeImmutable $from, DateTimeImmutable $to): array
+    {
+        $suspensions = [];
+        foreach ($employee->getContractPeriods() as $period) {
+            $periodStart = $period->getStartDate();
+            $periodEnd   = $period->getEndDate();
+
+            if ($periodStart > $to) {
+                continue;
+            }
+            if ($periodEnd instanceof DateTimeImmutable && $periodEnd < $from) {
+                continue;
+            }
+
+            foreach ($period->getSuspensions() as $suspension) {
+                $suspensions[] = $suspension;
+            }
+        }
+
+        return $suspensions;
+    }
+
     /**
      * @return array{bool, bool}
      */