chore: bump version to v0.1.27

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.22'
+    app.version: '0.1.27'

doc/functional-rules.md

@@ -169,11 +169,13 @@ Tous les filtres checkbox sont cochés par défaut à l'ouverture du drawer.
         - acquis annuel samedi: `5`
         - en cours d'acquisition jours: `25/12 = 2,08` jours/mois
         - en cours d'acquisition samedis: `5/12 = 0,42` samedi/mois (non detaille en UI)
+        - en cas de début/fin en cours de mois, l'acquisition est proratisée au nombre de jours calendaires couverts dans le mois
         - samedis acquis affiches: uniquement `opening_saturdays` (report N-1)
       - contrat `4h`:
         - acquis annuel CP: `10`
         - acquis annuel samedi: `0`
         - en cours d'acquisition: `0.83` jour/mois
+        - en cas de début/fin en cours de mois, l'acquisition est proratisée au nombre de jours calendaires couverts dans le mois
       - contrat `FORFAIT`:
         - base annuelle: `jours ouvrés de l'exercice (lundi-vendredi, hors jours fériés métropole) - 218`
         - prorata: en cas de démarrage/fin de contrat en cours d'année civile, le calcul ne couvre que l'intervalle actif du contrat dans l'année
@@ -198,13 +200,16 @@ Tous les filtres checkbox sont cochés par défaut à l'ouverture du drawer.
       - lecture des compteurs:
         - `acquis` = droits reportés de l'exercice N-1 (après application des règles de soldé)
         - `en cours d'acquisition` = total droits générés sur l'exercice N (jours + samedis en cours), sans detail séparé en UI
+        - `en cours d'acquisition` est arrêté au dernier jour du mois précédent
       - règle de consommation:
         - les absences s'imputent d'abord sur `acquis`, puis sur `en cours d'acquisition`
         - la prise sur `en cours d'acquisition` est autorisée (usage anticipé)
         - `en cours d'acquisition` peut devenir négatif si la prise dépasse le généré (ex: `2.08 - 3 = -0.92`), puis se reconstitue avec les acquisitions suivantes
       - date d'arret de calcul:
-        - les compteurs sont calculés jusqu'au dernier jour du mois précédent (le mois en cours est exclu)
-        - exemple: au `04/03/2026`, l'arret de calcul est le `28/02/2026` (ou `29/02` en année bissextile)
+        - `reste à prendre` est calculé en prévisionnel jusqu'à la fin de l'exercice
+        - les absences futures déjà posées sur l'exercice sont déduites du `reste à prendre`
+        - `en cours d'acquisition` reste calculé jusqu'au dernier jour du mois précédent
+        - exemple: au `11/03/2026`, l'exercice `2026` déduit les absences posées jusqu'au `31/05/2026`, mais l'acquisition reste arrêtée au `28/02/2026`
     - hors périmètre phase 1: `INTERIM` (retour non supporté)
   - onglet `RTT`:
     - endpoint de synthèse: `GET /api/employees/{id}/rtt-summary?year=YYYY`

src/Service/Leave/LeaveBalanceComputationService.php

@@ -117,14 +117,14 @@ final readonly class LeaveBalanceComputationService
     {
         if (LeaveRuleCode::FORFAIT_218 === $ruleCode) {
             return [
-                new DateTimeImmutable(sprintf('%d-01-01', $year)),
-                new DateTimeImmutable(sprintf('%d-12-31', $year)),
+                new DateTimeImmutable(sprintf('%d-01-01 00:00:00', $year)),
+                new DateTimeImmutable(sprintf('%d-12-31 00:00:00', $year)),
             ];
         }
 
         return [
-            new DateTimeImmutable(sprintf('%d-06-01', $year - 1)),
-            new DateTimeImmutable(sprintf('%d-05-31', $year)),
+            new DateTimeImmutable(sprintf('%d-06-01 00:00:00', $year - 1)),
+            new DateTimeImmutable(sprintf('%d-05-31 00:00:00', $year)),
         ];
     }
 
