chore: bump version to v0.1.120

Le récap salaire comptait les congés (C) tombant un dimanche via
countAbsencesByCode, alors que l'onglet Congés, le rollover et les jours de
présence l'ignoraient déjà. Garde ajoutée (C + dimanche → ignoré) pour aligner :
poser une période à cheval sur un week-end (ex. jeu→mar) ne fait plus perdre le
dimanche. Correctif au comptage uniquement : les lignes d'absence du dimanche
restent créées et affichées sur le calendrier (volonté RH), l'existant cesse de
compter sans migration. Périmètre strict : code C (maladie/AT inchangés), samedi
inchangé (budget dédié).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CLAUDE.md

@@ -33,7 +33,7 @@
 - Contract nature (per period): CDI, CDD, INTERIM
 - **Agence d'intérim** (`InterimAgency` entity, table `interim_agencies`): optionnelle sur `EmployeeContractPeriod` quand nature = INTERIM. Pas de CRUD UI — gérée en BDD. API lecture seule `GET /interim_agencies`. Affichée "Intérim (NomAgence)" sur la liste employés et l'historique contrat.
 - Employee contract history: `employee_contract_periods`, resolved by `EmployeeContractResolver`
-- **Écrans Heures / Heures Conducteurs (vue jour)** : le libellé nature (CDI/CDD/Intérim) sous le nom de l'employé est résolu **à la date filtrée** via `WorkHourDayContext.contractNature` (alimenté par `EmployeeContractResolver::resolveNatureForEmployeeAndDate`), pas via `Employee.currentContractNature` (qui est résolu à aujourd'hui). Idem pour le **mode de suivi (TIME/PRESENCE), les heures hebdo 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). Côté front, `resolveDayContract()` (`useHoursPage.ts`) pilote l'affichage et `handleSave` (heures vs présence par date).
+- **Écrans Heures / Heures Conducteurs (vue jour)** : le libellé nature (CDI/CDD/Intérim) sous le nom de l'employé est résolu **à la date filtrée** via `WorkHourDayContext.contractNature` (alimenté par `EmployeeContractResolver::resolveNatureForEmployeeAndDate`), pas via `Employee.currentContractNature` (qui est résolu à aujourd'hui). Idem pour le **mode de suivi (TIME/PRESENCE), les heures hebdo 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). Côté front, `resolveDayContract()` (`useHoursPage.ts`) pilote l'affichage et `handleSave` (heures vs présence par date). **Jours travaillés (CUSTOM)** : le libellé sous le nom affiche en suffixe les jours du planning `workDaysHours` au format court `LU,MA,ME,JE,VE` (ex. `BUREAU — CDI — LU,JE`). Exposé via `WorkHourDayContext.workDaysHours` (peuplé par `EmployeeContractResolver::resolveWorkDaysMinutesForEmployeeAndDate`, à la date filtrée), formaté front par `formatWorkedDaysShort` (`utils/contract.ts`) et accédé via `getRowWorkedDaysLabel` (`useHoursPage.ts`). Affiché **uniquement écran Heures** (`HoursDayView.vue`, mobile + desktop) ; naturellement limité aux CUSTOM (seuls eux ont `workDaysHours` → null sinon, rien affiché). Pas sur Heures Conducteurs (pas de planning workDaysHours).
 - **Exports heures annuelles** (par salarié `EmployeeYearlyHoursPrintProvider` + tous `EmployeeYearlyHoursBulkPrintProvider`, via `YearlyHoursExportBuilder`) : **tous les jours sous contrat sont affichés**, même vides ou non saisis (jusqu'à aujourd'hui). Seuls les jours hors contrat sont omis (`buildSegments` : un seul filtre `!$hasData && null === $contract`). Ne pas réintroduire de saut des jours de semaine vides. Samedis/dimanches grisés (`#c0c0c0`) dans les templates `employee-yearly-hours/print*.html.twig`. NB : l'export *tous employés* sur l'année peut dépasser `memory_limit=256M` (Dompdf) — limitation pré-existante, voir avec l'infra si besoin.
 - **Export heures vue Jour** (`WorkHourDayExportProvider`, endpoint `GET /work-hours/day-export?workDate=&siteIds=`, `ROLE_USER`) : bouton « Exporter » à droite du titre « Heures », **visible uniquement en vue Jour** (`v-if="(isAdmin || isSiteManager) && viewMode === 'day'"`, masqué en vue Semaine et pour `ROLE_SELF`). **Accessible aux admins ET aux chefs de site** : le périmètre est résolu côté backend via `EmployeeRepository::findScoped($user)` (admin → tous les sites, chef de site → ses sites uniquement, cf. `EmployeeScopeService`), donc un `siteIds` hors périmètre est ignoré ; le drawer front ne propose que les sites visibles (`sites` dérivé des employés scopés). PDF A4 portrait d'**une seule journée**, **regroupé par site**, colonnes de la vue Jour **sans « Valider »** (colonne **Total en gras**). Mêmes employés que l'écran : non-conducteurs, sous contrat à la date, sites cochés et dans le périmètre (lignes vides incluses). **Tri intra-site identique au calendrier** : `displayOrder` (ordre manuel), puis nom, puis prénom (cf. `compareEmployeesInSite` front). Calcul des cellules mutualisé via `YearlyHoursExportBuilder::buildDayRowsForEmployees` (Jour/Nuit/Total incluent crédit absence + crédit virtuel férié). Colonne **Statut = code** du type d'absence (`AbsenceType::getCode`, ex. `AT`) sur sa couleur de fond ; férié sans absence → nom du férié sur `#b3e5fc`. Chaque row porte `statut` (code), `statutLabel` (libellé, pour la légende) et `statutColor`. **Légende** sous le tableau (carré coloré contenant le code + libellé à droite), construite côté provider à partir des codes présents (hors férié, dédupliquée par code, triée). Gabarit `templates/work-hour-day-export/print.html.twig`.
 - **Export Contingent heures de nuit** (`NightHoursContingentPrintProvider`, endpoint `GET /night-hours-contingent/print?year=YYYY`, `ROLE_USER`) : option « Contingent H.nuit » du drawer Export de la liste employés. PDF **A4 paysage**, lignes = employés **groupés par site** et triés `displayOrder`/nom/prénom (comme le day-export), colonnes = 12 mois civils, chacun avec 2 sous-colonnes **H.nuit** et **N.jours**. Heures de nuit = minutes dans la fenêtre **21h→6h** via le service partagé `App\Service\WorkHours\NightHoursCalculator` (source unique mutualisée avec `WorkHourWeeklySummaryProvider`, `YearlyHoursExportBuilder`, `RttRecoveryComputationService` et `SalaryRecapPrintProvider`). Conducteurs inclus via `WorkHour.nightHoursMinutes`. **N.jours** = nb de jours où minutes de nuit ≥ 240 (4h). **Aucun crédit** absence/férié. Agrégation : `App\Service\WorkHours\NightContingentExportBuilder`. Gabarit `templates/night-hours-contingent/print.html.twig`.
