Retour RH: vue jour par date, RTT mi-semaine, récap salaire & exports, panier de nuit (#21)

## Correctifs RH (branche fix/retour-rh) ### Vue Jour (Heures) - Mode saisie/présence, libellé de contrat et sauvegarde résolus **à la date affichée** (et non au contrat courant). Corrige les salariés passés 39h/35h → Forfait. ### RTT — heures supplémentaires - Proratisation du **plafond 25%/50%** pour les embauches en milieu de semaine (la bande +25% se décale au lieu de rester bloquée à 43h). Témoin Dylan : 4h à 25% + 3h à 50%. ### Récap salaire (PDF mensuel) - Forfait : congés imputés **N-1** non affichés et comptés en présence. - Colonne « Heures payés » **scindée 25% / 50%** (en-tête fusionné). - **Exclusion des salariés sans contrat** sur le mois (ex. Marine, contrat terminé). ### Exports heures annuelles (par salarié + tous) - **Tous les jours sous contrat** affichés, même vides/non saisis (corrige les lignes manquantes). - Samedis/dimanches en **gris plus foncé**. ### Panier de nuit - **Ne s'applique pas aux conducteurs** (vue semaine + récap salaire). ## Tests - 11 tests ajoutés. Suite verte hors un test legacy pré-existant dépendant de la date (`EmployeeRttSummaryProviderTest::testNoQueryParamsKeepsLegacyYearDefaulting`, non modifié par cette branche). ## À noter (hors scope) - L'export heures annuelles *tous salariés* peut dépasser `memory_limit=256M` (Dompdf) — limitation **pré-existante**, non corrigée ici. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Reviewed-on: #21 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>
2026-06-02 06:26:40 +00:00
parent 8b34a429cc
commit a41bd632cf
21 changed files with 933 additions and 42 deletions
@@ -0,0 +1,307 @@
+# Vue Jour — contrat résolu à la date affichée — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Faire que l'écran Heures — vue Jour affiche/sauvegarde la saisie d'heures (TIME) vs cases de présence (PRESENCE) et le libellé de contrat selon le contrat valable **à la date affichée**, et non le contrat courant de l'employé.
+
+**Architecture:** Le provider backend `WorkHourDayContextProvider` résout déjà le contrat à la date demandée. On expose 4 champs de contrat supplémentaires sur la ligne du jour (`DayContextRow`), on les reflète dans le DTO TS, puis le composable `useHoursPage` lit ces champs par date (fallback sur `employee.contract` si pas de ligne du jour). `handleSave` en hérite automatiquement.
+
+**Tech Stack:** Symfony / API Platform (PHP 8.4, PHPUnit) côté backend ; Nuxt 4 / Vue 3 / TypeScript côté frontend.
+
+Spec : `docs/superpowers/specs/2026-06-01-day-view-per-date-tracking-mode-design.md`
+
+---
+
+## File Structure
+
+- `src/Dto/WorkHours/DayContextRow.php` — DTO ligne du jour : +4 champs.
+- `src/State/WorkHourDayContextProvider.php` — peuple les 4 champs depuis le contrat du jour.
+- `tests/State/WorkHourDayContextProviderTest.php` — test de résolution par date.
+- `frontend/services/dto/work-hour.ts` — type `WorkHourDayContextRow` : +4 champs.
+- `frontend/composables/useHoursPage.ts` — helpers résolus par date.
+- `doc/` + `frontend/data/documentation-content.ts` + `CLAUDE.md` — documentation.
+
+---
+
+### Task 1: Backend — exposer le contrat du jour sur `DayContextRow`
+
+**Files:**
+- Modify: `src/Dto/WorkHours/DayContextRow.php`
+- Modify: `src/State/WorkHourDayContextProvider.php:60-71`
+- Test: `tests/State/WorkHourDayContextProviderTest.php`
+
+- [ ] **Step 1: Écrire le test en échec**
+
+Ajouter cette méthode dans `tests/State/WorkHourDayContextProviderTest.php` (après `testBuildsRowsWithAbsenceCredits`). Elle vérifie que la ligne porte le contrat **à la date demandée** pour un employé 39h→Forfait. On remplace le resolver stub par un callback dépendant de la date.
+
+```php
+public function testRowCarriesContractAtRequestedDate(): void
+{
+    $user = new User();
+
+    $timeContract = new Contract()
+        ->setName('Contrat')
+        ->setTrackingMode(Contract::TRACKING_TIME)
+        ->setWeeklyHours(39)
+    ;
+    $forfaitContract = new Contract()
+        ->setName('Forfait')
+        ->setTrackingMode(Contract::TRACKING_PRESENCE)
+        ->setWeeklyHours(null)
+    ;
+    $employee = new Employee()
+        ->setFirstName('Jean')
+        ->setLastName('Test')
+        ->setContract($forfaitContract)
+    ;
+    $this->setEntityId($employee, 1);
+
+    // Resolver renvoie le contrat 39h avant 2026-03-01, le forfait à partir de cette date.
+    $resolver = $this->createStub(EmployeeContractResolver::class);
+    $resolver->method('resolveForEmployeeAndDate')->willReturnCallback(
+        static fn (Employee $e, \DateTimeImmutable $d): ?Contract =>
+            $d < new \DateTimeImmutable('2026-03-01') ? $timeContract : $forfaitContract
+    );
+    $resolver->method('resolveNatureForEmployeeAndDate')->willReturn(ContractNature::CDI);
+
+    $this->requestStack->push(new Request(query: ['workDate' => '2026-02-16']));
+    $this->security->method('getUser')->willReturn($user);
+    $this->employeeRepository->method('findScoped')->with($user)->willReturn([$employee]);
+    $this->absenceRepository->method('findByDateAndEmployees')->willReturn([]);
+
+    $provider = new WorkHourDayContextProvider(
+        $this->security,
+        $this->requestStack,
+        $this->employeeRepository,
+        $this->absenceRepository,
+        $this->formationRepository,
+        $resolver,
+        new AbsenceSegmentsResolver(),
+        new WorkedHoursCreditPolicy($this->buildResolverStub(), new DailyReferenceMinutesResolver()),
+        $this->buildHolidayResolver(),
+    );
+
+    $row = $provider->provide(new Get())->rows[0];
+
+    self::assertSame('TIME', $row['trackingMode']);
+    self::assertSame(39, $row['weeklyHours']);
+    self::assertSame('39H', $row['contractType']);
+    self::assertSame('Contrat', $row['contractName']);
+}
+```
+
+- [ ] **Step 2: Lancer le test, vérifier l'échec**
+
+Run: `make test`
+Expected: FAIL — `Undefined array key "trackingMode"` (le DTO ne porte pas encore le champ).
+
+- [ ] **Step 3: Ajouter les 4 champs au DTO**
+
+Dans `src/Dto/WorkHours/DayContextRow.php`, ajouter au constructeur après `public ?string $contractNature = null,` :
+
+```php
+        public ?string $trackingMode = null,
+        public ?int $weeklyHours = null,
+        public ?string $contractType = null,
+        public ?string $contractName = null,
+```
+
+Mettre à jour le PHPDoc de `toArray()` (ajouter les 4 clés après `contractNature:?string`) :
+
+```php
+     *     contractNature:?string,
+     *     trackingMode:?string,
+     *     weeklyHours:?int,
+     *     contractType:?string,
+     *     contractName:?string
+```
+
+Et le corps de `toArray()`, après `'contractNature' => $this->contractNature,` :
+
+```php
+            'trackingMode'          => $this->trackingMode,
+            'weeklyHours'           => $this->weeklyHours,
+            'contractType'          => $this->contractType,
+            'contractName'          => $this->contractName,
+```
+
+- [ ] **Step 4: Peupler les champs dans le provider**
+
+Dans `src/State/WorkHourDayContextProvider.php`, dans l'appel `new DayContextRow(...)` (lignes 65-71), ajouter après `contractNature: $contractNature,` :
+
+```php
+                trackingMode: $contract?->getTrackingMode(),
+                weeklyHours: $contract?->getWeeklyHours(),
+                contractType: $contract?->getType()->value,
+                contractName: $contract?->getName(),
+```
+
+- [ ] **Step 5: Lancer le test, vérifier le succès**
+
+Run: `make test`
+Expected: PASS (le nouveau test et les 150 autres ; le test legacy `EmployeeRttSummaryProviderTest::testNoQueryParamsKeepsLegacyYearDefaulting` peut rester rouge — pré-existant, dépendant de la date, hors périmètre).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/Dto/WorkHours/DayContextRow.php src/State/WorkHourDayContextProvider.php tests/State/WorkHourDayContextProviderTest.php
+git commit -m "[#SIRH] Vue jour: exposer le contrat du jour sur DayContextRow"
+```
+
+---
+
+### Task 2: Frontend — lire le contrat par date dans la vue Jour
+
+**Files:**
+- Modify: `frontend/services/dto/work-hour.ts:103-118`
+- Modify: `frontend/composables/useHoursPage.ts`
+
+- [ ] **Step 1: Refléter les 4 champs dans le DTO TS**
+
+Dans `frontend/services/dto/work-hour.ts`, type `WorkHourDayContextRow`, ajouter après `contractNature?: ...` (ligne 117) :
+
+```typescript
+  trackingMode?: TrackingMode | null
+  weeklyHours?: number | null
+  contractType?: string | null
+  contractName?: string | null
+```
+
+(`TrackingMode` est déjà importé dans ce fichier — utilisé ligne 73.)
+
+- [ ] **Step 2: Ajouter un résolveur de contrat par date dans le composable**
+
+Dans `frontend/composables/useHoursPage.ts`, juste avant `const isPresenceTracking` (ligne 353), insérer :
+
+```typescript
+  // Résout le contrat à la date affichée (ligne du jour), avec repli sur le contrat courant.
+  const resolveDayContract = (employee: Employee) => {
+    const dayRow = dayContextByEmployeeId.value.get(employee.id)
+    if (dayRow?.hasContractAtDate) {
+      return {
+        trackingMode: dayRow.trackingMode ?? null,
+        weeklyHours: dayRow.weeklyHours ?? null,
+        type: dayRow.contractType ?? null,
+        name: dayRow.contractName ?? ''
+      }
+    }
+    return {
+      trackingMode: employee.contract?.trackingMode ?? null,
+      weeklyHours: employee.contract?.weeklyHours ?? null,
+      type: employee.contract?.type ?? null,
+      name: employee.contract?.name ?? ''
+    }
+  }
+```
+
+- [ ] **Step 3: Brancher les helpers sur le contrat du jour**
+
+Toujours dans `frontend/composables/useHoursPage.ts`, remplacer les définitions actuelles (lignes 353-358 et 367-377).
+
+Remplacer :
+
+```typescript
+  const isPresenceTracking = (employee: Employee) => employee.contract?.trackingMode === TRACKING_MODES.PRESENCE
+  const isTimeTracking = (employee: Employee) => !isPresenceTracking(employee)
+  const is4hContract = (employeeId: number) => {
+    const employee = employees.value.find((e) => e.id === employeeId)
+    return employee?.contract?.weeklyHours === 4
+  }
+```
+
+par :
+
+```typescript
+  const isPresenceTracking = (employee: Employee) => resolveDayContract(employee).trackingMode === TRACKING_MODES.PRESENCE
+  const isTimeTracking = (employee: Employee) => !isPresenceTracking(employee)
+  const is4hContract = (employeeId: number) => {
+    const employee = employees.value.find((e) => e.id === employeeId)
+    return employee ? resolveDayContract(employee).weeklyHours === 4 : false
+  }
+```
+
+Remplacer :
+
+```typescript
+  const contractLabel = (employee: Employee) => {
+    const contract = employee.contract
+    if (!contract) return '-'
+    if (contract.type === CONTRACT_TYPES.INTERIM) {
+      return contract.name
+    }
+    if (contract.weeklyHours !== null && contract.weeklyHours !== undefined && contract.trackingMode === TRACKING_MODES.TIME) {
+      return `${contract.weeklyHours}h`
+    }
+    return contract.name
+  }
+```
+
+par :
+
+```typescript
+  const contractLabel = (employee: Employee) => {
+    const contract = resolveDayContract(employee)
+    if (!contract.type && !contract.name) return '-'
+    if (contract.type === CONTRACT_TYPES.INTERIM) {
+      return contract.name
+    }
+    if (contract.weeklyHours !== null && contract.weeklyHours !== undefined && contract.trackingMode === TRACKING_MODES.TIME) {
+      return `${contract.weeklyHours}h`
+    }
+    return contract.name
+  }
+```
+
+- [ ] **Step 4: Vérification statique de lecture**
+
+Relire le diff : `resolveDayContract` est défini après `dayContextByEmployeeId` (ligne 201) et `employees` — donc disponible. `isPresenceTracking` reste de signature `(employee: Employee)` ⇒ aucun appelant à modifier (`HoursDayView.vue`, `handleSave` ligne 1073 inchangés). `CONTRACT_TYPES`/`TRACKING_MODES` déjà importés (ligne 8).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add frontend/services/dto/work-hour.ts frontend/composables/useHoursPage.ts
+git commit -m "[#SIRH] Vue jour: saisie/présence et libellé résolus à la date affichée"
+```
+
+---
+
+### Task 3: Documentation
+
+**Files:**
+- Modify: `doc/functional-rules.md`
+- Modify: `frontend/data/documentation-content.ts`
+- Modify: `CLAUDE.md`
+
+- [ ] **Step 1: Doc fonctionnelle**
+
+Il n'existe pas de doc dédiée « Heures » dans `doc/` ; ajouter le paragraphe suivant dans `doc/functional-rules.md` (section traitant des écrans Heures / du contrat, ou en fin de fichier sous un titre `## Vue Jour — contrat à la date affichée`) :
+
+> **Vue Jour (Heures) — contrat à la date affichée** : le mode de suivi (saisie d'heures vs cases de présence), le libellé de contrat et la logique de sauvegarde sont résolus selon la période de contrat valable à la date filtrée (champs `trackingMode`/`weeklyHours`/`contractType`/`contractName` portés par `WorkHourDayContext`), et non selon le contrat courant de l'employé. Un salarié passé 39h/35h → Forfait conserve donc la saisie d'heures sur ses dates antérieures à la bascule, et bascule en cases de présence à partir de la date de passage en forfait.
+
+- [ ] **Step 2: Doc in-app**
+
+Dans `frontend/data/documentation-content.ts`, repérer la section/article de l'écran « Heures » (`grep -n "Heures" frontend/data/documentation-content.ts`) et ajouter un bloc texte :
+
+> Sur la vue Jour, l'affichage (saisie d'heures ou présence) et le libellé de contrat correspondent au contrat de l'employé à la date consultée. Si un salarié a changé de type de contrat (ex. passage en forfait), les jours antérieurs restent affichés selon l'ancien contrat.
+
+- [ ] **Step 3: CLAUDE.md**
+
+Dans `CLAUDE.md`, section « Écrans Heures / Heures Conducteurs (vue jour) », compléter la puce existante sur `contractNature` par une phrase :
+
+> Idem pour le **mode de suivi et le libellé de contrat** sur la vue Jour : résolus à la date filtrée via `WorkHourDayContext` (`trackingMode`/`weeklyHours`/`contractType`/`contractName`, peuplés depuis `EmployeeContractResolver::resolveForEmployeeAndDate`), pas via `employee.contract` (résolu à aujourd'hui). Le composable lit `resolveDayContract()` (`useHoursPage.ts`), ce qui pilote aussi `handleSave` (heures vs présence par date).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add doc/ frontend/data/documentation-content.ts CLAUDE.md
+git commit -m "docs: vue jour contrat à la date affichée (doc + in-app + CLAUDE.md)"
+```
+
+---
+
+## Vérification finale (manuelle, par l'utilisateur)
+
+- Sur la fiche d'un salarié passé 39h/35h → Forfait, écran Heures vue Jour :
+  - naviguer une date **avant** la bascule → champs de saisie d'heures, libellé `39h`/`35h` ;
+  - naviguer une date **après** la bascule → cases de présence, libellé `Forfait` ;
+  - éditer puis enregistrer une date avant la bascule → les heures sont conservées (pas de flags présence).
@@ -0,0 +1,88 @@
+# Vue Jour (Heures) — résolution du contrat à la date affichée
+
+Date : 2026-06-01
+
+## Problème
+
+Sur l'écran **Heures — vue Jour** (`HoursDayView`), l'affichage saisie d'heures (TIME)
+vs cases de présence (PRESENCE), ainsi que le libellé de contrat entre parenthèses,
+sont résolus à partir de `employee.contract` — c'est-à-dire le **contrat courant**
+de l'employé (résolu à aujourd'hui), pas le contrat valable à la date affichée.
+
+Conséquence pour un salarié passé d'un contrat 39h/35h (TIME) à un Forfait (PRESENCE) :
+- toutes les dates **passées** s'affichent en cases de présence alors qu'elles
+  relevaient d'un contrat en heures ;
+- pire, `handleSave` (`useHoursPage.ts:1073`) se base sur le même test : éditer
+  une date passée écrit des **flags de présence** au lieu des heures et écrase la saisie.
+
+La **vue Semaine** est déjà correcte : elle résout le `trackingMode` par date côté
+backend via `WeeklySummaryRow.trackingMode`. Le périmètre de ce correctif est donc
+la **vue Jour uniquement**.
+
+## Principe
+
+Le provider backend `WorkHourDayContextProvider::provide()` résout **déjà** le contrat
+à la date affichée (`EmployeeContractResolver::resolveForEmployeeAndDate`) et expose
+déjà `contractNature` par date sur chaque ligne. Il suffit :
+
+1. d'exposer sur la ligne du jour les champs de contrat manquants ;
+2. de faire lire ces champs au frontend (au lieu de `employee.contract`).
+
+L'ensemble de la ligne (toggle saisie/présence + libellé 39h/Forfait + logique 4h)
+devient ainsi cohérent avec le contrat valable à la date affichée.
+
+## Changements
+
+### Backend
+
+1. **`src/Dto/WorkHours/DayContextRow.php`** — ajouter 4 champs au constructeur et à
+   `toArray()` (+ mettre à jour le PHPDoc du retour de `toArray()`) :
+   - `trackingMode: ?string`
+   - `weeklyHours: ?int`
+   - `contractType: ?string`
+   - `contractName: ?string`
+
+2. **`src/State/WorkHourDayContextProvider.php`** — peupler ces champs depuis le
+   `$contract` déjà résolu (lignes 60-71) :
+   - `trackingMode` = `$contract?->getTrackingMode()`
+   - `weeklyHours` = `$contract?->getWeeklyHours()`
+   - `contractType` = `$contract?->getType()->value`
+   - `contractName` = `$contract?->getName()`
+   - tous `null` si pas de contrat à la date (cohérent avec `hasContractAtDate`).
+
+### Frontend
+
+3. **`frontend/services/dto/work-hour.ts`** — refléter les 4 champs sur
+   `WorkHourDayContextRow`.
+
+4. **`frontend/composables/useHoursPage.ts`** — `isPresenceTracking`, `isTimeTracking`,
+   `contractLabel`, `is4hContract` lisent le `dayContextByEmployeeId.get(employeeId)`
+   (résolu par date), avec **fallback** sur `employee.contract` si aucune ligne du jour
+   n'existe. Cela corrige automatiquement `handleSave` (ligne 1073), qui s'appuie sur
+   `isPresenceTracking`.
+
+   Les signatures actuelles prennent un `Employee` ; on conserve la signature et on
+   utilise `employee.id` en interne pour récupérer la ligne du jour.
+
+## Hors périmètre
+
+- Vue Semaine (déjà par date).
+- Heures Conducteurs (toujours en mode TIME, pas de toggle).
+- Processor de sauvegarde backend : inchangé — le frontend enverra déjà la bonne
+  forme (heures vs présence) par date.
+
+## Tests / vérification
+
+- **Test backend** (`WorkHourDayContextProvider`) : pour un employé avec historique
+  39h → Forfait, la ligne renvoyée porte `trackingMode=TIME`/`weeklyHours=39`/
+  `contractType` non-forfait sur une date **avant** la bascule, et
+  `trackingMode=PRESENCE`/`contractType=FORFAIT` sur une date **après**.
+- **Vérification manuelle** : naviguer une date avant et après la bascule sur la fiche
+  du salarié → champs d'heures puis cases de présence, libellé cohérent.
+
+## Documentation (règle obligatoire)
+
+- `doc/` : section vue Jour — résolution du contrat (mode + libellé) à la date affichée.
+- `frontend/data/documentation-content.ts` : note utilisateur correspondante.
+- `CLAUDE.md` : préciser que la vue Jour résout `trackingMode`/libellé **à la date
+  filtrée** (au même titre que `contractNature` déjà documenté).