@@ -145,7 +145,7 @@ final readonly class LeaveBalanceComputationService
 
         $oldestStartDate = null;
         foreach ($history as $item) {
-            $start = DateTimeImmutable::createFromFormat('Y-m-d', $item->startDate);
+            $start = $this->parseYmdDate($item->startDate);
             if (!$start) {
                 continue;
             }
@@ -197,14 +197,14 @@ final readonly class LeaveBalanceComputationService
     ): ?DateTimeImmutable {
         $earliest = null;
         foreach ($employee->getContractHistory() as $period) {
-            $start = DateTimeImmutable::createFromFormat('Y-m-d', $period->startDate);
+            $start = $this->parseYmdDate($period->startDate);
             if (!$start) {
                 continue;
             }
 
             $end = null;
             if (null !== $period->endDate && '' !== trim($period->endDate)) {
-                $end = DateTimeImmutable::createFromFormat('Y-m-d', $period->endDate);
+                $end = $this->parseYmdDate($period->endDate);
             }
 
             if ($start > $to) {
@@ -268,11 +268,37 @@ final readonly class LeaveBalanceComputationService
             return 0.0;
         }
 
-        $monthsElapsed = ((int) $periodEnd->format('Y') - (int) $periodStart->format('Y')) * 12
-            + ((int) $periodEnd->format('n') - (int) $periodStart->format('n'))
-            + 1;
+        $periodStart   = $this->normalizeDate($periodStart);
+        $periodEnd     = $this->normalizeDate($periodEnd);
+        $coveredMonths = 0.0;
+        $cursor        = $periodStart->modify('first day of this month')->setTime(0, 0);
+        while ($cursor <= $periodEnd) {
+            $monthStart = $cursor > $periodStart ? $cursor : $periodStart;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $periodEnd) {
+                $monthEnd = $periodEnd;
+            }
 
-        return min($annualCap, $monthsElapsed * $accrualPerMonth);
+            $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            $daysInMonth = (int) $cursor->format('t');
+            $coveredMonths += $coveredDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
+        }
+
+        return min($annualCap, $coveredMonths * $accrualPerMonth);
+    }
+
+    private function parseYmdDate(string $value): ?DateTimeImmutable
+    {
+        $date = DateTimeImmutable::createFromFormat('!Y-m-d', trim($value));
+
+        return $date instanceof DateTimeImmutable ? $date : null;
+    }
+
+    private function normalizeDate(DateTimeImmutable $date): DateTimeImmutable
+    {
+        return $date->setTime(0, 0);
     }
 
     private function countBusinessDays(DateTimeImmutable $from, DateTimeImmutable $to): int