@@ -75,7 +75,8 @@
 - Driver contracts: RTT uses `dayHoursMinutes + nightHoursMinutes + workshopHoursMinutes` instead of morning/afternoon/evening time ranges
 - FORFAIT weekend/holiday bonus: each weekend or public holiday day worked gives bonus leave (full day if morning+afternoon, 0.5 if only one). Added to acquired days, no cap. PRESENCE mode only.
 - **FORFAIT — jours de présence et N-1** : les congés posés et imputés sur le stock N-1 ne décrémentent **pas** les jours de présence affichés (`presenceDaysByMonth` et `presenceDaysToToday`). Implémenté dans `EmployeeLeaveSummaryProvider::computePresenceDaysByMonth` via un budget N-1 (= `previousYearTakenDays`) consommé chronologiquement avant comptage des absences. Pour les non-forfait, ce budget vaut toujours 0 → comportement inchangé.
-  - **Récap salaire (export PDF mensuel)** : même règle appliquée dans `SalaryRecapPrintProvider` — un congé forfait imputé N-1 n'est ni affiché en colonne congés ni soustrait, et compte comme jour de présence. Le budget N-1 vient de `EmployeeLeaveSummaryProvider::resolvePreviousYearTakenDays()` (méthode publique mutualisée, qui reproduit `provide()` : phase courante + recalcul jours payés, donc **même budget que la fiche employé**). Comme l'export est mensuel, les congés sont chargés depuis le 1er janvier (`findForPrint(yearStart, to)`) et le budget consommé chronologiquement par `splitForfaitCongesByN1()`. Non-forfait ou budget N-1 = 0 → `countAbsencesByCode(['C'])` inchangé.
+  - **Récap salaire (export PDF mensuel)** : même règle appliquée dans `SalaryRecapPrintProvider` — un congé forfait imputé N-1 n'est ni affiché en colonne congés ni soustrait, et compte comme jour de présence. Le budget N-1 vient de `EmployeeLeaveSummaryProvider::resolvePreviousYearTakenDays()` (méthode publique mutualisée, qui reproduit `provide()` : phase courante + recalcul jours payés, donc **même budget que la fiche employé**). Comme l'export est mensuel, les congés sont chargés depuis le 1er janvier (`findForPrint(yearStart, to)`) et le budget consommé chronologiquement par `splitForfaitCongesByN1()`. Non-forfait ou budget N-1 = 0 → `countAbsencesByCode(['C'])`.
+- **Congé posé un dimanche — jamais décompté** : un congé `C` tombant un **dimanche** n'est compté comme congé pris **nulle part** (récap congés, rollover, jours de présence l'ignoraient déjà ; le **récap salaire** est désormais aligné via une garde dans `SalaryRecapPrintProvider::countAbsencesByCode` : `'C' === code && 7 === N → continue`). Objectif RH : poser une période à cheval sur un week-end (ex. jeu→mar) sans « perdre » le dimanche. **Correctif au comptage** (pas à la création) : les lignes d'absence du dimanche **restent créées et stockées** (`AbsenceWriteProcessor::expandAbsenceRange` inchangé), donc l'existant cesse de compter sans migration, et le **calendrier + impression PDF des absences continuent d'afficher** le dimanche (volonté RH). Périmètre strict : code `C` uniquement (maladie/AT comptés normalement) ; le **samedi** garde son budget dédié (`takenSaturdays`). `splitForfaitCongesByN1` sautait déjà le week-end.
   - **Colonne « Heures payés » scindée 25 %/50 %** : en-tête fusionné (`colspan=2`) + deux sous-colonnes `25%`/`50%` dans le template `salary-recap/print.html.twig`. Données : `paid25Hours` = `base25Minutes`, `paid50Hours` = `base50Minutes` (bases seules, **hors bonus** — total inchangé vs l'ancienne colonne unique). `buildRttPaymentMap` renvoie `['m25','m50']` par employé. Le tableau a désormais 20 colonnes (`colspan` des lignes site/vide ajusté).
 - **Jours de présence — borne début de contrat** : `presenceDaysByMonth`/`presenceDaysToToday` sont calculés à partir de `resolveEarliestContractStartWithinRange` (début de contrat dans l'exercice), pas du début d'exercice brut. Évite de compter comme « présents » les jours ouvrés antérieurs à l'embauche pour une entrée en cours d'exercice (ex. CDD : Dylan passait de 43,5 à 246 sans la borne). Sans effet pour un employé présent depuis avant l'exercice ni pour le forfait (déjà capé au début de phase).
 

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.118'
+    app.version: '0.1.120'

doc/functional-rules.md

@@ -61,6 +61,7 @@ Documents complementaires:
 - Libellé nature de contrat (CDI/CDD/Intérim) affiché sous le nom:
   - résolu à la date filtrée (période de contrat couvrant ce jour), pas à aujourd'hui
   - masqué si aucun contrat à cette date (cas rarissime en vue jour puisque l'employé est alors déjà filtré)
+- **Jours travaillés (contrats CUSTOM)** : pour un contrat CUSTOM (planning `workDaysHours` renseigné), les jours effectivement travaillés sont affichés en suffixe du libellé `Site — Nature`, au format court `LU,MA,ME,JE,VE` (ex. `BUREAU — CDI — LU,JE` pour un temps partiel travaillant lundi et jeudi). Résolu à la date filtrée. Les contrats 35h/39h/Forfait/Intérim n'ont pas de planning → aucun suffixe. Écran Heures uniquement (pas Heures Conducteurs).
 - **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`, alimentés par `EmployeeContractResolver::resolveForEmployeeAndDate`), 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. La vue Semaine était déjà résolue par date.
 - **Exports heures annuelles (par salarié et tous salariés)** : affichent **tous les jours sous contrat**, même vides ou non saisis, jusqu'à la date du jour ; seuls les jours hors contrat (avant embauche, après départ, suspension) sont omis. Les samedis et dimanches sont grisés (gris foncé), les jours fériés en bleu.
 - **Récap salaire (export PDF mensuel)** : seuls les salariés ayant un contrat couvrant tout ou partie du mois imprimé apparaissent (filtre `hasContractInRange`). Un salarié dont le contrat est terminé avant le mois (ex. parti en février) n'est pas listé sur le récap des mois suivants.
@@ -278,8 +279,9 @@ Seuls les employés dont au moins une période de contrat intersecte la période
         - pas de samedi (`0`)
         - pas de jours en cours d'acquisition (`0`)
       - fractionné: saisie manuelle par la RH via `PATCH /employees/{id}/fractioned-days`, stocké dans `employee_leave_balances.fractioned_days`. Les jours fractionnés sont ajoutés aux acquis et au reste à prendre.
+      - **dimanche jamais décompté** : un congé `C` posé un dimanche n'est **jamais** compté comme congé pris, où que ce soit (récap congés, rollover, jours de présence, et **récap salaire**). Permet de poser une période à cheval sur un week-end (ex. jeu→mar) sans « perdre » le dimanche. Ne concerne que le code `C` (maladie/AT inchangés) ; le samedi conserve son budget dédié. **Le calendrier et son impression PDF continuent d'afficher** la ligne du dimanche (la ligne d'absence existe en base, choix RH).
       - pour `CDI`/`CDD` non forfait:
-        - pris CP: basé sur absences de type code `C` (CONGÉ), en tenant compte des demi-journées
+        - pris CP: basé sur absences de type code `C` (CONGÉ), en tenant compte des demi-journées (dimanche exclu, samedi compté à part)
         - samedi pris: absences `C` posées le samedi (demi-journée incluse)
         - restants = acquis - pris (borné à 0)
       - pour `FORFAIT`:

frontend/components/hours/HoursDayView.vue

@@ -14,7 +14,7 @@
                         <span class="font-normal text-neutral-600 text-sm">({{ contractLabel(employee) }})</span>
                     </p>
                     <p class="text-sm text-neutral-500 truncate">
-                        {{ employee.site?.name ?? 'Sans site' }}<span v-if="getRowContractNature(employee.id)"> — {{ contractNatureLabel(getRowContractNature(employee.id) ?? undefined) }}</span>
+                        {{ employee.site?.name ?? 'Sans site' }}<span v-if="getRowContractNature(employee.id)"> — {{ contractNatureLabel(getRowContractNature(employee.id) ?? undefined) }}</span><span v-if="getRowWorkedDaysLabel(employee.id)"> — {{ getRowWorkedDaysLabel(employee.id) }}</span>
                     </p>
                 </div>
 
@@ -212,7 +212,7 @@
                     </p>
                     <p class="text-neutral-500 truncate inline-flex items-center gap-2">
                         <span>
-                            {{ employee.site?.name ?? 'Sans site' }}<span v-if="getRowContractNature(employee.id)"> — {{ contractNatureLabel(getRowContractNature(employee.id) ?? undefined) }}</span>
+                            {{ employee.site?.name ?? 'Sans site' }}<span v-if="getRowContractNature(employee.id)"> — {{ contractNatureLabel(getRowContractNature(employee.id) ?? undefined) }}</span><span v-if="getRowWorkedDaysLabel(employee.id)"> — {{ getRowWorkedDaysLabel(employee.id) }}</span>
                         </span>
                         <span
                             v-if="isAdmin && (rows[employee.id]?.isSiteValid ?? false)"
@@ -406,6 +406,7 @@ const props = defineProps<{
     hasRowFormation: (employeeId: number) => boolean
     getRowFormationLabel: (employeeId: number) => string
     getRowContractNature: (employeeId: number) => 'CDI' | 'CDD' | 'INTERIM' | null
+    getRowWorkedDaysLabel: (employeeId: number) => string | null
     getRowUpdatedAt: (employeeId: number) => string
     getPresenceDayValue: (employeeId: number) => string
     onAbsenceClick: (employeeId: number) => void

frontend/composables/useHoursPage.ts

@@ -517,6 +517,11 @@ export const useHoursPage = () => {
     return dayContextByEmployeeId.value.get(employeeId)?.contractNature ?? null
   }
 
+  // Jours travaillés du planning (contrats CUSTOM uniquement), ex. "LU,VE". null sinon.
+  const getRowWorkedDaysLabel = (employeeId: number): string | null => {
+    return formatWorkedDaysShort(dayContextByEmployeeId.value.get(employeeId)?.workDaysHours)
+  }
+
   const getRowUpdatedAt = (employeeId: number): string => {
     const raw = rows.value[employeeId]?.updatedAt
     if (!raw) return ''
@@ -1207,6 +1212,7 @@ export const useHoursPage = () => {
     hasRowFormation,
     getRowFormationLabel,
     getRowContractNature,
+    getRowWorkedDaysLabel,
     getRowUpdatedAt,
     getPresenceDayValue,
     openAbsenceDrawer,

frontend/data/documentation-content.ts

@@ -29,6 +29,7 @@ export const documentationSections: DocSection[] = [
           { type: 'list', content: 'Boutons "Hier" / "Aujourd\'hui" / "Demain" pour naviguer rapidement\nSélecteur de date pour choisir une date spécifique\nFiltrage par site si vous avez accès à plusieurs sites' },
           { type: 'paragraph', content: 'Seuls les employés ayant un contrat actif à la date sélectionnée sont affichés.' },
           { type: 'note', content: 'Sous le nom de l\'employé, la nature du contrat (CDI / CDD / Intérim) affichée correspond à la période couvrant la date filtrée, et non à aujourd\'hui.' },
+          { type: 'paragraph', content: 'Pour un contrat à temps partiel avec un planning de jours travaillés (contrat « personnalisé »), les jours travaillés sont rappelés à la suite du libellé site et nature, en abrégé : par exemple « BUREAU — CDI — LU,JE » pour un salarié travaillant le lundi et le jeudi. Les contrats 35h, 39h, forfait et intérim n\'affichent pas ce rappel.' },
           { type: 'paragraph', content: 'Sur la vue Jour, l\'affichage (saisie d\'heures ou cases de 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 (par exemple un passage en forfait), les jours antérieurs à ce changement restent affichés selon l\'ancien contrat.' },
         ],
       },
@@ -492,6 +493,7 @@ export const documentationSections: DocSection[] = [
         blocks: [
           { type: 'paragraph', content: 'L\'onglet "Congés" sur la fiche employé affiche un calendrier annuel des congés posés (12 mois en grille 4×3) ainsi que les compteurs (acquis, pris, reste, en cours d\'acquisition, N-1 ou samedis selon le contrat).' },
           { type: 'paragraph', content: 'La période affichée dépend du type de contrat actuel : Janvier → Décembre pour FORFAIT, Juin (N-1) → Mai (N) pour les autres contrats.' },
+          { type: 'note', content: 'Les dimanches ne sont jamais comptés comme congés pris. Une période de congé à cheval sur un week-end (par exemple du jeudi au mardi) ne décompte pas le dimanche. Le dimanche reste affiché sur le calendrier mais n\'entre dans aucun compteur.' },
           { type: 'note', content: 'La case « En cours d\'acquisition » affiche deux valeurs : à gauche les jours encore à acquérir (déduction faite des congés déjà posés en anticipé), à droite le total brut acquis sur l\'exercice à ce jour. Exemple : « 14,50 / 17,50 » signifie 17,50 jours acquis dont 3 déjà pris en anticipé.' },
           { type: 'paragraph', content: 'Un sélecteur d\'année est disponible en bas du calendrier (zone scrollable, à gauche). Il permet de consulter l\'exercice suivant ainsi que les exercices passés. La plage proposée part de l\'exercice suivant (l\'exercice à venir, pour consulter en avance les congés déjà posés) et remonte jusqu\'au plus récent entre (a) le premier exercice où l\'employé avait un contrat ouvert et (b) l\'exercice de mise en service du logiciel — il est inutile de remonter plus loin, aucune donnée n\'a été saisie avant.' },
           { type: 'note', content: 'Sur l\'exercice suivant, le calendrier et les congés déjà posés sont exacts, mais les compteurs « Année acquis » et report N-1 sont provisoires : ils dépendent de la clôture de l\'exercice courant et ne se figeront qu\'à cette clôture.' },
@@ -640,6 +642,7 @@ export const documentationSections: DocSection[] = [
           { type: 'list', content: 'Sélecteur de mois (défaut = mois courant)\nDonnées groupées par site\nColonnes : nom, base contrat, jours de présence cadre, heures de nuit, panier de nuit, heures RTT payées (en-tête fusionné scindé en deux sous-colonnes 25 % et 50 %), congés (nombre + dates), maladie/AT (nombre + dates), primes conducteur (PDJ, repas, nuitée, samedi), observations\nColonne « Repas » chauffeur : somme déjeuner + dîner sur le mois (un jour avec les deux compte 2 repas)' },
           { type: 'note', content: 'Seuls les salariés ayant un contrat couvrant tout ou partie du mois apparaissent : un salarié dont le contrat est terminé (ex. parti en février) n\'est pas listé sur le récap des mois suivants.' },
           { type: 'note', content: 'Forfait : un congé imputé sur le stock de l\'année précédente (N-1) n\'apparaît pas dans la colonne congés et compte comme un jour de présence. Le budget N-1 est consommé dans l\'ordre chronologique depuis janvier, de façon cohérente avec la fiche employé (les jours payés réduisent le stock N-1 d\'abord). Au-delà du budget N-1, les congés s\'affichent normalement.' },
+          { type: 'note', content: 'Un congé posé un dimanche n\'est jamais décompté comme congé pris (colonne congés), comme partout ailleurs dans l\'application. Vous pouvez donc poser une période à cheval sur un week-end (par exemple du jeudi au mardi) sans « perdre » le dimanche. Le dimanche reste visible sur le calendrier et son impression.' },
           { type: 'note', content: 'Export « Contingent H.nuit » : depuis la liste des employés, bouton Export → « Contingent H.nuit » + année. Génère un PDF A4 paysage avec une ligne par employé (groupés par site) et une colonne par mois, chacune avec le total d\'heures de nuit (travail entre 21h et 6h) et le nombre de nuits (jours où au moins 4h ont été travaillées de nuit). Les conducteurs utilisent leurs heures de nuit saisies.' },
         ],
       },

frontend/pages/hours.vue

@@ -87,6 +87,7 @@
                 :has-row-formation="hasRowFormation"
                 :get-row-formation-label="getRowFormationLabel"
                 :get-row-contract-nature="getRowContractNature"
+                :get-row-worked-days-label="getRowWorkedDaysLabel"
                 :get-row-updated-at="getRowUpdatedAt"
                 :get-presence-day-value="getPresenceDayValue"
                 :on-absence-click="openAbsenceDrawer"
@@ -215,6 +216,7 @@ const {
   hasRowFormation,
   getRowFormationLabel,
   getRowContractNature,
+  getRowWorkedDaysLabel,
   getRowUpdatedAt,
   getPresenceDayValue,
   openAbsenceDrawer,

frontend/services/dto/work-hour.ts

@@ -119,6 +119,7 @@ export type WorkHourDayContextRow = {
   weeklyHours?: number | null
   contractType?: ContractType | null
   contractName?: string | null
+  workDaysHours?: Record<number, number> | null
 }
 
 export type WorkHourDayContext = {

frontend/utils/contract.ts

@@ -37,6 +37,26 @@ export const requiresWorkDaysHours = (
 
 const DAY_SHORT_LABELS: Record<number, string> = { 1: 'Lun', 2: 'Mar', 3: 'Mer', 4: 'Jeu', 5: 'Ven' }
 
+const DAY_TINY_LABELS: Record<number, string> = { 1: 'LU', 2: 'MA', 3: 'ME', 4: 'JE', 5: 'VE' }
+
+/**
+ * Very compact worked-days summary for the day view header, e.g. "LU,VE".
+ * Lists the iso days actually worked (minutes > 0), uppercase 2-letter, comma-separated.
+ * Returns null when the schedule is empty/unset (non-CUSTOM contracts have no schedule).
+ */
+export const formatWorkedDaysShort = (
+  workDaysHours: Record<number, number> | null | undefined
+): string | null => {
+  if (!workDaysHours) return null
+  const days = Object.entries(workDaysHours)
+    .map(([iso, minutes]) => [Number(iso), Number(minutes)] as const)
+    .filter(([iso, minutes]) => iso >= 1 && iso <= 5 && minutes > 0)
+    .sort(([a], [b]) => a - b)
+    .map(([iso]) => DAY_TINY_LABELS[iso])
+  if (days.length === 0) return null
+  return days.join(',')
+}
+
 /**
  * Compact human-readable summary of a per-day schedule, e.g. "Lun 2h, Jeu 2h".
  * Returns null when the schedule is empty/unset.

src/ApiResource/WorkHourDayContext.php

@@ -41,7 +41,8 @@ final class WorkHourDayContext
      *     trackingMode:?string,
      *     weeklyHours:?int,
      *     contractType:?string,
-     *     contractName:?string
+     *     contractName:?string,
+     *     workDaysHours:?array<int, int>
      * }>
      */
     public array $rows = [];

src/Dto/WorkHours/DayContextRow.php

@@ -25,6 +25,8 @@ final class DayContextRow
         public ?int $weeklyHours = null,
         public ?string $contractType = null,
         public ?string $contractName = null,
+        /** @var null|array<int, int> iso day (1=Mon..5=Fri) → minutes, planning des jours travaillés (CUSTOM uniquement) */
+        public ?array $workDaysHours = null,
     ) {}
 
     public function setFormation(string $label): void
@@ -87,7 +89,8 @@ final class DayContextRow
      *     trackingMode:?string,
      *     weeklyHours:?int,
      *     contractType:?string,
-     *     contractName:?string
+     *     contractName:?string,
+     *     workDaysHours:?array<int, int>
      * }
      */
     public function toArray(): array
@@ -111,6 +114,7 @@ final class DayContextRow
             'weeklyHours'           => $this->weeklyHours,
             'contractType'          => $this->contractType,
             'contractName'          => $this->contractName,
+            'workDaysHours'         => $this->workDaysHours,
         ];
     }
 

src/State/SalaryRecapPrintProvider.php

@@ -694,6 +694,14 @@ class SalaryRecapPrintProvider implements ProviderInterface
                 continue;
             }
 
+            // Un congé (C) posé un dimanche n'est pas décompté comme congé pris : un dimanche
+            // ne fait pas partie des congés (cf. récap congés / rollover qui l'ignorent déjà).
+            // Le calendrier et son impression continuent d'afficher la ligne (volonté RH).
+            // Hors périmètre : maladie/AT et le samedi (budget samedis dédié) sont inchangés.
+            if ('C' === $type->getCode() && 7 === (int) $absence->getStartDate()->format('N')) {
+                continue;
+            }
+
             $startHalf = $absence->getStartHalf();
             $endHalf   = $absence->getEndHalf();
 

src/State/WorkHourDayContextProvider.php

@@ -72,6 +72,7 @@ final readonly class WorkHourDayContextProvider implements ProviderInterface
                 weeklyHours: $contract?->getWeeklyHours(),
                 contractType: $contract?->getType()->value,
                 contractName: $contract?->getName(),
+                workDaysHours: $workDaysMinutes,
             );
         }
 

tests/State/SalaryRecapPrintProviderTest.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Tests\State;
 
 use App\Entity\Absence;
+use App\Entity\AbsenceType;
 use App\Entity\Employee;
 use App\Entity\EmployeeContractPeriod;
 use App\Enum\HalfDay;
@@ -96,13 +97,76 @@ final class SalaryRecapPrintProviderTest extends TestCase
         self::assertFalse($this->hasInRange(new Employee(), '2026-06-01', '2026-06-30'));
     }
 
+    public function testSundayCongeIsNotCounted(): void
+    {
+        // Congé (C) posé un dimanche (2026-06-07) : ne doit pas compter comme congé pris.
+        $result = $this->countByCode([$this->buildAbsenceWithCode('2026-06-07', 'C')], ['C']);
+
+        self::assertSame(0.0, $result['count']);
+        self::assertSame('', $result['dates']);
+    }
+
+    public function testSaturdayCongeStillCounted(): void
+    {
+        // Le samedi reste hors périmètre (budget samedis dédié) : congé samedi toujours compté.
+        $result = $this->countByCode([$this->buildAbsenceWithCode('2026-06-06', 'C')], ['C']);
+
+        self::assertSame(1.0, $result['count']);
+        self::assertSame('06/06', $result['dates']);
+    }
+
+    public function testWeekdayCongeCounted(): void
+    {
+        $result = $this->countByCode([$this->buildAbsenceWithCode('2026-06-01', 'C')], ['C']);
+
+        self::assertSame(1.0, $result['count']);
+        self::assertSame('01/06', $result['dates']);
+    }
+
+    public function testSundayMaladieStillCounted(): void
+    {
+        // L'exclusion du dimanche ne concerne que les congés (C) : maladie/AT inchangés.
+        $result = $this->countByCode([$this->buildAbsenceWithCode('2026-06-07', 'M')], ['M', 'AT']);
+
+        self::assertSame(1.0, $result['count']);
+        self::assertSame('07/06', $result['dates']);
+    }
+
+    /**
+     * @param list<Absence> $absences
+     * @param list<string>  $codes
+     *
+     * @return array{count: float, dates: string}
+     */
+    private function countByCode(array $absences, array $codes): array
+    {
+        $provider = new ReflectionClass(SalaryRecapPrintProvider::class)->newInstanceWithoutConstructor();
+
+        return new ReflectionClass($provider::class)
+            ->getMethod('countAbsencesByCode')
+            ->invoke($provider, $absences, $codes)
+        ;
+    }
+
+    private function buildAbsenceWithCode(string $date, string $code): Absence
+    {
+        return new Absence()
+            ->setType(new AbsenceType()->setCode($code)->setLabel($code)->setColor('#000'))
+            ->setStartDate(new DateTime($date))
+            ->setEndDate(new DateTime($date))
+            ->setStartHalf(HalfDay::AM)
+            ->setEndHalf(HalfDay::PM)
+        ;
+    }
+
     private function hasInRange(Employee $employee, string $from, string $to): bool
     {
         $provider = new ReflectionClass(SalaryRecapPrintProvider::class)->newInstanceWithoutConstructor();
 
         return new ReflectionClass($provider::class)
             ->getMethod('hasContractInRange')
-            ->invoke($provider, $employee, new DateTimeImmutable($from), new DateTimeImmutable($to));
+            ->invoke($provider, $employee, new DateTimeImmutable($from), new DateTimeImmutable($to))
+        ;
     }
 
     private function buildEmployeeWithPeriod(string $start, ?string $end): Employee
@@ -126,11 +190,13 @@ final class SalaryRecapPrintProviderTest extends TestCase
     {
         $provider = new ReflectionClass(SalaryRecapPrintProvider::class)->newInstanceWithoutConstructor();
         new ReflectionProperty(SalaryRecapPrintProvider::class, 'absenceSegmentsResolver')
-            ->setValue($provider, new AbsenceSegmentsResolver());
+            ->setValue($provider, new AbsenceSegmentsResolver())
+        ;
 
         return new ReflectionClass($provider::class)
             ->getMethod('splitForfaitCongesByN1')
-            ->invoke($provider, $conges, $budget, new DateTimeImmutable($from), new DateTimeImmutable($to));
+            ->invoke($provider, $conges, $budget, new DateTimeImmutable($from), new DateTimeImmutable($to))
+        ;
     }
 
     private function buildConge(string $date): Absence

tests/State/WorkHourDayContextProviderTest.php

@@ -23,6 +23,7 @@ use App\Service\WorkHours\HolidayVirtualHoursResolver;
 use App\Service\WorkHours\WorkedHoursCreditPolicy;
 use App\State\WorkHourDayContextProvider;
 use DateTime;
+use DateTimeImmutable;
 use PHPUnit\Framework\TestCase;
 use ReflectionObject;
 use Symfony\Bundle\SecurityBundle\Security;
@@ -150,8 +151,7 @@ final class WorkHourDayContextProviderTest extends TestCase
         // 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
+            static fn (Employee $e, DateTimeImmutable $d): ?Contract => $d < new DateTimeImmutable('2026-03-01') ? $timeContract : $forfaitContract
         );
         $resolver->method('resolveNatureForEmployeeAndDate')->willReturn(ContractNature::CDI);
 
@@ -180,6 +180,67 @@ final class WorkHourDayContextProviderTest extends TestCase
         self::assertSame('Contrat', $row['contractName']);
     }
 
+    public function testRowCarriesWorkDaysHoursForCustomContract(): void
+    {
+        $user     = new User();
+        $employee = $this->buildEmployee(1, Contract::TRACKING_TIME, 4);
+
+        $resolver = $this->createStub(EmployeeContractResolver::class);
+        $resolver->method('resolveForEmployeeAndDate')->willReturn($employee->getContract());
+        $resolver->method('resolveNatureForEmployeeAndDate')->willReturn(ContractNature::CDI);
+        // Contrat 4h travaillé le lundi et le vendredi (120 min chacun).
+        $resolver->method('resolveWorkDaysMinutesForEmployeeAndDate')->willReturn([1 => 120, 5 => 120]);
+
+        $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([1 => 120, 5 => 120], $row['workDaysHours']);
+    }
+
+    public function testRowHasNullWorkDaysHoursForStandardContract(): void
+    {
+        $user     = new User();
+        $employee = $this->buildEmployee(1, Contract::TRACKING_TIME, 35);
+
+        // buildResolverStub ne stube pas resolveWorkDaysMinutesForEmployeeAndDate → null (35h n'a pas de planning).
+        $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,
+            $this->buildResolverStub(),
+            new AbsenceSegmentsResolver(),
+            new WorkedHoursCreditPolicy($this->buildResolverStub(), new DailyReferenceMinutesResolver()),
+            $this->buildHolidayResolver(),
+        );
+
+        $row = $provider->provide(new Get())->rows[0];
+
+        self::assertNull($row['workDaysHours']);
+    }
+
     private function buildEmployee(int $id, string $trackingMode, ?int $weeklyHours): Employee
     {
         $contract = new Contract()