@@ -349,14 +375,25 @@ final readonly class LeaveBalanceComputationService
             }
 
             for ($cursor = $rangeStart; $cursor <= $rangeEnd; $cursor = $cursor->modify('+1 day')) {
+                $dayOfWeek = (int) $cursor->format('N');
+
+                if ($splitSaturdays) {
+                    if (7 === $dayOfWeek) {
+                        continue;
+                    }
+                } else {
+                    if ($dayOfWeek >= 6) {
+                        continue;
+                    }
+                }
+
                 [$am, $pm] = $this->resolveSegmentsForDate($absence, $cursor->format('Y-m-d'));
                 $dayAmount = ($am ? 0.5 : 0.0) + ($pm ? 0.5 : 0.0);
                 if ($dayAmount <= 0.0) {
                     continue;
                 }
 
-                $isSaturday = $splitSaturdays && '6' === $cursor->format('N');
-                if ($isSaturday) {
+                if ($splitSaturdays && 6 === $dayOfWeek) {
                     $takenSaturdays += $dayAmount;
                 } else {
                     $takenDays += $dayAmount;

src/State/EmployeeLeaveSummaryProvider.php

@@ -163,18 +163,19 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
 
             $effectiveFrom   = $this->resolveEffectivePeriodStart($employee, $from, $to);
             $hasShiftedStart = $effectiveFrom > $from;
-            if ($hasShiftedStart) {
+            if ($hasShiftedStart && null === $openingBalance) {
                 $carryDays      = 0.0;
                 $carrySaturdays = 0.0;
             }
 
-            $calculationEnd = $this->resolveCalculationEndDate($leavePolicy['ruleCode'], $year, $to, $employee);
-            $generatedDays  = $leavePolicy['accrualPerMonth'] > 0.0
+            $accrualCalculationEnd = $this->resolveAccrualCalculationEndDate($leavePolicy['ruleCode'], $year, $to, $employee);
+            $takenCalculationEnd   = $this->resolveTakenCalculationEndDate($to, $employee);
+            $generatedDays         = $leavePolicy['accrualPerMonth'] > 0.0
                 ? $this->computeAccruedDaysFromStart(
                     $leavePolicy['acquiredDays'],
                     $leavePolicy['accrualPerMonth'],
                     $effectiveFrom,
-                    $calculationEnd
+                    $accrualCalculationEnd
                 )
                 : 0.0;
             $generatedSaturdays = $leavePolicy['saturdayAccrualPerMonth'] > 0.0
@@ -182,14 +183,14 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
                     $leavePolicy['acquiredSaturdays'],
                     $leavePolicy['saturdayAccrualPerMonth'],
                     $effectiveFrom,
-                    $calculationEnd
+                    $accrualCalculationEnd
                 )
                 : 0.0;
             $absences                     = $this->absenceRepository->findByEmployeeAndOverlappingDateRange($employee, $from, $to);
             [$takenDays, $takenSaturdays] = $this->computeTakenAbsences(
                 $absences,
                 $effectiveFrom,
-                $calculationEnd,
+                $takenCalculationEnd,
                 $leavePolicy['countOnlyCp'],
                 $leavePolicy['splitSaturdays']
             );
@@ -279,14 +280,14 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
     ): ?DateTimeImmutable {
         $earliest = null;
         foreach ($employee->getContractHistory() as $period) {
-            $start = DateTimeImmutable::createFromFormat('Y-m-d', $period->startDate);
+            $start = $this->parseYmdDate($period->startDate);
             if (!$start instanceof DateTimeImmutable) {
                 continue;
             }
 
             $end = null;
             if (null !== $period->endDate && '' !== trim($period->endDate)) {
-                $end = DateTimeImmutable::createFromFormat('Y-m-d', $period->endDate);
+                $end = $this->parseYmdDate($period->endDate);
             }
 
             if ($start > $to) {
@@ -343,17 +344,28 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
             return 0.0;
         }
 
-        $monthsElapsed = ((int) $periodEnd->format('Y') - (int) $periodStart->format('Y')) * 12
-            + ((int) $periodEnd->format('n') - (int) $periodStart->format('n'))
-            + 1;
-        if ($monthsElapsed < 0) {
-            return 0.0;
+        $periodStart   = $this->normalizeDate($periodStart);
+        $periodEnd     = $this->normalizeDate($periodEnd);
+        $coveredMonths = 0.0;
+        $cursor        = $periodStart->modify('first day of this month')->setTime(0, 0);
+        while ($cursor <= $periodEnd) {
+            $monthStart = $cursor > $periodStart ? $cursor : $periodStart;
+            $monthEnd   = $cursor->modify('last day of this month')->setTime(0, 0);
+            if ($monthEnd > $periodEnd) {
+                $monthEnd = $periodEnd;
+            }
+
+            $coveredDays = ((int) $monthEnd->diff($monthStart)->format('%a')) + 1;
+            $daysInMonth = (int) $cursor->format('t');
+            $coveredMonths += $coveredDays / $daysInMonth;
+
+            $cursor = $cursor->modify('first day of next month');
         }
 
-        return min($acquiredDays, $monthsElapsed * $accrualPerMonth);
+        return min($acquiredDays, $coveredMonths * $accrualPerMonth);
     }
 
-    private function resolveCalculationEndDate(
+    private function resolveAccrualCalculationEndDate(
         string $ruleCode,
         int $year,
         DateTimeImmutable $periodEnd,
@@ -372,6 +384,7 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
             $lastDayPreviousMonth = $today
                 ->modify('first day of this month')
                 ->modify('-1 day')
+                ->setTime(0, 0)
             ;
             $end = $lastDayPreviousMonth < $periodEnd ? $lastDayPreviousMonth : $periodEnd;
         }
@@ -379,7 +392,25 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         // Cap at contract end date if the employee has left.
         $contractEndRaw = $employee->getCurrentContractEndDate();
         if (null !== $end && null !== $contractEndRaw && '' !== trim($contractEndRaw)) {
-            $contractEnd = DateTimeImmutable::createFromFormat('Y-m-d', $contractEndRaw);
+            $contractEnd = $this->parseYmdDate($contractEndRaw);
+            if ($contractEnd instanceof DateTimeImmutable && $contractEnd < $end) {
+                $end = $contractEnd;
+            }
+        }
+
+        return $end;
+    }
+
+    private function resolveTakenCalculationEndDate(
+        DateTimeImmutable $periodEnd,
+        Employee $employee
+    ): ?DateTimeImmutable {
+        $end = $periodEnd;
+
+        // Cap at contract end date if the employee has left.
+        $contractEndRaw = $employee->getCurrentContractEndDate();
+        if (null !== $end && null !== $contractEndRaw && '' !== trim($contractEndRaw)) {
+            $contractEnd = $this->parseYmdDate($contractEndRaw);
             if ($contractEnd instanceof DateTimeImmutable && $contractEnd < $end) {
                 $end = $contractEnd;
             }
@@ -501,8 +532,8 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
     private function resolveLeavePeriodBounds(int $leaveYear): array
     {
         // Exercice CP "2026" = du 1er juin 2025 au 31 mai 2026.
-        $from = new DateTimeImmutable(sprintf('%d-06-01', $leaveYear - 1));
-        $to   = new DateTimeImmutable(sprintf('%d-05-31', $leaveYear));
+        $from = new DateTimeImmutable(sprintf('%d-06-01 00:00:00', $leaveYear - 1));
+        $to   = new DateTimeImmutable(sprintf('%d-05-31 00:00:00', $leaveYear));
 
         return [$from, $to];
     }
@@ -512,12 +543,12 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
      */
     private function resolveForfaitYearBounds(Employee $employee, int $year): array
     {
-        $from = new DateTimeImmutable(sprintf('%d-01-01', $year));
-        $to   = new DateTimeImmutable(sprintf('%d-12-31', $year));
+        $from = new DateTimeImmutable(sprintf('%d-01-01 00:00:00', $year));
+        $to   = new DateTimeImmutable(sprintf('%d-12-31 00:00:00', $year));
 
         $contractStartRaw = $employee->getCurrentContractStartDate();
         if (null !== $contractStartRaw && '' !== trim($contractStartRaw)) {
-            $contractStart = DateTimeImmutable::createFromFormat('Y-m-d', $contractStartRaw);
+            $contractStart = $this->parseYmdDate($contractStartRaw);
             if ($contractStart instanceof DateTimeImmutable && $contractStart > $from) {
                 $from = $contractStart;
             }
@@ -525,7 +556,7 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
 
         $contractEndRaw = $employee->getCurrentContractEndDate();
         if (null !== $contractEndRaw && '' !== trim($contractEndRaw)) {
-            $contractEnd = DateTimeImmutable::createFromFormat('Y-m-d', $contractEndRaw);
+            $contractEnd = $this->parseYmdDate($contractEndRaw);
             if ($contractEnd instanceof DateTimeImmutable && $contractEnd < $to) {
                 $to = $contractEnd;
             }
@@ -563,7 +594,7 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
 
         $oldestStartDate = null;
         foreach ($history as $item) {
-            $start = DateTimeImmutable::createFromFormat('Y-m-d', $item->startDate);
+            $start = $this->parseYmdDate($item->startDate);
             if (!$start) {
                 continue;
             }
@@ -592,6 +623,18 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
         return $firstYear;
     }
 
+    private function parseYmdDate(string $value): ?DateTimeImmutable
+    {
+        $date = DateTimeImmutable::createFromFormat('!Y-m-d', trim($value));
+
+        return $date instanceof DateTimeImmutable ? $date : null;
+    }
+
+    private function normalizeDate(DateTimeImmutable $date): DateTimeImmutable
+    {
+        return $date->setTime(0, 0);
+    }
+
     /**
      * @param list<Absence> $absences
      *
@@ -632,14 +675,27 @@ final readonly class EmployeeLeaveSummaryProvider implements ProviderInterface
             }
 
             for ($cursor = $rangeStart; $cursor <= $rangeEnd; $cursor = $cursor->modify('+1 day')) {
+                $dayOfWeek = (int) $cursor->format('N');
+
+                if ($splitSaturdays) {
+                    // Mode CDI/CDD : dimanche ignoré, samedi compté séparément.
+                    if (7 === $dayOfWeek) {
+                        continue;
+                    }
+                } else {
+                    // Mode forfait : seuls les jours ouvrés (lun-ven) comptent.
+                    if ($dayOfWeek >= 6) {
+                        continue;
+                    }
+                }
+
                 [$am, $pm] = $this->resolveSegmentsForDate($absence, $cursor->format('Y-m-d'));
                 $dayAmount = ($am ? 0.5 : 0.0) + ($pm ? 0.5 : 0.0);
                 if ($dayAmount <= 0.0) {
                     continue;
                 }
 
-                $isSaturday = $splitSaturdays && '6' === $cursor->format('N');
-                if ($isSaturday && $splitSaturdays) {
+                if ($splitSaturdays && 6 === $dayOfWeek) {
                     $takenSaturdays += $dayAmount;
                 } else {
                     $takenDays += $dayAmount;

tests/Service/Leave/LeaveBalanceComputationServiceTest.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service\Leave;
+
+use App\Service\Leave\LeaveBalanceComputationService;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+
+/**
+ * @internal
+ */
+final class LeaveBalanceComputationServiceTest extends TestCase
+{
+    public function testComputeAccruedDaysProratesPartialFirstMonth(): void
+    {
+        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
+
+        $result = $method->invoke(
+            $service,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+
+        self::assertEqualsWithDelta(18.125, $result, 0.0001);
+    }
+
+    public function testComputeAccruedDaysTotalMatchesAlainCase(): void
+    {
+        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
+
+        $days = $method->invoke(
+            $service,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+        $saturdays = $method->invoke(
+            $service,
+            5.0,
+            5.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+
+        self::assertEqualsWithDelta(21.75, $days + $saturdays, 0.0001);
+    }
+
+    public function testComputeAccruedDaysIncludesLastDayOfMonthDespiteTimeComponents(): void
+    {
+        $service = new ReflectionClass(LeaveBalanceComputationService::class)->newInstanceWithoutConstructor();
+        $method  = new ReflectionClass(LeaveBalanceComputationService::class)->getMethod('computeAccruedDays');
+
+        $result = $method->invoke(
+            $service,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2026-02-01 12:50:18'),
+            new DateTimeImmutable('2026-02-28 00:00:00')
+        );
+
+        self::assertEqualsWithDelta(25.0 / 12.0, $result, 0.0001);
+    }
+}

tests/State/EmployeeLeaveSummaryProviderTest.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\State;
+
+use App\State\EmployeeLeaveSummaryProvider;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+
+/**
+ * @internal
+ */
+final class EmployeeLeaveSummaryProviderTest extends TestCase
+{
+    public function testComputeAccruedDaysFromStartProratesPartialFirstMonth(): void
+    {
+        $provider = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->newInstanceWithoutConstructor();
+        $method   = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->getMethod('computeAccruedDaysFromStart');
+
+        $result = $method->invoke(
+            $provider,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+
+        self::assertEqualsWithDelta(18.125, $result, 0.0001);
+    }
+
+    public function testComputeAccruingDaysTotalMatchesAlainCase(): void
+    {
+        $provider = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->newInstanceWithoutConstructor();
+        $method   = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->getMethod('computeAccruedDaysFromStart');
+
+        $days = $method->invoke(
+            $provider,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+        $saturdays = $method->invoke(
+            $provider,
+            5.0,
+            5.0 / 12.0,
+            new DateTimeImmutable('2025-06-10'),
+            new DateTimeImmutable('2026-02-28')
+        );
+
+        self::assertEqualsWithDelta(21.75, $days + $saturdays, 0.0001);
+    }
+
+    public function testComputeAccruedDaysFromStartIncludesLastDayOfMonth(): void
+    {
+        $provider = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->newInstanceWithoutConstructor();
+        $method   = new ReflectionClass(EmployeeLeaveSummaryProvider::class)->getMethod('computeAccruedDaysFromStart');
+
+        $result = $method->invoke(
+            $provider,
+            25.0,
+            25.0 / 12.0,
+            new DateTimeImmutable('2026-02-01 12:50:18'),
+            new DateTimeImmutable('2026-02-28 00:00:00')
+        );
+
+        self::assertEqualsWithDelta(25.0 / 12.0, $result, 0.0001);
+    }
+}