diff --git a/.kiro/specs/precision-distances-km/.config.kiro b/.kiro/specs/precision-distances-km/.config.kiro new file mode 100644 index 0000000..55da86f --- /dev/null +++ b/.kiro/specs/precision-distances-km/.config.kiro @@ -0,0 +1 @@ +{"specId": "b190f621-9d51-491c-877a-7649d38590de", "workflowType": "requirements-first", "specType": "feature"} diff --git a/.kiro/specs/precision-distances-km/design.md b/.kiro/specs/precision-distances-km/design.md new file mode 100644 index 0000000..b6d6cc0 --- /dev/null +++ b/.kiro/specs/precision-distances-km/design.md @@ -0,0 +1,781 @@ +# Document de Conception Technique — Précision des distances (km) + +## Overview + +Cette fonctionnalité ajoute un paramètre global **Precision_Distance** (0, 1 ou 2 décimales) qui pilote un arrondi supérieur (ceiling) systématique appliqué à l'affichage et à l'agrégation de toutes les distances de l'application : liste des trajets, panneau des totaux, carte, export PDF, et calculs de barème kilométrique (Montant_Previsionnel_Mensuel, Montant_Previsionnel_Annuel, Montant_Reel, Frais_Reel_Mensuel, Regularisation). + +Elle modifie également `IMontantRegleService` : le Montant_Previsionnel_Mensuel (80%) porte désormais uniquement sur le mois affiché (et non plus sur le Total_Annuel_Partiel), et une nouvelle valeur Montant_Previsionnel_Annuel (100%, sans minoration) est introduite, appliquée au Total_Annuel_Partiel. + +Cette conception **s'appuie sur l'architecture existante** décrite dans `.kiro/specs/schotziad-km-tracker/design.md` (ASP.NET Core 8 / EF Core / SQLite côté backend, Angular 22 zoneless standalone côté frontend) et ne la remet pas en cause : elle ajoute une entité de configuration, un service de précision, un endpoint, et modifie des points de calcul existants identifiés dans le code réel (`ResumeService`, `TotauxService`, `MontantRegleService`, `RemboursementService`, `PdfService`, `CarteTrajetsComponent`, `TrajetListComponent`, `PanneauTotauxComponent`, `MontantsReglesComponent`). + +> **Important** : l'arrondi ORS/Haversine existant dans `ORSClient.cs` (`Math.Round(distanceMeters / 1000, 2, MidpointRounding.AwayFromZero)`) reste inchangé — c'est l'arrondi de **calcul brut** stocké en base (colonne `Trajet.Distance`). Le nouvel arrondi Precision_Distance est un **arrondi d'affichage/agrégation en aval**, appliqué à la volée sur la valeur lue, jamais persisté sur `Trajet.Distance`. + +--- + +## Architecture + +### Vue d'ensemble des points d'impact + +```mermaid +graph TB + subgraph "Backend ASP.NET Core" + PARAM_CTRL[ParametresApplicationController] + PARAM_SVC[PrecisionDistanceService
ObtenirAsync / DefinirAsync / ArrondirDistance] + PARAM_DB[(ParametresApplication
singleton)] + + RESUME[ResumeService] + TOTAUX[TotauxService] + MONTANT[MontantRegleService] + REMB[RemboursementService] + BAREME[BaremeService] + PDF[PdfService] + + PARAM_CTRL --> PARAM_SVC + PARAM_SVC --> PARAM_DB + + RESUME --> PARAM_SVC + TOTAUX --> PARAM_SVC + MONTANT --> PARAM_SVC + REMB --> PARAM_SVC + PDF --> PARAM_SVC + MONTANT --> BAREME + REMB --> BAREME + REMB --> MONTANT + PDF --> RESUME + PDF --> REMB + PDF --> MONTANT + PDF --> BAREME + end + + subgraph "Frontend Angular" + PARAM_SVC_FE[ParametresApplicationService
signal precisionDistance] + PARAM_COMP[ParametresApplicationComponent] + LISTE[TrajetListComponent] + TOTAUX_COMP[PanneauTotauxComponent] + CARTE[CarteTrajetsComponent] + MONTANTS_COMP[MontantsReglesComponent] + ARRONDI_FE[arrondirDistance util] + + PARAM_COMP --> PARAM_SVC_FE + LISTE --> PARAM_SVC_FE + TOTAUX_COMP --> PARAM_SVC_FE + CARTE --> PARAM_SVC_FE + MONTANTS_COMP --> PARAM_SVC_FE + LISTE --> ARRONDI_FE + TOTAUX_COMP --> ARRONDI_FE + CARTE --> ARRONDI_FE + end + + PARAM_SVC_FE -- "HTTP GET/PUT" --> PARAM_CTRL +``` + +### Décision d'architecture : table dédiée à une seule ligne (singleton), pas de table clé-valeur générique + +**Options considérées :** + +1. **Table clé-valeur générique** (`ParametreApplication { Cle, Valeur }`) — flexible pour ajouter de futurs paramètres sans migration, mais nécessite un parsing/validation par clé côté application (perte du typage fort EF Core), et introduit une indirection pour un besoin actuel limité à un seul paramètre entier. +2. **Table dédiée à une seule ligne (singleton)**, sur le modèle exact de `Profil` et `Compte` déjà présents dans `AppDbContext` (`Id` fixe = 1, `ValueGeneratedNever()`, index unique `UX_*_Singleton`). + +**Décision retenue : option 2**, pour cohérence stricte avec les conventions existantes du projet (`Profil`, `Compte` sont déjà des singletons typés) et parce que le besoin actuel est un unique paramètre entier borné (0/1/2). Si d'autres paramètres globaux apparaissent plus tard, cette même table `ParametresApplication` pourra recevoir de nouvelles colonnes (comme `Profil` a reçu ses champs successivement) sans qu'une refonte soit nécessaire. + +### Décision d'architecture : arrondi ceiling centralisé dans une méthode utilitaire pure, appelée à la lecture + +L'arrondi n'est **jamais** appliqué à l'écriture (la colonne `Trajet.Distance` n'est jamais modifiée par ce paramètre — Exigence 1.8). Il est appliqué : +- **côté backend**, à chaque endroit où une distance ou un total est **lu puis exposé** (DTO de réponse, PDF) ; +- **côté frontend**, à l'affichage, en réutilisant la valeur `precisionDistance` courante partagée par un signal de service, pour un rendu réactif sans aller-retour serveur à chaque changement de sélection (mois, véhicule, journée). + +Cela garantit l'Exigence 9.4 (même Distance_Effective_Arrondie pour un même Trajet, à précision égale, dans la liste, le panneau, la carte, le PDF et le barème) : une seule fonction d'arrondi (`ArrondirDistance` côté backend, `arrondirDistance` côté frontend), avec la même formule. + +--- + +## Data Models + +### Entité `ParametresApplication` (nouvelle — backend) + +```csharp +namespace SchotzIadKmTracker.Api.Models.Entities; + +/// +/// Configuration globale de l'application (singleton — une seule ligne, Id = 1). +/// Sur le même modèle que et . +/// +public class ParametresApplication +{ + /// Identifiant fixe (1) : la configuration est un singleton. + public int Id { get; set; } = 1; + + /// + /// Nombre de décimales (0, 1 ou 2) utilisé pour l'arrondi supérieur des distances à + /// l'affichage et dans les agrégats. Défaut 2 (Exigence 1.2). Valeur validée par + /// avant écriture — jamais persistée + /// hors de {0, 1, 2}. + /// + public int PrecisionDistanceKm { get; set; } = 2; + + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; +} +``` + +### Enregistrement dans `AppDbContext` + +```csharp +public DbSet ParametresApplication => Set(); +``` + +```csharp +// --- ParametresApplication (singleton Id = 1) --- +modelBuilder.Entity(entity => +{ + entity.ToTable("ParametresApplication", t => + t.HasCheckConstraint("CK_ParametresApplication_PrecisionDistanceKm", "\"PrecisionDistanceKm\" IN (0, 1, 2)")); + entity.HasKey(p => p.Id); + entity.Property(p => p.Id).ValueGeneratedNever(); + entity.HasIndex(p => p.Id, "UX_ParametresApplication_Singleton").IsUnique(); +}); +``` + +### Migration EF Core + +Nouvelle migration (nom à la suite des migrations existantes, ex. `20260916000000_AjoutParametresApplication`), créant la table `ParametresApplication` avec la contrainte CHECK ci-dessus. Aucune donnée à migrer (table vide au départ ; la ligne singleton est créée à la volée, comme `Profil`, au premier accès — cf. `PrecisionDistanceService.ObtenirAsync`). + +### Schéma SQLite + +```sql +CREATE TABLE ParametresApplication ( + Id INTEGER PRIMARY KEY, + PrecisionDistanceKm INTEGER NOT NULL DEFAULT 2 CHECK (PrecisionDistanceKm IN (0, 1, 2)), + UpdatedAt TEXT NOT NULL DEFAULT (datetime('now')) +); +``` + +--- + +## API + +### DTOs (nouveau fichier `Models/DTOs/ParametresApplicationDtos.cs`) + +```csharp +namespace SchotzIadKmTracker.Api.Models.DTOs; + +/// Configuration globale exposée en lecture. +public record ParametresApplicationDto(int PrecisionDistanceKm); + +/// Corps de requête pour modifier la précision des distances. +public record SavePrecisionDistanceDto(int PrecisionDistanceKm); +``` + +### Endpoints (`Controllers/ParametresApplicationController.cs`) + +Suit exactement les conventions de `BaremeController` (route `api/...`, `[ApiController]`, autorisation JWT globale héritée du filtre configuré dans `Program.cs`, pas d'attribut `[Authorize]` explicite requis — seul `AuthController` porte `[AllowAnonymous]`). + +| Méthode | Route | Description | Codes | +|---|---|---|---| +| GET | `/api/parametres-application` | Retourne la configuration courante (crée la ligne singleton avec la valeur par défaut 2 si absente) | 200 | +| PUT | `/api/parametres-application` | Modifie `PrecisionDistanceKm` | 200, 400 | + +```csharp +[ApiController] +[Route("api/parametres-application")] +public class ParametresApplicationController : ControllerBase +{ + private readonly IPrecisionDistanceService _precisionDistanceService; + + public ParametresApplicationController(IPrecisionDistanceService precisionDistanceService) + { + _precisionDistanceService = precisionDistanceService; + } + + [HttpGet] + [ProducesResponseType(typeof(ParametresApplicationDto), StatusCodes.Status200OK)] + public async Task> Get(CancellationToken cancellationToken) + { + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + return Ok(new ParametresApplicationDto(precision)); + } + + [HttpPut] + [ProducesResponseType(typeof(ParametresApplicationDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status400BadRequest)] + public async Task> Put( + [FromBody] SavePrecisionDistanceDto dto, CancellationToken cancellationToken) + { + try + { + var precision = await _precisionDistanceService.DefinirAsync(dto.PrecisionDistanceKm, cancellationToken); + return Ok(new ParametresApplicationDto(precision)); + } + catch (PrecisionDistanceInvalideException ex) + { + return Problem(detail: ex.Message, statusCode: StatusCodes.Status400BadRequest); + } + } +} +``` + +L'authentification est garantie par le filtre d'autorisation global déjà enregistré dans `Program.cs` (`AuthorizeFilter` appliqué à tous les contrôleurs MVC) : sans jeton JWT valide, la requête reçoit un **401** avant d'atteindre le contrôleur (Exigences 1.7, 2.6 — même comportement que `BaremeController`, `ProfilController`, etc., aucune configuration supplémentaire requise). + +### Validation (400) + +Portée par le service (`PrecisionDistanceService.DefinirAsync`), pas par FluentValidation, car la validation est une règle métier simple (appartenance à `{0, 1, 2}`) sur un endpoint à faible complexité — cohérent avec `MontantRegleService` qui valide aussi en profondeur dans le service (défense en profondeur, cf. `MontantRegleNegatifException`). Une nouvelle exception `PrecisionDistanceInvalideException` (`Services/Exceptions/PrecisionDistanceInvalideException.cs`) suit le même modèle que `MontantRegleNegatifException`. + +--- + +## Components and Interfaces + +### Backend — nouveau service `IPrecisionDistanceService` / `PrecisionDistanceService` + +```csharp +namespace SchotzIadKmTracker.Api.Services; + +/// +/// Lecture/écriture de la configuration globale Precision_Distance, et fonction utilitaire +/// pure d'arrondi supérieur (ceiling) réutilisée par tous les points de calcul de distance. +/// +public interface IPrecisionDistanceService +{ + /// + /// Retourne la précision courante (0, 1 ou 2). Crée la ligne singleton avec la valeur + /// par défaut (2) si elle est absente (Exigence 1.2), sur le même modèle que + /// . + /// + Task ObtenirAsync(CancellationToken cancellationToken = default); + + /// + /// Définit la précision. Lève + /// si la valeur n'est pas 0, 1 ou 2 (Exigence 1.6). + /// + Task DefinirAsync(int valeur, CancellationToken cancellationToken = default); + + /// + /// Arrondit une distance brute (km) au supérieur (ceiling) à la précision indiquée. + /// Fonction pure, sans effet de bord, sans accès base — utilisable partout où une + /// distance doit être affichée ou agrégée (Exigences 3.2–3.5, 4.2). + /// Formule : Ceiling(distanceBrute × 10^precision) / 10^precision. + /// + decimal ArrondirDistance(decimal distanceBrute, int precision); +} +``` + +```csharp +public class PrecisionDistanceService : IPrecisionDistanceService +{ + private const int ParametresId = 1; + private readonly AppDbContext _context; + + public PrecisionDistanceService(AppDbContext context) => _context = context; + + public async Task ObtenirAsync(CancellationToken cancellationToken = default) + { + var parametres = await GetOrCreateAsync(cancellationToken); + return parametres.PrecisionDistanceKm; + } + + public async Task DefinirAsync(int valeur, CancellationToken cancellationToken = default) + { + if (valeur is not (0 or 1 or 2)) + { + throw new PrecisionDistanceInvalideException( + "La précision des distances doit être 0, 1 ou 2 décimale(s)."); + } + + var parametres = await GetOrCreateAsync(cancellationToken); + parametres.PrecisionDistanceKm = valeur; + parametres.UpdatedAt = DateTime.UtcNow; + await _context.SaveChangesAsync(cancellationToken); + return parametres.PrecisionDistanceKm; + } + + public decimal ArrondirDistance(decimal distanceBrute, int precision) + { + var facteur = (decimal)Math.Pow(10, precision); + return Math.Ceiling(distanceBrute * facteur) / facteur; + } + + private async Task GetOrCreateAsync(CancellationToken cancellationToken) + { + var parametres = await _context.ParametresApplication + .FirstOrDefaultAsync(p => p.Id == ParametresId, cancellationToken); + if (parametres is not null) + { + return parametres; + } + + parametres = new ParametresApplication { Id = ParametresId }; + await _context.ParametresApplication.AddAsync(parametres, cancellationToken); + await _context.SaveChangesAsync(cancellationToken); + return parametres; + } +} +``` + +Enregistrement dans `Program.cs`, à côté des autres services scoped : + +```csharp +builder.Services.AddScoped(); +``` + +### Points de consommation backend (injection de `IPrecisionDistanceService`) + +Tous les services suivants injectent `IPrecisionDistanceService` en plus de leurs dépendances actuelles, appellent `ObtenirAsync()` une fois par requête (le résultat est stable pendant la durée de la requête), puis appliquent `ArrondirDistance` **avant sommation** (jamais après) : + +| Service | Méthode(s) concernée(s) | Changement | +|---|---|---| +| `ResumeService` | `ConstruireResumeMensuel` (privée, appelée par `GetResumeMensuelAsync`/`GetResumeAnnuelAsync`) | Pour chaque trajet : `Distance_Effective_Arrondie = ArrondirDistance(Distance, precision) × (AllerRetour ? 2 : 1)` (arrondi AVANT doublement — Exigence 4.2), puis somme de ces valeurs déjà arrondies pour `TotalKm` (Exigence 5.2/5.3). Le `TrajetDto.Distance` exposé devient lui aussi `Distance_Effective_Arrondie` (au lieu de `DistanceEffective` brut). | +| `TotauxService` | `GetTotauxAsync` | La fonction locale `Effective(distance, allerRetour)` devient `ArrondirDistance(distance, precision) × (allerRetour ? 2 : 1)` ; `TotalJour`, `TotalMois`, `TotalAnnuelPartiel` sont des sommes de valeurs déjà arrondies (Exigence 5.1, 5.4), sans nouvel arrondi après la somme (le `Math.Round(..., 2, ...)` final existant est **supprimé** — les distances sommées sont déjà à la précision voulue et n'ont plus besoin d'un second arrondi à 2 décimales). | +| `MontantRegleService` | `GetMontantPrevisionnelAsync` | Voir section dédiée ci-dessous (Requirement 7/8). | +| `RemboursementService` | `GetRegularisationAnnuelleAsync` | `kmMoisMap` est construit à partir de `ArrondirDistance(Distance, precision) × (AllerRetour ? 2 : 1)` par trajet (au lieu de la distance brute), donc `totalKmAnnuel` (Exigence 6.3, 6.6) et chaque `KmMois` (Exigence 6.4) sont des sommes de distances déjà arrondies. | +| `PdfService` | `AssemblerModeleMensuelAsync`, tables du rapport annuel (via `RemboursementService`/`ResumeService` déjà corrigés) | Consomme les résumés/régularisations déjà arrondis en amont ; aucun calcul de distance supplémentaire à modifier directement — la cohérence vient de la réutilisation des services corrigés (Exigence 9.2, 9.3). Voir section « Cohérence PDF/Carte » plus bas pour le détail des points d'appel exacts. | +| `BaremeService` | `CalculerMontantAsync` | Ne change pas : reçoit déjà un `totalKm` en paramètre. Ce sont ses **appelants** (`MontantRegleService`, `RemboursementService`) qui doivent désormais lui passer un total déjà arrondi (Exigence 6.6). | + +### Requirement 7/8 — `MontantRegleService.GetMontantPrevisionnelAsync` + +Signature actuelle (`MontantRegleService.cs`) : calcule un seul `MontantPrevisionnelDto` avec `MontantPrevisionnel` = 80% du barème appliqué au **Total_Annuel_Partiel**. Cette conception est remplacée par : + +```csharp +Task GetMontantPrevisionnelAsync( + int annee, int mois, int vehiculeId, CancellationToken cancellationToken = default); +``` + +avec un **nouveau contenu de calcul** (signature externe inchangée pour ne pas casser le contrat déjà consommé par `BaremeService.getMontantPrevisionnel` côté frontend — seuls les champs du DTO retourné changent) : + +1. Charger les trajets du véhicule pour l'année, jusqu'au mois inclus (comme aujourd'hui), avec `Date.Month` pour distinguer le mois affiché du cumul. +2. Pour chaque trajet : `distanceArrondie = ArrondirDistance(Distance, precision) × (AllerRetour ? 2 : 1)`. +3. `totalMoisAffiche = Σ distanceArrondie` des trajets dont `Date.Month == mois` (Exigence 7.1). +4. `totalAnnuelPartiel = Σ distanceArrondie` des trajets dont `Date.Month <= mois` (Exigence 5.3, 6.2, 8.2). +5. Sélectionner la tranche via `BaremeService.CalculerMontantAsync(annee, puissanceFiscale, totalAnnuelPartiel, ...)` — **la sélection de tranche reste basée sur le cumul annuel arrondi**, conformément à l'Exigence 7.2 : « à partir du total kilométrique annuel arrondi cumulé, tout en appliquant le coefficient ainsi déterminé au seul kilométrage arrondi du mois affiché ». +6. `Montant_Previsionnel_Mensuel = Round(totalMoisAffiche × tranche.Coefficient, 2)` — **80%** en réalité `Round(totalMoisAffiche × tranche.Coefficient × 0.80m, 2)` car le coefficient de tranche seul ne représente pas le montant complet lorsqu'il existe une `Base` non nulle. Pour rester fidèle à la formule existante `CalculerMontantAsync` (`totalKm × coefficient + base`), le calcul du prévisionnel mensuel applique le barème complet à `totalMoisAffiche` (nouvel appel à `CalculerMontantAsync` avec ce total, dans la même tranche déterminée à l'étape 5) puis multiplie par 0.80. +7. `Montant_Previsionnel_Annuel = Round(bareme.Montant sur totalAnnuelPartiel × 1.00, 2)` (Exigence 8.2). + +Nouveau DTO : + +```csharp +public record MontantPrevisionnelDto( + int Annee, + int Mois, + int VehiculeId, + decimal TotalMoisKm, // Distance_Effective_Arrondie totale du mois affiché + decimal TotalAnnuelPartielKm, // Total_Annuel_Partiel arrondi (cumul jusqu'au mois inclus) + decimal MontantPrevisionnelMensuel, // 80% du barème appliqué à TotalMoisKm (tranche déterminée par le cumul annuel) + decimal MontantPrevisionnelAnnuel // 100% du barème appliqué à TotalAnnuelPartielKm +); +``` + +> **Rupture de contrat mineure** : `MontantBaremePlein` et `MontantPrevisionnel` (noms actuels) sont retirés/renommés en `MontantPrevisionnelAnnuel` et `MontantPrevisionnelMensuel`. Le frontend (`bareme.model.ts`, `PanneauTotauxComponent`, `MontantsReglesComponent`) doit être mis à jour en conséquence (voir section Frontend). + +Implémentation : + +```csharp +public async Task GetMontantPrevisionnelAsync( + int annee, int mois, int vehiculeId, CancellationToken cancellationToken = default) +{ + var vehicule = await _context.Vehicules + .AsNoTracking() + .FirstOrDefaultAsync(v => v.Id == vehiculeId, cancellationToken) + ?? throw new VehiculeNotFoundException($"Le véhicule d'identifiant {vehiculeId} est introuvable."); + + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + + var trajets = await _context.Trajets + .AsNoTracking() + .Where(t => t.VehiculeId == vehiculeId && t.Date.Year == annee && t.Date.Month <= mois) + .Select(t => new { t.Date.Month, t.Distance, t.AllerRetour }) + .ToListAsync(cancellationToken); + + decimal DistanceArrondie(decimal? distance, bool allerRetour) => + distance.HasValue + ? _precisionDistanceService.ArrondirDistance(distance.Value, precision) * (allerRetour ? 2m : 1m) + : 0m; + + var totalMoisAffiche = trajets.Where(t => t.Month == mois).Sum(t => DistanceArrondie(t.Distance, t.AllerRetour)); + var totalAnnuelPartiel = trajets.Sum(t => DistanceArrondie(t.Distance, t.AllerRetour)); + + // Tranche déterminée par le cumul annuel (Exigence 7.2) ; réutilisée pour le mois et l'année. + var baremeAnnuel = await _baremeService.CalculerMontantAsync(annee, vehicule.PuissanceFiscale, totalAnnuelPartiel, cancellationToken); + var baremeMois = await _baremeService.CalculerMontantAsync(annee, vehicule.PuissanceFiscale, totalMoisAffiche, cancellationToken); + // NB : CalculerMontantAsync sélectionne la tranche selon le total PASSÉ ; pour appliquer la + // tranche déterminée par le CUMUL au montant du MOIS, on applique manuellement le coefficient/base + // de la tranche annuelle au total du mois plutôt que de ré-sélectionner une tranche via le mois seul : + var montantMoisSelonTrancheAnnuelle = totalMoisAffiche * baremeAnnuel.Coefficient + baremeAnnuel.Base; + + var montantPrevisionnelMensuel = Math.Round(montantMoisSelonTrancheAnnuelle * 0.80m, 2, MidpointRounding.AwayFromZero); + var montantPrevisionnelAnnuel = Math.Round(baremeAnnuel.Montant, 2, MidpointRounding.AwayFromZero); + + return new MontantPrevisionnelDto( + annee, mois, vehiculeId, + Math.Round(totalMoisAffiche, precision, MidpointRounding.AwayFromZero), + Math.Round(totalAnnuelPartiel, precision, MidpointRounding.AwayFromZero), + montantPrevisionnelMensuel, + montantPrevisionnelAnnuel); +} +``` + +> **Correction de conception importante** : l'appel intermédiaire `baremeMois` (calculé mais non utilisé dans la formule finale) est retiré de l'implémentation définitive ci-dessus — seul `montantMoisSelonTrancheAnnuelle` (coefficient/base de la tranche annuelle appliqués au total du mois) sert au calcul, conformément à l'Exigence 7.2. Il est laissé en commentaire dans le pseudo-code ci-dessus uniquement pour expliciter le raisonnement ; l'implémentation réelle ne doit PAS effectuer cet appel inutile. + +### Écran Frontend — `ParametresApplicationComponent` + +Nouveau composant `frontend/src/app/features/parametres-application/parametres-application.component.ts` (+ `.html`, `.scss`), sur le modèle exact de `VehiculesComponent`/`BaremeComponent` (composant standalone, `ChangeDetectionStrategy` par défaut cohérente avec les composants de paramétrage existants — `ProfilComponent` n'utilise pas `OnPush`, ce composant n'en a pas besoin non plus). + +```typescript +@Component({ + selector: 'app-parametres-application', + standalone: true, + imports: [CommonModule, ReactiveFormsModule], + templateUrl: './parametres-application.component.html', + styleUrl: './parametres-application.component.scss' +}) +export class ParametresApplicationComponent implements OnInit { + private readonly parametresService = inject(ParametresApplicationService); + private readonly notification = inject(NotificationService); + + readonly precisionSelectionnee = signal<0 | 1 | 2>(2); + readonly enregistrement = signal(false); + + ngOnInit(): void { + this.precisionSelectionnee.set(this.parametresService.precisionDistance()); + } + + choisir(valeur: 0 | 1 | 2): void { + const precedente = this.precisionSelectionnee(); + this.precisionSelectionnee.set(valeur); + this.enregistrement.set(true); + this.parametresService.definirPrecisionDistance(valeur).subscribe({ + next: () => { + this.enregistrement.set(false); + this.notification.success('Précision des distances enregistrée.'); + }, + error: () => { + this.enregistrement.set(false); + this.precisionSelectionnee.set(precedente); // Exigence 2.5 : conserve la valeur précédente + this.notification.error("La modification n'a pas pu être enregistrée."); + } + }); + } +} +``` + +Template : trois boutons/radios (« 0 », « 1 », « 2 ») avec le choix courant présélectionné (`precisionSelectionnee`), et un texte d'aide expliquant l'arrondi supérieur. + +### Route et menu (`app.routes.ts`, `parametrage.component.html`) + +`app.routes.ts` — nouvel enfant **entre** `compte` et `vehicules`, avec le même niveau de garde que `compte`/`vehicules` (`authGuard` seul, pas `profilConfigureGuard` — Exigence 2.6) : + +```typescript +children: [ + { path: '', redirectTo: 'compte', pathMatch: 'full' }, + { path: 'compte', component: ProfilComponent }, + { path: 'application', component: ParametresApplicationComponent }, + { path: 'vehicules', component: VehiculesComponent }, + { path: 'bareme', component: BaremeComponent, canActivate: [profilConfigureGuard] } +] +``` + +`parametrage.component.html` — nouveau lien **entre** « Compte » et « Véhicules » (Exigence 2.1) : + +```html + + Application + +``` + +### Service Angular `ParametresApplicationService` (nouveau, `core/services/parametres-application.service.ts`) + +Porte le **signal partagé** de précision courante, chargé une fois et mis à jour après modification — c'est le mécanisme central de propagation demandé (pas de rechargement par composant) : + +```typescript +@Injectable({ providedIn: 'root' }) +export class ParametresApplicationService { + private readonly http = inject(HttpClient); + private readonly baseUrl = environment.apiUrl; + + /** Précision courante (0, 1 ou 2), partagée par toute l'application. Défaut 2 avant premier chargement. */ + readonly precisionDistance = signal<0 | 1 | 2>(2); + + /** Charge la précision courante depuis le backend et met à jour le signal partagé. */ + charger(): Observable { + return this.http.get(`${this.baseUrl}/parametres-application`).pipe( + tap((p) => this.precisionDistance.set(p.precisionDistanceKm as 0 | 1 | 2)) + ); + } + + /** Modifie la précision et met à jour le signal partagé en cas de succès. */ + definirPrecisionDistance(valeur: 0 | 1 | 2): Observable { + return this.http.put(`${this.baseUrl}/parametres-application`, { precisionDistanceKm: valeur }).pipe( + tap((p) => this.precisionDistance.set(p.precisionDistanceKm as 0 | 1 | 2)) + ); + } +} +``` + +```typescript +// core/models/parametres-application.model.ts +export interface ParametresApplication { + precisionDistanceKm: number; +} +``` + +**Chargement initial** : suit le même schéma que le chargement du profil dans `AppComponent` (`effect()` déclenché dès que l'utilisateur authentifié quitte une page publique — cf. `AppComponent` existant qui charge déjà `ProfilService.getProfil()` à ce moment). `AppComponent` appelle également `ParametresApplicationService.charger()` à cet instant, afin que le signal soit disponible avant l'affichage des vues protégées. + +### Fonction utilitaire d'arrondi frontend (`shared/utils/arrondir-distance.ts`, nouveau fichier) + +```typescript +/** + * Arrondit une distance brute (km) au supérieur (ceiling) à la précision donnée. + * Miroir exact de PrecisionDistanceService.ArrondirDistance côté backend. + */ +export function arrondirDistance(distanceBrute: number, precision: 0 | 1 | 2): number { + const facteur = Math.pow(10, precision); + return Math.ceil(distanceBrute * facteur) / facteur; +} + +/** Distance_Effective_Arrondie : arrondi de la distance simple PUIS doublement si aller/retour. */ +export function distanceEffectiveArrondie( + distanceBrute: number | null, + allerRetour: boolean, + precision: 0 | 1 | 2 +): number | null { + if (distanceBrute == null) { + return null; + } + const arrondie = arrondirDistance(distanceBrute, precision); + return allerRetour ? arrondie * 2 : arrondie; +} +``` + +> **Remarque sur la source de la distance brute côté frontend** : après la modification backend (Requirement 5/6 ci-dessus), les DTOs `TrajetDto` exposés par `ResumeService` contiennent déjà `Distance_Effective_Arrondie` (le backend a effectué l'arrondi avant l'envoi). Le frontend n'a donc PAS besoin de ré-arrondir la valeur reçue de l'API pour l'affichage de la liste des trajets ou des totaux — il l'affiche telle quelle. La fonction `arrondirDistance`/`distanceEffectiveArrondie` côté frontend sert uniquement dans les cas où le frontend a besoin d'un **rendu réactif immédiat sans aller-retour serveur** après un changement de précision (Exigence 2.4/5.5 : recalcul immédiat des totaux affichés) — c'est-à-dire lorsqu'un composant recalcule l'affichage à partir de distances brutes déjà en mémoire (ex. recalcul du panneau de totaux en cache local avant confirmation serveur), plutôt que de déclencher un rechargement HTTP à chaque clic sur 0/1/2. + +### Composants frontend à modifier pour appliquer/afficher l'arrondi + +| Composant | Fichier réel | Modification | +|---|---|---| +| `TrajetListComponent` | `frontend/src/app/features/trajet-list/trajet-list.component.ts` (méthode `distanceAffichee`) | La distance provient déjà du `TrajetDto.distance` renvoyé par le backend arrondi (Requirement 5/6) ; `distanceAffichee` n'a plus besoin d'arrondir elle-même à 2 décimales fixes — elle formate simplement selon `precisionSelectionnee()` du `ParametresApplicationService` injecté (nombre de décimales affichées cohérent avec la précision choisie, ex. `toFixed(precision)`). | +| `PanneauTotauxComponent` | `frontend/src/app/features/panneau-totaux/panneau-totaux.component.ts` + `.html` | `totaux()` provient de `TrajetService.getTotauxJour` (backend déjà arrondi) ; le pipe `number: '1.2-2'` fixe dans le template est remplacé par un format dynamique basé sur `parametresService.precisionDistance()` (ex. `'1.{p}-{p}'` construit dynamiquement, ou méthode `formatKm()` utilisant `toFixed`). Le bloc « Indication de versement (80%) » est renommé et complété avec la nouvelle ligne « Montant prévisionnel annuel » (Requirement 8), consommant les nouveaux champs `montantPrevisionnelMensuel`/`montantPrevisionnelAnnuel` du DTO. | +| `CarteTrajetsComponent` | `frontend/src/app/features/carte-trajets/carte-trajets.component.ts` (méthode `contenuInfobulle`) | `trajet.distance.toFixed(2)` est remplacé par `trajet.distance.toFixed(this.parametresService.precisionDistance())`. La distance vient de `TrajetService.getTrajetsJournee` (`TrajetCarteDto`), à corriger côté backend pour renvoyer la Distance_Effective_Arrondie (même service `ResumeService`/logique commune que la liste, ou méthode dédiée du `ITrajetService` selon l'implémentation réelle du endpoint `/api/trajets/{date}/journee` — à vérifier au moment de l'implémentation dans `ITrajetService`). | +| `MontantsReglesComponent` | `frontend/src/app/features/montants-regles/montants-regles.component.ts` | Consomme `BaremeService.getMontantPrevisionnel(annee, mois, vehiculeId)` ; le champ lu passe de `p.montantPrevisionnel` à `p.montantPrevisionnelMensuel`. Affichage inchangé (2 décimales monétaires, Exigence 8.4). | +| `BaremeService` (frontend) | `frontend/src/app/core/services/bareme.service.ts` | Le modèle `MontantPrevisionnel` (`frontend/src/app/core/models/bareme.model.ts`) est mis à jour avec les nouveaux champs (`totalMoisKm`, `totalAnnuelPartielKm`, `montantPrevisionnelMensuel`, `montantPrevisionnelAnnuel`) miroir du DTO backend. | +| `ParametrageComponent` | `frontend/src/app/features/parametrage/parametrage.component.html` | Nouveau lien « Application » (voir section Route et menu ci-dessus). | +| `AppComponent` | `frontend/src/app/app.component.ts` | Ajoute le chargement initial de `ParametresApplicationService.charger()` au même moment que le chargement du profil (cf. section Service Angular ci-dessus). | + +--- + +## Règle de calcul Aller_Retour : ordre des opérations + +**Règle (Exigence 4.2)** : la distance simple brute est arrondie au supérieur **avant** d'être doublée. Ne jamais doubler la distance brute puis arrondir le résultat — les deux ordres peuvent produire des résultats différents. + +**Exemple chiffré (Precision_Distance = 0)** : + +- Distance simple brute (stockée en base, déjà arrondie à 2 décimales par `ORSClient`) : `12.30 km`. +- **Ordre correct (retenu)** : `ArrondirDistance(12.30, 0) = Ceiling(12.30) = 13 km`, puis doublement : `13 × 2 = 26 km`. → **Distance_Effective_Arrondie = 26 km**. +- **Ordre incorrect (rejeté)** : doublement d'abord `12.30 × 2 = 24.60 km`, puis arrondi : `Ceiling(24.60) = 25 km`. → 25 km ≠ 26 km. + +L'écart (26 vs 25) illustre pourquoi l'ordre est normatif et testé explicitement (voir Stratégie de test). + +Implémentation (backend comme frontend) : toujours calculer `ArrondirDistance(distanceSimple, precision) × (allerRetour ? 2 : 1)`, jamais `ArrondirDistance(distanceSimple × (allerRetour ? 2 : 1), precision)`. + +--- + +## Cohérence PDF / Carte (Exigence 9) + +- **`PdfService`** (`backend/SchotzIadKmTracker.Api/Services/PdfService.cs`) : ne fait aucun calcul de distance brut lui-même — il compose `IResumeService.GetResumeMensuelAsync/GetResumeAnnuelAsync` (table des trajets et totaux du rapport mensuel, méthode privée `ComposerTableTrajets`) et `IRemboursementService.GetRegularisationAnnuelleAsync` (synthèse annuelle, méthode privée `ComposerTableSyntheseAnnuelle`). Une fois ces deux services corrigés pour retourner des distances déjà arrondies selon Precision_Distance (Requirement 5/6 ci-dessus), le PDF hérite automatiquement de la cohérence, **sans modification de `PdfService` lui-même**, à l'exception d'un point : `AssemblerModeleMensuelAsync` recalcule localement `totalIkMois = resumeMensuel.TotalKm × bareme.Coefficient` — ce total provient déjà de `resumeMensuel.TotalKm` (corrigé), donc cohérent sans changement de code dans `PdfService`. +- **`CarteTrajetsComponent`** (`frontend/src/app/features/carte-trajets/carte-trajets.component.ts`, méthode `contenuInfobulle`) : la ligne `trajet.distance.toFixed(2)` doit devenir `trajet.distance.toFixed(precision)` où `precision` provient de `ParametresApplicationService.precisionDistance()` injecté dans le composant. La valeur `trajet.distance` elle-même doit être la Distance_Effective_Arrondie renvoyée par le endpoint utilisé par `TrajetService.getTrajetsJournee` (à vérifier/corriger côté `ITrajetService`/contrôleur `TrajetsController` au moment de l'implémentation, par cohérence avec `ResumeService`). +- Exigence 9.4 (valeur strictement identique) est garantie par le fait qu'un seul point d'arrondi (`IPrecisionDistanceService.ArrondirDistance`) est appelé, à la même précision courante, par tous les services qui produisent une distance affichée. + +--- + +## Écarts avec `schotziad-km-tracker/design.md` existant + +Cette section documente, sans modifier le fichier `design.md` existant, les endpoints et composants dont le comportement change avec cette spec, afin qu'une mise à jour ultérieure de la spec de base en tienne compte : + +| Élément existant | Comportement actuel (design.md) | Nouveau comportement (precision-distances-km) | +|---|---|---| +| `IMontantRegleService.GetMontantPrevisionnelAsync` | 80% du barème plein appliqué au **Total_Annuel_Partiel** | 80% appliqué au **seul mois affiché** (tranche déterminée par le cumul annuel) ; ajout d'un second montant 100% sur le Total_Annuel_Partiel | +| `MontantPrevisionnelDto` | Champs `TotalAnnuelPartielKm`, `MontantBaremePlein`, `MontantPrevisionnel` | Renommés/complétés : `TotalMoisKm`, `TotalAnnuelPartielKm`, `MontantPrevisionnelMensuel`, `MontantPrevisionnelAnnuel` | +| `PanneauTotauxComponent` | Affiche un unique bloc « Indication de versement (80%) » sur le Total_Annuel_Partiel | Affiche le Montant_Previsionnel_Mensuel (mois affiché) PUIS, en dessous, le Montant_Previsionnel_Annuel (100%, cumul annuel) | +| `MontantsReglesComponent` | Colonne « Montant_Previsionnel » = 80% sur cumul annuel par mois | Colonne « Montant_Previsionnel_Mensuel » = 80% sur le seul mois de la ligne | +| `ResumeService` / `TotauxService` / `RemboursementService` | Distances sommées à partir de `DistanceEffective` brute (2 décimales fixes issues d'ORS) | Distances sommées à partir de `Distance_Effective_Arrondie` (précision paramétrable, arrondi ceiling) | +| `TrajetDto.Distance` (résumés) | Distance brute effective (non arrondie au-delà des 2 décimales de calcul) | Distance_Effective_Arrondie selon Precision_Distance courante | +| `CarteTrajetsComponent` infobulle | `toFixed(2)` fixe | `toFixed(precision)` dynamique | +| `ParametrageComponent` menu | Compte, Véhicules, Barème | Compte, **Application**, Véhicules, Barème | +| Aucune table de configuration globale | — | Nouvelle table `ParametresApplication` (singleton) | + +--- + +## Error Handling + +| Cas | Origine | Traitement | +|---|---|---| +| `PrecisionDistanceKm` soumis hors {0, 1, 2} | `PrecisionDistanceService.DefinirAsync` | Lève `PrecisionDistanceInvalideException` → contrôleur retourne **400** avec message explicite (Exigence 1.6) | +| Requête sans jeton JWT valide sur `GET`/`PUT /api/parametres-application` | Filtre d'autorisation global (`Program.cs`) | **401** avant d'atteindre le contrôleur (Exigence 1.7, 2.6), comportement identique aux autres endpoints protégés | +| Échec réseau/serveur lors de l'enregistrement d'une nouvelle précision (frontend) | `ParametresApplicationComponent.choisir` | Le composant restaure `precisionSelectionnee` à la valeur précédente et affiche une notification d'erreur (Exigence 2.5), sans modifier le signal partagé (qui reste à l'ancienne valeur tant que le serveur n'a pas confirmé) | +| Véhicule introuvable dans `GetMontantPrevisionnelAsync` | `MontantRegleService` | `VehiculeNotFoundException` existante, inchangée (déjà mappée en 404 par le contrôleur existant) | +| Table `ParametresApplication` absente au premier démarrage | `PrecisionDistanceService.ObtenirAsync`/`GetOrCreateAsync` | Création à la volée de la ligne singleton avec la valeur par défaut 2, sur le modèle de `ProfilService.GetOrCreateProfilAsync` — aucune exception | +| Distance brute `null` (Trajet non calculable) rencontrée dans un calcul de précision | Tous les services consommateurs | `ArrondirDistance` n'est jamais appelé sur `null` ; la contribution du trajet à la somme reste 0, comme le comportement actuel (`Distance.GetValueOrDefault()`) | + +--- + +## Testing Strategy + +### Applicabilité du property-based testing + +La fonction `ArrondirDistance` (backend) / `arrondirDistance` (frontend) est une **fonction pure** avec une propriété universelle claire (arrondi supérieur à une précision donnée) : le PBT s'applique pleinement. La règle d'ordre « arrondir puis doubler » pour Aller_Retour est également une propriété universelle testable sur toute distance et tout indicateur booléen. En revanche, l'intégration UI (sélection du menu, affichage du signal partagé, rendu Leaflet, génération PDF) relève de tests d'exemple/intégration classiques, pas de PBT (comportement UI, pas fonction pure à large espace d'entrée testable utilement en PBT). + +### Prework — analyse de testabilité des critères d'acceptation + +**1.1** THE Backend SHALL persister une valeur unique de Precision_Distance parmi {0,1,2} + Thoughts : comportement de persistance simple, un test d'exemple suffit (enregistrer puis relire chaque valeur valide). + Testable : yes - example + +**1.2** Valeur par défaut = 2 si absente + Thoughts : cas précis unique (état initial). Exemple. + Testable : yes - example + +**1.3/1.4** Exposition d'API GET/PUT protégées + Thoughts : vérifie la présence d'endpoints, pas une propriété sur un espace d'entrée. Exemple/intégration. + Testable : yes - example + +**1.5** Application immédiate sans migration des données stockées + Thoughts : comportement d'absence d'effet de bord sur les données existantes. Testable par exemple (créer des trajets, changer la précision, vérifier que `Trajet.Distance` est inchangé) — cf. Property ci-dessous, généralisable en propriété d'invariance. + Testable : yes - property (invariant : changer Precision_Distance ne modifie jamais Trajet.Distance) + +**1.6** Rejet si valeur ≠ {0,1,2} + Thoughts : propriété universelle sur l'espace des entiers hors {0,1,2}. Le comportement varie selon que l'entrée est dans l'ensemble valide ou non — testable par génération d'entiers aléatoires. + Testable : yes - property + +**1.7** Rejet sans session valide + Thoughts : comportement d'authentification binaire, ne varie pas avec le contenu de la requête. Exemple/intégration. + Testable : yes - example + +**1.8** La valeur brute de Distance n'est jamais modifiée par un changement de précision + Thoughts : invariant testable pour toute distance et toute séquence de changements de précision. + Testable : yes - property + +**2.1–2.6** Sous-menu Application (positionnement, présélection, confirmation, erreur, garde d'accès) + Thoughts : comportements d'interface spécifiques à des scénarios précis, pas une propriété sur un large espace d'entrée. + Testable : yes - example + +**3.1–3.5** Arrondi supérieur d'un trajet simple selon la précision (0/1/2), toujours ≥ distance brute + Thoughts : propriété universelle par excellence — pour toute distance brute positive et toute précision valide, l'arrondi ceiling est supérieur ou égal à la distance brute, et coïncide avec l'arrondi mathématique attendu à chaque précision. + Testable : yes - property + +**4.1–4.3** Arrondi avant doublement pour Aller_Retour ; non-A/R = Distance_Arrondie + Thoughts : propriété universelle sur l'ordre des opérations, testable par génération de distances et comparaison des deux ordres de calcul. + Testable : yes - property + +**5.1–5.4** Sommation de distances déjà arrondies, sans arrondi supplémentaire après somme + Thoughts : propriété universelle sur des listes de trajets générées aléatoirement — la somme des distances arrondies individuellement doit être exactement égale au total renvoyé (pas de second arrondi qui la modifierait). + Testable : yes - property + +**5.5** Recalcul immédiat des totaux à l'affichage lors d'un changement de précision (sans rechargement de page) + Thoughts : comportement d'interface réactive (signal partagé), pas une fonction pure à espace d'entrée large. Exemple/intégration (vérifier que le signal déclenche un nouveau rendu). + Testable : yes - example + +**6.1–6.6** Application du barème aux distances arrondies (mensuel, annuel, réel, frais mensuel, régularisation, sélection de tranche) + Thoughts : ce sont des compositions de la propriété d'arrondi déjà couverte (Property 1/2) avec la logique de barème déjà testée dans la spec `schotziad-km-tracker`. La nouveauté testable ici est que le total transmis au barème est le total déjà arrondi — couvert par la propriété d'agrégation (Property 3) et par le fait que `CalculerMontantAsync` reste inchangé (déjà testé ailleurs). + Testable : no (couvert par les propriétés 1–3 ; pas de nouvelle propriété distincte nécessaire) + +**7.1–7.4** Montant_Previsionnel_Mensuel basé sur le seul mois affiché, tranche déterminée par le cumul annuel + Thoughts : propriété universelle — pour toute combinaison de distances mensuelles et de barème, le montant mensuel ne doit dépendre QUE des distances du mois affiché (invariance par rapport aux distances des autres mois, à tranche égale). + Testable : yes - property + +**8.1–8.5** Montant_Previsionnel_Annuel = 100% sur le Total_Annuel_Partiel, affiché sous le mensuel, précision 2 décimales + Thoughts : le calcul (100% sur le cumul) est une propriété universelle (relation simple avec le montant du barème plein déjà calculé) ; l'affichage/positionnement est un exemple UI. + Testable : yes - property (relation Montant_Previsionnel_Annuel = montant plein du barème sur le cumul, sans minoration) + example (positionnement UI) + +**9.1** Infobulle carte = Distance_Effective_Arrondie selon la précision courante + Thoughts : propriété universelle (la valeur affichée doit être strictement égale à la fonction d'arrondi appliquée à la distance brute et à l'indicateur A/R). + Testable : yes - property + +**9.2–9.3** PDF utilise la Distance_Effective_Arrondie et la précision en vigueur au moment de la génération + Thoughts : propriété universelle sur les valeurs numériques du document généré, mais génération PDF coûteuse (QuestPDF) — préférable de tester la fonction de composition des données (modèle) plutôt que le rendu binaire complet. + Testable : yes - property (sur le modèle de données assemblé, pas sur le rendu binaire) + +**9.4** Cohérence stricte entre liste, panneau, carte, PDF et barème pour un même trajet à précision égale + Thoughts : propriété universelle mais transversale à plusieurs services déjà couverts individuellement (Property 1/2/6) — se déduit de l'utilisation d'un point d'arrondi unique. Pas de nouvelle propriété distincte nécessaire, mais un test d'intégration (exemple) vérifiant l'égalité entre les sorties de `ResumeService`, `TotauxService` et `RemboursementService` pour un jeu de trajets donné apporte une garantie de non-régression bienvenue. + Testable : edge-case (test d'intégration de cohérence croisée, pas une propriété PBT distincte) + +### Réflexion de redondance + +- Les critères 3.1–3.5 (arrondi simple par précision) et 4.1–4.3 (arrondi puis doublement) partagent la même fonction sous-jacente : une seule **Property 1** (arrondi ceiling ≥ brute, exact par précision) et une seule **Property 2** (ordre arrondi-puis-doublement) suffisent, sans décliner une propriété par valeur de précision. +- Les critères 6.1–6.6 sont entièrement dérivés des propriétés d'arrondi (1, 2) et d'agrégation (3) : aucune propriété supplémentaire. +- Le critère 1.8 (invariance de `Trajet.Distance`) et le critère 5.1–5.4 (pas d'arrondi après somme) sont regroupés respectivement en **Property 5** et **Property 3** — pas de doublon avec 1.6 (validation stricte, **Property 4**, qui porte sur un autre aspect : le rejet des valeurs invalides, non l'arrondi lui-même). +- Le critère 9.4 (cohérence croisée) est une consé quence directe des propriétés 1–3 appliquées via un point d'arrondi unique ; il est couvert par un test d'intégration (exemple), pas par une propriété PBT distincte. + +## Correctness Properties + +*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.* + +### Property 1: Arrondi supérieur exact et jamais inférieur à la distance brute + +*For any* distance brute positive et toute précision valide (0, 1 ou 2), `ArrondirDistance(distance, precision)` retourne une valeur supérieure ou égale à `distance`, et cette valeur, multipliée par `10^precision`, est un entier (le résultat est bien un multiple exact du pas de précision). + +**Validates: Requirements 3.1, 3.2, 3.3, 3.4, 3.5** + +### Property 2: Arrondi avant doublement pour Aller_Retour + +*For any* distance simple brute positive et toute précision valide, `distanceEffectiveArrondie(distance, allerRetour=true, precision)` est égal à `2 × ArrondirDistance(distance, precision)`, et est strictement différent, en général, de `ArrondirDistance(2 × distance, precision)` — l'implémentation ne doit jamais utiliser ce second ordre. Pour `allerRetour=false`, `distanceEffectiveArrondie` est égal à `ArrondirDistance(distance, precision)` (sans doublement). + +**Validates: Requirements 4.1, 4.2, 4.3** + +### Property 3: Sommation de distances déjà arrondies sans arrondi supplémentaire + +*For any* liste de trajets (distance brute nullable, indicateur aller/retour), la somme des `Distance_Effective_Arrondie` de chaque trajet (calculée individuellement) est strictement égale à la valeur de total retournée par le service d'agrégation (résumé mensuel/annuel, totaux jour/mois/année, régularisation annuelle) — aucun arrondi n'est appliqué une seconde fois après la sommation. + +**Validates: Requirements 5.1, 5.2, 5.3, 5.4** + +### Property 4: Validation stricte de la précision + +*For any* entier soumis comme nouvelle valeur de Precision_Distance, `PrecisionDistanceService.DefinirAsync` accepte et persiste la valeur si et seulement si elle appartient à {0, 1, 2} ; pour toute autre valeur, l'opération est rejetée (exception levée) et la valeur précédemment persistée reste inchangée. + +**Validates: Requirements 1.6** + +### Property 5: Invariance de la distance brute stockée face à un changement de précision + +*For any* séquence de changements de Precision_Distance (valeurs valides), la colonne `Trajet.Distance` de tout trajet existant avant cette séquence reste strictement inchangée après celle-ci ; seule la valeur affichée/agrégée à la lecture varie. + +**Validates: Requirements 1.5, 1.8** + +### Property 6: Montant_Previsionnel_Mensuel dépend uniquement du mois affiché + +*For any* ensemble de trajets répartis sur plusieurs mois d'une même année pour un véhicule donné, et pour tout mois M sélectionné, le Montant_Previsionnel_Mensuel calculé pour M ne change pas si l'on modifie les distances des trajets d'un autre mois que M, tant que le cumul annuel reste dans la même tranche de barème (la tranche appliquée est déterminée par le cumul, mais le montant du mois ne dépend que du kilométrage du mois M). + +**Validates: Requirements 7.1, 7.2** + +### Property 7: Montant_Previsionnel_Annuel égal au barème plein sur le cumul + +*For any* Total_Annuel_Partiel arrondi et toute puissance fiscale/année ayant un barème configuré, le Montant_Previsionnel_Annuel est égal au montant retourné par `CalculerMontantAsync` appliqué à ce même Total_Annuel_Partiel, sans aucune minoration (coefficient 1.00), arrondi à 2 décimales. + +**Validates: Requirements 8.2, 8.5** + +### Property 8: Cohérence de l'infobulle carte avec la Distance_Effective_Arrondie + +*For any* trajet et toute précision valide, la distance présentée dans l'infobulle de la carte est strictement égale à `distanceEffectiveArrondie(trajet.distanceBrute, trajet.allerRetour, precision)`. + +**Validates: Requirements 9.1** + +### Property 9: Modèle de données PDF cohérent avec les résumés/régularisations + +*For any* jeu de trajets d'un mois ou d'une année, les valeurs kilométriques assemblées dans le modèle du rapport PDF (`ModeleRapportMensuel`, `ModeleRapportAnnuel`) sont strictement égales aux valeurs retournées par `IResumeService`/`IRemboursementService` pour les mêmes paramètres et la même précision courante. + +**Validates: Requirements 9.2, 9.3** + +### Configuration des tests de propriété + +- **Bibliothèque** : côté backend (.NET), utiliser **FsCheck** (ou **CsCheck**, déjà idiomatique en C#/xUnit) — bibliothèque standard PBT pour .NET, ne pas réimplémenter un générateur maison. +- **Itérations minimales** : 100 par propriété. +- **Tag de traçabilité** dans chaque test : + `// Feature: precision-distances-km, Property {n}: {texte de la propriété}` +- Chaque propriété est implémentée par **un seul test property-based** (pas un test par précision — les générateurs couvrent {0, 1, 2} et un espace de distances flottantes/décimales positives, y compris valeurs limites proches d'un seuil d'arrondi comme `12.000...1`). + +### Tests unitaires (exemples et cas limites, complémentaires aux propriétés) + +- `PrecisionDistanceService.ObtenirAsync` retourne 2 par défaut quand la table est vide (Exigence 1.2). +- `PUT /api/parametres-application` avec `precisionDistanceKm = 3` retourne 400 (Exigence 1.6, cas concret). +- `GET`/`PUT /api/parametres-application` sans jeton retourne 401 (Exigence 1.7). +- Exemple chiffré Aller_Retour documenté ci-dessus (12.30 km → 26 km avec précision 0, et non 25 km) — implémenté comme test unitaire explicite en plus de la Property 2. +- `ParametresApplicationComponent.choisir` restaure la sélection précédente et notifie une erreur si l'appel HTTP échoue (Exigence 2.5). +- Positionnement du lien « Application » entre « Compte » et « Véhicules » dans `parametrage.component.html` (test de structure du template ou test e2e léger). +- `MontantsReglesComponent` affiche `montantPrevisionnelMensuel` (et non l'ancien champ) sans erreur de compilation/liaison après le renommage du DTO. + +### Tests d'intégration + +- Un scénario bout-en-bout (base SQLite en mémoire ou fichier temporaire) : créer des trajets sur plusieurs mois, changer Precision_Distance, vérifier que `ResumeService`, `TotauxService` et `RemboursementService` renvoient des valeurs cohérentes entre elles pour les mêmes trajets (couvre l'Exigence 9.4 en test d'intégration, cf. prework 9.4). +- Génération effective d'un PDF mensuel et annuel (au moins 1 exemple chacun) pour vérifier l'absence d'exception de rendu après les changements de modèle (pas de PBT sur le rendu binaire lui-même, conformément à la règle « ne pas faire de PBT sur des opérations coûteuses/rendu »). diff --git a/.kiro/specs/precision-distances-km/requirements.md b/.kiro/specs/precision-distances-km/requirements.md new file mode 100644 index 0000000..6f61204 --- /dev/null +++ b/.kiro/specs/precision-distances-km/requirements.md @@ -0,0 +1,149 @@ +# Requirements Document + +## Introduction + +Cette fonctionnalité introduit un paramètre global de **précision d'affichage des distances** (nombre de décimales : 0, 1 ou 2) dans l'application **SchotzIAD KM Tracker**, ainsi qu'une règle d'arrondi supérieur systématique appliquée à cette précision pour toute distance affichée ou agrégée (trajet, totaux journaliers/mensuels/annuels, carte, export PDF, barème kilométrique). Elle modifie également le mode de calcul de l'indication de versement mensuelle (Montant_Previsionnel), qui passe d'un calcul basé sur le cumul annuel partiel à un calcul basé uniquement sur le mois affiché, et introduit une nouvelle ligne d'affichage « Montant prévisionnel annuel » (100% du barème, projection sur le cumul annuel partiel). + +> **Note** : Cette spec **complète** la spec existante `schotziad-km-tracker` (`requirements.md`, `design-requirements.md`, `design.md`). Elle réutilise et étend les termes déjà définis dans le glossaire de `schotziad-km-tracker` (notamment Trajet, Distance, Aller_Retour, Distance_Effective, Résumé_Mensuel, Résumé_Annuel, Total_Annuel_Partiel, Panneau_Totaux, Bareme_Kilometrique, Montant_Previsionnel, Montant_Reel, Regularisation, Frais_Reel_Mensuel, Page_Parametrage, Export_PDF, Carte). Les exigences ci-dessous priment sur celles de `schotziad-km-tracker` en cas de divergence portant sur le calcul du Montant_Previsionnel et sur la précision d'affichage des distances ; toutes les autres exigences de `schotziad-km-tracker` restent applicables sans changement. + +--- + +## Glossary + +- **Precision_Distance** : Le paramètre global de l'Application déterminant le nombre de décimales (0, 1 ou 2) utilisé pour l'arrondi supérieur des distances à l'affichage et dans les agrégats. Ce paramètre est unique pour toute l'Application (pas de déclinaison par Véhicule ni par Utilisateur). +- **Distance_Arrondie** : La valeur d'une Distance simple (non doublée) après application de l'arrondi supérieur mathématique (ceiling) à la précision définie par Precision_Distance. Exemple avec Precision_Distance = 0 : 12,3 km devient 13 km. Exemple avec Precision_Distance = 1 : 12,34 km devient 12,4 km. Exemple avec Precision_Distance = 2 : 12,347 km devient 12,35 km. +- **Distance_Effective_Arrondie** : La distance comptée d'un Trajet dans tous les agrégats et affichages une fois la règle d'arrondi appliquée : égale à la Distance_Arrondie, ou à son double lorsque le Trajet est un Aller_Retour (la Distance simple est arrondie AVANT d'être doublée, jamais après). +- **Sous_Menu_Application** : L'entrée « Application » du menu latéral de la Page_Parametrage, positionnée entre « Compte » et « Véhicules », permettant de configurer Precision_Distance. +- **Montant_Previsionnel_Mensuel** : L'indication de versement mensuelle (80%) redéfinie par la présente spec : elle correspond à 80% du Bareme_Kilometrique appliqué à la Distance_Effective_Arrondie totale du seul mois affiché (et non plus au Total_Annuel_Partiel). +- **Montant_Previsionnel_Annuel** : La nouvelle ligne d'affichage introduite par la présente spec, calculée comme 100% (sans minoration) du Bareme_Kilometrique appliqué au Total_Annuel_Partiel arrondi (cumul de l'année sélectionnée jusqu'au mois affiché inclus), affichée sous le Montant_Previsionnel_Mensuel. + +--- + +## Requirements + +### Requirement 1: Paramètre global de précision des distances + +**User Story:** En tant qu'utilisateur, je veux choisir le nombre de décimales utilisé pour l'affichage des distances en kilomètres, afin d'adapter la précision affichée à mes besoins (ex. arrondi à l'unité pour une lecture rapide, ou deux décimales pour une précision fine). + +#### Acceptance Criteria + +1. THE Backend SHALL persister une valeur unique de Precision_Distance pour l'ensemble de l'Application, parmi exactement trois valeurs possibles : 0, 1 ou 2. +2. WHERE aucune valeur de Precision_Distance n'a encore été enregistrée, THE Backend SHALL considérer la valeur par défaut de Precision_Distance comme égale à 2. +3. THE Backend SHALL exposer une API protégée par authentification permettant de lire la valeur courante de Precision_Distance. +4. THE Backend SHALL exposer une API protégée par authentification permettant de modifier la valeur de Precision_Distance. +5. WHEN l'utilisateur soumet une nouvelle valeur de Precision_Distance égale à 0, 1 ou 2, THE Backend SHALL persister cette valeur et SHALL l'appliquer immédiatement à tous les calculs et affichages ultérieurs de distances, pour les Trajets passés comme futurs, sans migration ni recalcul des données stockées. +6. IF le Backend reçoit une valeur de Precision_Distance différente de 0, 1 ou 2, THEN THE Backend SHALL rejeter la modification et retourner un message d'erreur indiquant que seules les valeurs 0, 1 et 2 sont autorisées. +7. IF le Backend reçoit une requête de lecture ou de modification de Precision_Distance sans Session authentifiée valide, THEN THE Backend SHALL rejeter la requête. +8. THE Backend SHALL ne jamais modifier la valeur brute stockée de la Distance d'un Trajet (colonne Distance existante) ni les calculs de Calculateur_Distance (routier ou Haversine) suite à un changement de Precision_Distance ; seuls l'affichage et les agrégats calculés à la volée sont affectés. + +--- + +### Requirement 2: Sous-menu « Application » dans le paramétrage + +**User Story:** En tant qu'utilisateur, je veux accéder à un sous-menu « Application » dans la page de paramétrage, afin de configurer la précision d'affichage des distances au même endroit que mes autres réglages. + +#### Acceptance Criteria + +1. THE Page_Parametrage SHALL présenter, dans son menu latéral, l'entrée Sous_Menu_Application positionnée entre l'entrée « Compte » et l'entrée « Véhicules » (ordre : Compte, Application, Véhicules, Barème). +2. WHEN l'utilisateur sélectionne Sous_Menu_Application dans le menu latéral de la Page_Parametrage, THE Frontend SHALL afficher à droite du menu un contrôle de sélection « Nombre de décimales des distances (km) » proposant exactement trois choix : 0, 1 et 2, sans rechargement complet de la page. +3. WHEN la page Sous_Menu_Application est affichée, THE Frontend SHALL présélectionner le choix correspondant à la valeur courante de Precision_Distance renvoyée par le Backend. +4. WHILE la page Sous_Menu_Application est affichée, WHEN l'utilisateur sélectionne une valeur différente pour Precision_Distance, THE Frontend SHALL envoyer la nouvelle valeur au Backend et afficher un message de confirmation lorsque l'enregistrement réussit. +5. IF l'enregistrement d'une nouvelle valeur de Precision_Distance échoue au niveau du Backend, THEN THE Frontend SHALL afficher un message d'erreur indiquant que la modification n'a pas pu être enregistrée et SHALL conserver l'affichage de la valeur précédemment active. +6. THE Backend SHALL autoriser l'accès à Sous_Menu_Application indépendamment de l'état de configuration du Profil (Profil_Configure ou non), de la même manière que les entrées « Compte » et « Véhicules » de la Page_Parametrage. + +--- + +### Requirement 3: Arrondi supérieur d'un trajet simple + +**User Story:** En tant qu'utilisateur, je veux que la distance affichée d'un trajet simple soit arrondie au supérieur selon la précision choisie, afin d'obtenir un affichage cohérent et jamais sous-évalué. + +#### Acceptance Criteria + +1. WHEN le Frontend affiche la distance d'un Trajet qui n'est pas un Aller_Retour, THE Frontend SHALL afficher la Distance_Arrondie de ce Trajet, calculée par arrondi supérieur mathématique de la Distance brute à la précision définie par Precision_Distance. +2. WHILE Precision_Distance est égal à 0, THE Distance_Arrondie SHALL être égale à la Distance brute arrondie au kilomètre entier supérieur (ex. 12,3 km devient 13 km ; 12,0 km reste 12 km). +3. WHILE Precision_Distance est égal à 1, THE Distance_Arrondie SHALL être égale à la Distance brute arrondie au dixième de kilomètre supérieur (ex. 12,34 km devient 12,4 km). +4. WHILE Precision_Distance est égal à 2, THE Distance_Arrondie SHALL être égale à la Distance brute arrondie au centième de kilomètre supérieur (ex. 12,347 km devient 12,35 km). +5. THE Distance_Arrondie d'un Trajet SHALL toujours être supérieure ou égale à la Distance brute correspondante, quelle que soit la valeur de Precision_Distance. + +--- + +### Requirement 4: Arrondi supérieur d'un trajet aller-retour + +**User Story:** En tant qu'utilisateur, je veux que la distance affichée d'un trajet aller-retour soit le double de la distance simple déjà arrondie, afin que l'ordre des opérations (arrondi puis doublement) soit cohérent et prévisible. + +#### Acceptance Criteria + +1. WHEN le Frontend affiche la distance d'un Trajet dont Aller_Retour est vrai, THE Frontend SHALL afficher la Distance_Effective_Arrondie égale au double de la Distance_Arrondie de la distance simple mesurée entre le départ et l'arrivée. +2. THE Backend SHALL calculer la Distance_Effective_Arrondie d'un Trajet Aller_Retour en appliquant l'arrondi supérieur à la distance simple AVANT de la multiplier par deux, et jamais en doublant d'abord la distance brute puis en arrondissant le résultat. +3. THE Distance_Effective_Arrondie d'un Trajet non-Aller_Retour SHALL être égale à sa Distance_Arrondie (sans doublement). + +--- + +### Requirement 5: Agrégation des totaux à partir des distances arrondies + +**User Story:** En tant qu'utilisateur, je veux que les totaux du jour, du mois et de l'année soient calculés en additionnant des distances déjà arrondies, afin que la somme affichée soit cohérente avec la somme visuelle des lignes de détail. + +#### Acceptance Criteria + +1. WHEN le Backend ou le Frontend calcule le total kilométrique d'une journée, THE Backend ou THE Frontend SHALL additionner la Distance_Effective_Arrondie de chaque Trajet de cette journée, sans appliquer d'arrondi supplémentaire après la somme. +2. WHEN le Backend calcule le total kilométrique d'un Résumé_Mensuel, THE Backend SHALL additionner la Distance_Effective_Arrondie de chaque Trajet du mois concerné, sans appliquer d'arrondi supplémentaire après la somme. +3. WHEN le Backend calcule le total kilométrique d'un Résumé_Annuel ou le Total_Annuel_Partiel, THE Backend SHALL additionner la Distance_Effective_Arrondie de chaque Trajet des mois concernés, sans appliquer d'arrondi supplémentaire après la somme. +4. THE Panneau_Totaux SHALL afficher le total du jour, le total du mois sélectionné et le Total_Annuel_Partiel de l'année sélectionnée en appliquant la règle de sommation des distances déjà arrondies définie par la présente exigence. +5. WHEN Precision_Distance est modifié, THE Frontend SHALL recalculer et afficher immédiatement les totaux du jour, du mois et de l'année selon la nouvelle valeur de Precision_Distance, sans rechargement complet de la page. + +--- + +### Requirement 6: Application de l'arrondi au barème kilométrique + +**User Story:** En tant qu'utilisateur, je veux que les calculs de barème kilométrique (indication de versement, montant réel, régularisation) utilisent les distances arrondies affichées, afin que les montants calculés correspondent aux kilomètres que je vois à l'écran. + +#### Acceptance Criteria + +1. WHEN le Backend calcule le Montant_Previsionnel_Mensuel, THE Backend SHALL appliquer le Bareme_Kilometrique à la somme des Distance_Effective_Arrondie des Trajets du mois affiché, et non à la Distance brute. +2. WHEN le Backend calcule le Montant_Previsionnel_Annuel, THE Backend SHALL appliquer le Bareme_Kilometrique à la valeur arrondie du Total_Annuel_Partiel telle que définie par l'Exigence 5. +3. WHEN le Backend calcule le Montant_Reel annuel d'un Véhicule, THE Backend SHALL appliquer le Bareme_Kilometrique plein (100%) au total kilométrique annuel obtenu par sommation des Distance_Effective_Arrondie de tous les Trajets de l'année, et non des Distances brutes. +4. WHEN le Backend calcule le Frais_Reel_Mensuel de chaque mois, THE Backend SHALL multiplier la somme des Distance_Effective_Arrondie des Trajets du mois par le coefficient de la tranche annuelle applicable. +5. WHEN le Backend calcule la Regularisation d'un Véhicule pour une année, THE Backend SHALL utiliser le Montant_Reel annuel calculé à partir des distances arrondies conformément à la présente exigence. +6. THE Backend SHALL déterminer la Tranche_Bareme applicable (mensuelle ou annuelle) à partir du total kilométrique arrondi correspondant, et non à partir du total kilométrique brut. + +--- + +### Requirement 7: Indication de versement mensuelle recentrée sur le mois affiché + +**User Story:** En tant qu'utilisateur, je veux que l'indication de versement (80%) corresponde uniquement au mois que je consulte, afin de mieux estimer le montant à verser pour ce mois précis plutôt que pour tout le cumul annuel. + +#### Acceptance Criteria + +1. WHEN l'utilisateur consulte les données d'un mois, THE Frontend SHALL afficher le Montant_Previsionnel_Mensuel calculé comme 80% du Bareme_Kilometrique appliqué à la Distance_Effective_Arrondie totale du seul mois affiché, sans y inclure les distances des mois précédents de l'année. +2. THE Backend SHALL déterminer la Tranche_Bareme utilisée pour le Montant_Previsionnel_Mensuel à partir du total kilométrique annuel arrondi cumulé (Total_Annuel_Partiel), conformément à la règle de sélection de tranche du Bareme_Kilometrique définie dans `schotziad-km-tracker` (Requirement 13), tout en appliquant le coefficient ainsi déterminé au seul kilométrage arrondi du mois affiché. +3. THE Frontend SHALL continuer à indiquer explicitement que le Montant_Previsionnel_Mensuel est une simple indication de versement et que le montant réellement versé est celui saisi par l'utilisateur (Montant_Regle). +4. THE présente exigence SHALL remplacer, pour le calcul du Montant_Previsionnel mensuel, la règle de calcul antérieure basée sur le Total_Annuel_Partiel définie dans `schotziad-km-tracker` (Requirement 13, critère 5). + +--- + +### Requirement 8: Montant prévisionnel annuel + +**User Story:** En tant qu'utilisateur, je veux voir, en dessous de l'indication de versement mensuelle, une projection du montant prévisionnel annuel sans minoration, afin d'avoir une vision du montant total attendu sur l'année en cours. + +#### Acceptance Criteria + +1. WHEN l'utilisateur consulte les données d'un mois, THE Frontend SHALL afficher, immédiatement sous le Montant_Previsionnel_Mensuel, une ligne « Montant prévisionnel annuel » présentant le Montant_Previsionnel_Annuel. +2. THE Backend SHALL calculer le Montant_Previsionnel_Annuel en appliquant le Bareme_Kilometrique sans minoration (100%) au Total_Annuel_Partiel arrondi de l'année sélectionnée, cumulé jusqu'au mois affiché inclus. +3. THE Frontend SHALL indiquer explicitement que le Montant_Previsionnel_Annuel est une projection indicative sans minoration (100% du barème) et qu'il ne se substitue pas au Montant_Reel calculé en fin d'année sur la base du kilométrage annuel complet. +4. THE Frontend SHALL afficher le Montant_Previsionnel_Annuel avec une précision de deux décimales, selon les mêmes conventions d'affichage monétaire que le Montant_Previsionnel_Mensuel. +5. THE Backend SHALL déterminer la Tranche_Bareme utilisée pour le Montant_Previsionnel_Annuel à partir du même total kilométrique arrondi (Total_Annuel_Partiel) auquel le barème est appliqué. + +--- + +### Requirement 9: Cohérence de l'arrondi sur la carte et dans l'export PDF + +**User Story:** En tant qu'utilisateur, je veux que la carte et les exports PDF affichent la même distance arrondie que la liste des trajets et les totaux, afin de ne jamais voir de chiffres contradictoires selon l'endroit de l'application consulté. + +#### Acceptance Criteria + +1. WHEN l'utilisateur survole ou clique sur un tracé de Trajet sur la Carte, THE Frontend SHALL afficher dans l'infobulle la Distance_Effective_Arrondie de ce Trajet, calculée selon la valeur courante de Precision_Distance. +2. WHEN le Backend génère un Export_PDF (mensuel ou annuel), THE Backend SHALL utiliser la Distance_Effective_Arrondie de chaque Trajet, ainsi que les totaux calculés à partir de ces distances arrondies conformément à l'Exigence 5, pour toutes les valeurs kilométriques figurant dans le document. +3. WHEN le Backend génère un Export_PDF, THE Backend SHALL appliquer la valeur de Precision_Distance en vigueur au moment de la génération du document pour arrondir les distances affichées dans le PDF. +4. THE Backend SHALL garantir que la Distance_Effective_Arrondie utilisée pour un même Trajet est strictement identique, à valeur de Precision_Distance égale, dans la liste des Trajets, le Panneau_Totaux, la Carte, l'Export_PDF et les calculs de Bareme_Kilometrique. + +--- diff --git a/.kiro/specs/precision-distances-km/tasks.md b/.kiro/specs/precision-distances-km/tasks.md new file mode 100644 index 0000000..3a6e083 --- /dev/null +++ b/.kiro/specs/precision-distances-km/tasks.md @@ -0,0 +1,196 @@ +# Implementation Plan: Précision des distances (km) + +## Overview + +Cette implémentation ajoute un paramètre global `Precision_Distance` (0/1/2 décimales) avec arrondi supérieur (ceiling) systématique côté backend et frontend, refond le calcul du Montant_Previsionnel (mensuel recentré sur le mois affiché + nouveau montant annuel 100%), et propage la cohérence de l'arrondi à la liste des trajets, aux totaux, à la carte, à l'export PDF et au barème kilométrique. + +L'ordre des tâches suit les dépendances réelles : entité + migration → service de précision pur → intégration dans les services d'agrégation existants → refonte du calcul prévisionnel → cohérence carte/PDF → tests backend → couche frontend (service/util → composant/route → consommateurs) → vérification finale. + +## Tasks + +- [x] 1. Backend — Entité `ParametresApplication` et migration EF Core + - Créer `Models/Entities/ParametresApplication.cs` (singleton `Id = 1`, `PrecisionDistanceKm` défaut 2, `UpdatedAt`) + - Ajouter `DbSet ParametresApplication` et la configuration `OnModelCreating` (contrainte CHECK `IN (0,1,2)`, clé `ValueGeneratedNever()`, index unique singleton) dans `Data/AppDbContext.cs` + - Générer la migration EF Core (`dotnet ef migrations add AjoutParametresApplication`) créant la table avec la contrainte CHECK + - _Requirements: 1.1, 1.2_ + +- [x] 2. Backend — Service de précision et exception métier + - [x] 2.1 Créer l'exception `Services/Exceptions/PrecisionDistanceInvalideException.cs` (même modèle que `MontantRegleNegatifException`) + - _Requirements: 1.6_ + - [x] 2.2 Créer `Services/IPrecisionDistanceService.cs` (`ObtenirAsync`, `DefinirAsync`, `ArrondirDistance`) + - _Requirements: 1.1, 1.2, 1.3, 1.4, 1.6, 1.8, 3.1, 3.2, 3.3, 3.4, 3.5, 4.2_ + - [x] 2.3 Implémenter `Services/PrecisionDistanceService.cs` + - `GetOrCreateAsync` privé créant la ligne singleton par défaut (2) si absente + - `ObtenirAsync`/`DefinirAsync` avec validation stricte `{0,1,2}` levant `PrecisionDistanceInvalideException` + - `ArrondirDistance` : `Ceiling(distance × 10^precision) / 10^precision` + - _Requirements: 1.1, 1.2, 1.5, 1.6, 1.8, 3.1, 3.2, 3.3, 3.4, 3.5_ + - [x]* 2.4 Écrire les tests de propriété pour `PrecisionDistanceService` + - **Property 1: Arrondi supérieur exact et jamais inférieur à la distance brute** — _Validates: Requirements 3.1, 3.2, 3.3, 3.4, 3.5_ + - **Property 4: Validation stricte de la précision** — _Validates: Requirements 1.6_ + - **Property 5: Invariance de la distance brute stockée face à un changement de précision** — _Validates: Requirements 1.5, 1.8_ + - [ ]* 2.5 Écrire les tests unitaires `PrecisionDistanceService` + - `ObtenirAsync` retourne 2 par défaut quand la table est vide (Exigence 1.2) + - `DefinirAsync(3)` lève `PrecisionDistanceInvalideException` (Exigence 1.6, cas concret) + - _Requirements: 1.2, 1.6_ + +- [x] 3. Backend — DTOs et contrôleur `ParametresApplicationController` + - [x] 3.1 Créer `Models/DTOs/ParametresApplicationDtos.cs` (`ParametresApplicationDto`, `SavePrecisionDistanceDto`) + - _Requirements: 1.3, 1.4_ + - [x] 3.2 Créer `Controllers/ParametresApplicationController.cs` (GET/PUT `api/parametres-application`, mapping `PrecisionDistanceInvalideException` → 400) + - _Requirements: 1.3, 1.4, 1.6, 1.7_ + - [x] 3.3 Enregistrer `IPrecisionDistanceService`/`PrecisionDistanceService` dans `Program.cs` (`AddScoped`, section services métier) + - _Requirements: 1.1, 1.3, 1.4_ + - [ ]* 3.4 Écrire les tests d'intégration du contrôleur + - `PUT /api/parametres-application` avec `precisionDistanceKm = 3` retourne 400 (Exigence 1.6) + - `GET`/`PUT /api/parametres-application` sans jeton retourne 401 (Exigence 1.7) + - _Requirements: 1.3, 1.4, 1.6, 1.7_ + +- [x] 4. Checkpoint — Ensure all tests pass + - Ensure all tests pass, ask the user if questions arise. + +- [x] 5. Backend — Intégration de l'arrondi dans les services d'agrégation existants + - [x] 5.1 Modifier `Services/ResumeService.cs` : injecter `IPrecisionDistanceService`, appliquer `ArrondirDistance(Distance, precision) × (AllerRetour ? 2 : 1)` par trajet dans `ConstruireResumeMensuel`, exposer `TrajetDto.Distance` déjà arrondi, sommer les valeurs déjà arrondies pour `TotalKm` sans second arrondi + - _Requirements: 4.1, 4.2, 4.3, 5.2, 5.3_ + - [x] 5.2 Modifier `Services/TotauxService.cs` : injecter `IPrecisionDistanceService`, remplacer la fonction locale `Effective(distance, allerRetour)` par l'arrondi avant doublement, supprimer le `Math.Round(..., 2, ...)` final existant sur `TotalJour`/`TotalMois`/`TotalAnnuelPartiel` + - _Requirements: 4.1, 4.2, 4.3, 5.1, 5.4_ + - [x] 5.3 Modifier `Services/RemboursementService.cs` : injecter `IPrecisionDistanceService`, construire `kmMoisMap` à partir des distances arrondies par trajet (au lieu de la distance brute), garantissant `totalKmAnnuel` et chaque `KmMois` comme sommes de distances déjà arrondies + - _Requirements: 4.1, 4.2, 4.3, 6.3, 6.4, 6.6_ + - [x]* 5.4 Écrire le test de propriété pour la sommation + - **Property 2: Arrondi avant doublement pour Aller_Retour** — _Validates: Requirements 4.1, 4.2, 4.3_ + - **Property 3: Sommation de distances déjà arrondies sans arrondi supplémentaire** — _Validates: Requirements 5.1, 5.2, 5.3, 5.4_ + - [x]* 5.5 Écrire le test unitaire de l'exemple chiffré Aller_Retour + - Cas 12.30 km, précision 0 → 26 km (et non 25 km), en plus de la Property 2 + - _Requirements: 4.2_ + +- [x] 6. Backend — Refonte de `MontantRegleService.GetMontantPrevisionnelAsync` + - [x] 6.1 Créer/modifier le DTO `MontantPrevisionnelDto` (`TotalMoisKm`, `TotalAnnuelPartielKm`, `MontantPrevisionnelMensuel`, `MontantPrevisionnelAnnuel`) dans `Models/DTOs/` + - _Requirements: 6.1, 6.2, 7.1, 8.1, 8.2, 8.4_ + - [x] 6.2 Modifier `Services/IMontantRegleService.cs` et `Services/MontantRegleService.cs` : injecter `IPrecisionDistanceService`, calculer `totalMoisAffiche`/`totalAnnuelPartiel` à partir des distances arrondies, déterminer la tranche via le cumul annuel (`baremeAnnuel`), appliquer son coefficient/base au total du mois pour `MontantPrevisionnelMensuel` (80%), calculer `MontantPrevisionnelAnnuel` (100% sur le cumul) + - _Requirements: 6.1, 6.2, 6.6, 7.1, 7.2, 7.4, 8.1, 8.2, 8.5_ + - [x]* 6.3 Écrire les tests de propriété pour le calcul prévisionnel + - **Property 6: Montant_Previsionnel_Mensuel dépend uniquement du mois affiché** — _Validates: Requirements 7.1, 7.2_ + - **Property 7: Montant_Previsionnel_Annuel égal au barème plein sur le cumul** — _Validates: Requirements 8.2, 8.5_ + - [ ]* 6.4 Écrire les tests unitaires de `GetMontantPrevisionnelAsync` + - Véhicule introuvable → `VehiculeNotFoundException` (comportement existant inchangé) + - Cas limite : trajets avec distance `null` ignorés dans la somme + - _Requirements: 6.1, 6.2, 7.1, 8.1, 8.2_ + +- [x] 7. Backend — Cohérence carte et export PDF + - [x] 7.1 Vérifier/corriger l'endpoint trajets/journée (`ITrajetService`/`TrajetsController`, méthode consommée par `TrajetService.getTrajetsJournee`) pour renvoyer la Distance_Effective_Arrondie via `IPrecisionDistanceService` + - _Requirements: 9.1, 9.4_ + - [x] 7.2 Vérifier `Services/PdfService.cs` (`AssemblerModeleMensuelAsync`, composition des tables mensuelle/annuelle) : confirmer qu'aucun recalcul de distance brute ne subsiste et que le modèle assemblé provient intégralement de `IResumeService`/`IRemboursementService` déjà corrigés + - _Requirements: 9.2, 9.3_ + - [ ]* 7.3 Écrire les tests de propriété de cohérence carte/PDF + - **Property 8: Cohérence de l'infobulle carte avec la Distance_Effective_Arrondie** — _Validates: Requirements 9.1_ + - **Property 9: Modèle de données PDF cohérent avec les résumés/régularisations** — _Validates: Requirements 9.2, 9.3_ + - [ ]* 7.4 Écrire le test d'intégration de cohérence croisée + - Scénario bout-en-bout (SQLite en mémoire) : créer des trajets sur plusieurs mois, changer Precision_Distance, vérifier l'égalité des valeurs entre `ResumeService`, `TotauxService` et `RemboursementService` (Exigence 9.4) + - _Requirements: 9.4_ + - [ ]* 7.5 Écrire les tests d'intégration de génération PDF + - Génération effective d'un PDF mensuel et d'un PDF annuel (1 exemple chacun), vérifier l'absence d'exception après les changements de modèle + - _Requirements: 9.2, 9.3_ + +- [x] 8. Checkpoint — Ensure all tests pass + - Ensure all tests pass, ask the user if questions arise. + +- [x] 9. Frontend — Modèle, service et utilitaire d'arrondi + - [x] 9.1 Créer `core/models/parametres-application.model.ts` (`ParametresApplication { precisionDistanceKm: number }`) + - _Requirements: 1.3, 1.4_ + - [x] 9.2 Créer `core/services/parametres-application.service.ts` (`ParametresApplicationService` : signal partagé `precisionDistance`, `charger()`, `definirPrecisionDistance()`) + - _Requirements: 1.3, 1.4, 2.3, 2.4, 2.5_ + - [x] 9.3 Créer `shared/utils/arrondir-distance.ts` (`arrondirDistance`, `distanceEffectiveArrondie`), miroir exact de la formule backend + - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 4.1, 4.2, 4.3, 5.5_ + - [ ]* 9.4 Écrire les tests unitaires de `arrondirDistance`/`distanceEffectiveArrondie` + - Cas 12.30 km, précision 0, aller-retour → 26 km (miroir du test backend) + - Cas limites par précision (0/1/2) et valeurs proches d'un seuil d'arrondi + - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 4.1, 4.2, 4.3_ + - [x]* 9.5 Mettre à jour `core/models/bareme.model.ts` et `core/services/bareme.service.ts` avec les nouveaux champs `MontantPrevisionnel` (`totalMoisKm`, `totalAnnuelPartielKm`, `montantPrevisionnelMensuel`, `montantPrevisionnelAnnuel`) + - _Requirements: 6.1, 7.1, 8.1, 8.2, 8.4_ + +- [x] 10. Frontend — Composant `ParametresApplicationComponent` et route/menu + - [x] 10.1 Créer `features/parametres-application/parametres-application.component.ts` (+ `.html`, `.scss`) : sélection 0/1/2, présélection de la valeur courante, confirmation de succès, restauration + notification d'erreur en cas d'échec + - _Requirements: 2.2, 2.3, 2.4, 2.5_ + - [x] 10.2 Ajouter la route `/parametrage/application` dans `app.routes.ts`, entre `compte` et `vehicules`, gardée uniquement par `authGuard` (pas `profilConfigureGuard`) + - _Requirements: 2.1, 2.6_ + - [x] 10.3 Ajouter le lien « Application » entre « Compte » et « Véhicules » dans `features/parametrage/parametrage.component.html` + - _Requirements: 2.1_ + - [ ]* 10.4 Écrire les tests unitaires du composant `ParametresApplicationComponent` + - Présélection de la valeur courante au chargement (Exigence 2.3) + - `choisir()` restaure la sélection précédente et notifie une erreur si l'appel HTTP échoue (Exigence 2.5) + - _Requirements: 2.3, 2.4, 2.5_ + - [ ]* 10.5 Écrire le test de structure du menu de paramétrage + - Vérifier le positionnement du lien « Application » entre « Compte » et « Véhicules » + - _Requirements: 2.1_ + +- [x] 11. Frontend — Chargement initial dans `AppComponent` + - [x] 11.1 Modifier `app.component.ts` pour appeler `ParametresApplicationService.charger()` au même moment que le chargement du profil (effect déclenché à l'authentification) + - _Requirements: 1.3, 5.5_ + +- [x] 12. Checkpoint — Ensure all tests pass + - Ensure all tests pass, ask the user if questions arise. + +- [x] 13. Frontend — Adaptation des composants consommateurs + - [x] 13.1 Modifier `features/trajet-list/trajet-list.component.ts` (méthode `distanceAffichee`) : formater selon `ParametresApplicationService.precisionDistance()` au lieu d'un arrondi fixe à 2 décimales + - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5_ + - [x] 13.2 Modifier `features/panneau-totaux/panneau-totaux.component.ts` + `.html` : format dynamique des distances basé sur `precisionDistance()`, ajout de la ligne « Montant prévisionnel annuel » sous l'indication de versement mensuelle, consommation de `montantPrevisionnelMensuel`/`montantPrevisionnelAnnuel` + - _Requirements: 5.4, 5.5, 8.1, 8.3, 8.4_ + - [x] 13.3 Modifier `features/carte-trajets/carte-trajets.component.ts` (méthode `contenuInfobulle`) : `toFixed(precision)` dynamique basé sur `ParametresApplicationService.precisionDistance()` + - _Requirements: 9.1_ + - [x] 13.4 Modifier `features/montants-regles/montants-regles.component.ts` : lire `montantPrevisionnelMensuel` au lieu de `montantPrevisionnel` + - _Requirements: 7.1, 7.3_ + - [ ]* 13.5 Écrire les tests unitaires des composants adaptés + - `TrajetListComponent.distanceAffichee` formate selon la précision courante + - `PanneauTotauxComponent` affiche la nouvelle ligne « Montant prévisionnel annuel » + - `CarteTrajetsComponent.contenuInfobulle` utilise la précision courante + - `MontantsReglesComponent` affiche `montantPrevisionnelMensuel` sans erreur de liaison après le renommage du DTO + - _Requirements: 3.1, 5.4, 7.1, 7.3, 8.1, 8.3, 8.4, 9.1_ + +- [x] 14. Checkpoint final — Ensure all tests pass + - Ensure all tests pass, ask the user if questions arise. + +- [x] 15. Vérification finale + - [x] 15.1 Exécuter le build backend (`dotnet build`) et le build frontend (`ng build` / `npm run build`), corriger toute erreur de compilation résultant des changements de DTO/modèle + - _Requirements: 1.1–9.4 (non-régression globale)_ + - [x] 15.2 Exécuter l'ensemble des tests backend (`dotnet test`) et frontend (`ng test` / `vitest --run`), vérifier que toutes les propriétés et tous les tests unitaires/intégration passent + - _Requirements: 1.1–9.4 (non-régression globale)_ + +## Notes + +- Les tâches marquées `*` sont optionnelles (tests) et peuvent être ignorées pour un MVP plus rapide, mais restent recommandées vu la présence de 9 Correctness Properties dans le design. +- Chaque tâche référence les exigences granulaires concernées pour la traçabilité. +- Les checkpoints garantissent une validation incrémentale avant de passer à la couche suivante (backend cœur → calcul prévisionnel → cohérence carte/PDF → frontend). +- Les tests de propriété utilisent FsCheck (déjà présent dans `SchotzIadKmTracker.Tests.csproj`), avec au moins 100 itérations par propriété et le tag de traçabilité `// Feature: precision-distances-km, Property {n}: {texte}`. +- La tâche 6.2 constitue une rupture de contrat mineure sur `MontantPrevisionnelDto` : les tâches frontend 9.5 et 13.4 doivent être réalisées après la tâche 6.1 pour rester synchronisées avec les nouveaux noms de champs. + +## Task Dependency Graph + +```json +{ + "waves": [ + { "id": 0, "tasks": ["1"] }, + { "id": 1, "tasks": ["2.1"] }, + { "id": 2, "tasks": ["2.2"] }, + { "id": 3, "tasks": ["2.3"] }, + { "id": 4, "tasks": ["2.4", "2.5", "3.1"] }, + { "id": 5, "tasks": ["3.2"] }, + { "id": 6, "tasks": ["3.3"] }, + { "id": 7, "tasks": ["3.4"] }, + { "id": 8, "tasks": ["5.1", "5.2", "5.3"] }, + { "id": 9, "tasks": ["5.4", "5.5", "6.1"] }, + { "id": 10, "tasks": ["6.2"] }, + { "id": 11, "tasks": ["6.3", "6.4", "7.1"] }, + { "id": 12, "tasks": ["7.2"] }, + { "id": 13, "tasks": ["7.3", "7.4", "7.5"] }, + { "id": 14, "tasks": ["9.1"] }, + { "id": 15, "tasks": ["9.2"] }, + { "id": 16, "tasks": ["9.3", "9.5"] }, + { "id": 17, "tasks": ["9.4", "10.1"] }, + { "id": 18, "tasks": ["10.2", "10.3"] }, + { "id": 19, "tasks": ["10.4", "10.5", "11.1"] }, + { "id": 20, "tasks": ["13.1", "13.2", "13.3", "13.4"] }, + { "id": 21, "tasks": ["13.5"] }, + { "id": 22, "tasks": ["15.1"] }, + { "id": 23, "tasks": ["15.2"] } + ] +} +``` diff --git a/.kiro/specs/precision-distances-km/tasks.meta.json b/.kiro/specs/precision-distances-km/tasks.meta.json new file mode 100644 index 0000000..68b6eb1 --- /dev/null +++ b/.kiro/specs/precision-distances-km/tasks.meta.json @@ -0,0 +1,637 @@ +{ + "pbtResults": {}, + "executionHistory": { + "1. Backend — Entité `ParametresApplication` et migration EF Core": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603235 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324614373 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324711242 + } + ], + "2.1 Créer l'exception `Services/Exceptions/PrecisionDistanceInvalideException.cs` (même modèle que `MontantRegleNegatifException`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603514 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324715209 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324763012 + } + ], + "2.2 Créer `Services/IPrecisionDistanceService.cs` (`ObtenirAsync`, `DefinirAsync`, `ArrondirDistance`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603633 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324767607 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324819140 + } + ], + "2.3 Implémenter `Services/PrecisionDistanceService.cs`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603727 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324824384 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324882607 + } + ], + "3.1 Créer `Models/DTOs/ParametresApplicationDtos.cs` (`ParametresApplicationDto`, `SavePrecisionDistanceDto`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603798 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324892736 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324931371 + } + ], + "3.2 Créer `Controllers/ParametresApplicationController.cs` (GET/PUT `api/parametres-application`, mapping `PrecisionDistanceInvalideException` → 400)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603868 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324949397 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325012025 + } + ], + "3.3 Enregistrer `IPrecisionDistanceService`/`PrecisionDistanceService` dans `Program.cs` (`AddScoped`, section services métier)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324603948 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325016241 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325065910 + } + ], + "4. Checkpoint — Ensure all tests pass": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604002 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325074171 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325267173 + } + ], + "5.1 Modifier `Services/ResumeService.cs` : injecter `IPrecisionDistanceService`, appliquer `ArrondirDistance(Distance, precision) × (AllerRetour ? 2 : 1)` par trajet dans `ConstruireResumeMensuel`, exposer `TrajetDto.Distance` déjà arrondi, sommer les valeurs déjà arrondies pour `TotalKm` sans second arrondi": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604065 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325283389 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325405943 + } + ], + "5.2 Modifier `Services/TotauxService.cs` : injecter `IPrecisionDistanceService`, remplacer la fonction locale `Effective(distance, allerRetour)` par l'arrondi avant doublement, supprimer le `Math.Round(..., 2, ...)` final existant sur `TotalJour`/`TotalMois`/`TotalAnnuelPartiel`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604119 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325285149 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325407417 + } + ], + "5.3 Modifier `Services/RemboursementService.cs` : injecter `IPrecisionDistanceService`, construire `kmMoisMap` à partir des distances arrondies par trajet (au lieu de la distance brute), garantissant `totalKmAnnuel` et chaque `KmMois` comme sommes de distances déjà arrondies": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604176 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325286774 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325409159 + } + ], + "6.1 Créer/modifier le DTO `MontantPrevisionnelDto` (`TotalMoisKm`, `TotalAnnuelPartielKm`, `MontantPrevisionnelMensuel`, `MontantPrevisionnelAnnuel`) dans `Models/DTOs/`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604233 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325415845 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325475007 + } + ], + "6.2 Modifier `Services/IMontantRegleService.cs` et `Services/MontantRegleService.cs` : injecter `IPrecisionDistanceService`, calculer `totalMoisAffiche`/`totalAnnuelPartiel` à partir des distances arrondies, déterminer la tranche via le cumul annuel (`baremeAnnuel`), appliquer son coefficient/base au total du mois pour `MontantPrevisionnelMensuel` (80%), calculer `MontantPrevisionnelAnnuel` (100% sur le cumul)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604288 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325477020 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325597163 + } + ], + "7.1 Vérifier/corriger l'endpoint trajets/journée (`ITrajetService`/`TrajetsController`, méthode consommée par `TrajetService.getTrajetsJournee`) pour renvoyer la Distance_Effective_Arrondie via `IPrecisionDistanceService`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604402 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325603594 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325715537 + } + ], + "7.2 Vérifier `Services/PdfService.cs` (`AssemblerModeleMensuelAsync`, composition des tables mensuelle/annuelle) : confirmer qu'aucun recalcul de distance brute ne subsiste et que le modèle assemblé provient intégralement de `IResumeService`/`IRemboursementService` déjà corrigés": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604453 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325605135 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325717074 + } + ], + "8. Checkpoint — Ensure all tests pass": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604508 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325722240 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326716373 + } + ], + "9.1 Créer `core/models/parametres-application.model.ts` (`ParametresApplication { precisionDistanceKm: number }`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604565 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326726636 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326790793 + } + ], + "9.2 Créer `core/services/parametres-application.service.ts` (`ParametresApplicationService` : signal partagé `precisionDistance`, `charger()`, `definirPrecisionDistance()`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604619 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326796128 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326877000 + } + ], + "9.3 Créer `shared/utils/arrondir-distance.ts` (`arrondirDistance`, `distanceEffectiveArrondie`), miroir exact de la formule backend": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604682 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326882045 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326945574 + } + ], + "10.1 Créer `features/parametres-application/parametres-application.component.ts` (+ `.html`, `.scss`) : sélection 0/1/2, présélection de la valeur courante, confirmation de succès, restauration + notification d'erreur en cas d'échec": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604751 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326959853 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327069685 + } + ], + "10.2 Ajouter la route `/parametrage/application` dans `app.routes.ts`, entre `compte` et `vehicules`, gardée uniquement par `authGuard` (pas `profilConfigureGuard`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604815 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327075529 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327196670 + } + ], + "10.3 Ajouter le lien « Application » entre « Compte » et « Véhicules » dans `features/parametrage/parametrage.component.html`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604873 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327076628 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327197485 + } + ], + "11.1 Modifier `app.component.ts` pour appeler `ParametresApplicationService.charger()` au même moment que le chargement du profil (effect déclenché à l'authentification)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324604952 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327204036 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327280212 + } + ], + "12. Checkpoint — Ensure all tests pass": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605014 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327287107 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327678359 + } + ], + "13.1 Modifier `features/trajet-list/trajet-list.component.ts` (méthode `distanceAffichee`) : formater selon `ParametresApplicationService.precisionDistance()` au lieu d'un arrondi fixe à 2 décimales": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605079 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327683970 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327885223 + } + ], + "13.2 Modifier `features/panneau-totaux/panneau-totaux.component.ts` + `.html` : format dynamique des distances basé sur `precisionDistance()`, ajout de la ligne « Montant prévisionnel annuel » sous l'indication de versement mensuelle, consommation de `montantPrevisionnelMensuel`/`montantPrevisionnelAnnuel`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605136 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327686156 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327882270 + } + ], + "13.3 Modifier `features/carte-trajets/carte-trajets.component.ts` (méthode `contenuInfobulle`) : `toFixed(precision)` dynamique basé sur `ParametresApplicationService.precisionDistance()`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605196 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327687238 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327880538 + } + ], + "13.4 Modifier `features/montants-regles/montants-regles.component.ts` : lire `montantPrevisionnelMensuel` au lieu de `montantPrevisionnel`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605263 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327688307 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327883770 + } + ], + "14. Checkpoint final — Ensure all tests pass": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605326 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327893936 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790328182621 + } + ], + "15.1 Exécuter le build backend (`dotnet build`) et le build frontend (`ng build` / `npm run build`), corriger toute erreur de compilation résultant des changements de DTO/modèle": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605386 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790328189219 + }, + { + "executionId": "7dd406e6-29f8-4020-98c1-c18461c20a8a", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790329414209 + } + ], + "15.2 Exécuter l'ensemble des tests backend (`dotnet test`) et frontend (`ng test` / `vitest --run`), vérifier que toutes les propriétés et tous les tests unitaires/intégration passent": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324605452 + }, + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790328190132 + }, + { + "executionId": "7dd406e6-29f8-4020-98c1-c18461c20a8a", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790329415260 + } + ], + "2. Backend — Service de précision et exception métier": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790324882738 + } + ], + "3. Backend — DTOs et contrôleur `ParametresApplicationController`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325065987 + } + ], + "5. Backend — Intégration de l'arrondi dans les services d'agrégation existants": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325409224 + } + ], + "6. Backend — Refonte de `MontantRegleService.GetMontantPrevisionnelAsync`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325597233 + } + ], + "7. Backend — Cohérence carte et export PDF": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325717153 + } + ], + "2.4 Écrire les tests de propriété pour `PrecisionDistanceService`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325995274 + } + ], + "5.4 Écrire le test de propriété pour la sommation": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325995448 + } + ], + "5.5 Écrire le test unitaire de l'exemple chiffré Aller_Retour": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325996594 + } + ], + "6.3 Écrire les tests de propriété pour le calcul prévisionnel": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790325997191 + } + ], + "9. Frontend — Modèle, service et utilitaire d'arrondi": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790326945673 + } + ], + "10. Frontend — Composant `ParametresApplicationComponent` et route/menu": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327197551 + } + ], + "11. Frontend — Chargement initial dans `AppComponent`": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327280285 + } + ], + "13. Frontend — Adaptation des composants consommateurs": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327885292 + } + ], + "9.5 Mettre à jour `core/models/bareme.model.ts` et `core/services/bareme.service.ts` avec les nouveaux champs `MontantPrevisionnel` (`totalMoisKm`, `totalAnnuelPartielKm`, `montantPrevisionnelMensuel`, `montantPrevisionnelAnnuel`)": [ + { + "executionId": "0004c7a8-345c-45b5-8865-a79b13f348d0", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790327886765 + } + ], + "15. Vérification finale": [ + { + "executionId": "7dd406e6-29f8-4020-98c1-c18461c20a8a", + "chatSessionId": "sess_20c9bee5-b332-43f8-922c-20b9225bb8d8", + "timestamp": 1790329415401 + } + ] + } +} \ No newline at end of file diff --git a/.kiro/specs/schotziad-km-tracker/design-requirements.md b/.kiro/specs/schotziad-km-tracker/design-requirements.md index 022b4a8..70082bb 100644 --- a/.kiro/specs/schotziad-km-tracker/design-requirements.md +++ b/.kiro/specs/schotziad-km-tracker/design-requirements.md @@ -8,7 +8,9 @@ Ce document rassemble les **exigences techniques** dérivées des exigences fonc Ces exigences sont destinées à être définies et arbitrées **conjointement par le PO business et le PO IT**, dans un second temps, une fois le besoin fonctionnel stabilisé. Elles peuvent évoluer sans remettre en cause le besoin métier tant que le comportement observable décrit dans `requirements.md` est respecté. -Le document est organisé **en miroir** des exigences de `requirements.md` : chaque section reprend le même numéro et le même titre suivi de « — aspects techniques », afin de faciliter les références croisées. Seules les exigences comportant effectivement des critères techniques apparaissent ici. Les exigences purement métier (Requirements 4, 13, 18) ne figurent pas dans ce document. +Le document est organisé **en miroir** des exigences de `requirements.md` : chaque section reprend le même numéro et le même titre suivi de « — aspects techniques », afin de faciliter les références croisées. Seules les exigences comportant effectivement des critères techniques apparaissent ici. Les exigences purement métier (Requirements 4, 18) ne figurent pas dans ce document. + +> **Précision des distances** : les aspects techniques du paramètre Precision_Distance (endpoint, entité, formule d'arrondi) sont résumés au Requirement 22 ci-dessous, avec renvoi vers la spec séparée `precision-distances-km` (`design.md`) pour le détail complet (DTOs, service, migration). --- @@ -23,6 +25,7 @@ Le document est organisé **en miroir** des exigences de `requirements.md` : cha - **JWT** : JSON Web Token signé (HS256) émis par le Backend à la connexion, portant l'identifiant du Compte et une durée de validité configurable (12 heures par défaut). Support technique de la Session définie dans `requirements.md`. - **Cache_Adresses** : La table de base de données stockant les couples (adresse textuelle normalisée BAN, coordonnées géographiques) des adresses déjà saisies, soumise à une politique de rétention LRU. - **Mermaid** : Syntaxe de définition de diagrammes (ex. `graph TB`) rendue graphiquement lors de l'affichage des Documents_Specification. +- **ParametresApplication** : L'entité backend singleton (une seule ligne, `Id = 1`, sur le modèle de `Profil`/`Compte`) portant la colonne `PrecisionDistanceKm`, contrainte par un CHECK SQL `IN (0, 1, 2)`. Détaillée intégralement dans la spec `precision-distances-km`, `design.md`. --- @@ -165,6 +168,16 @@ Le document est organisé **en miroir** des exigences de `requirements.md` : cha --- +### Requirement 13: Barème kilométrique et indication de versement — aspects techniques + +> Exigence fonctionnelle : voir `requirements.md`, Requirement 13. + +#### Acceptance Criteria + +1. WHEN le Backend calcule le Montant_Previsionnel_Mensuel ou le Montant_Previsionnel_Annuel, THE Backend SHALL utiliser des distances déjà arrondies selon Precision_Distance (et non les distances brutes), conformément à la spec `precision-distances-km`, Requirements 6 et 7. + +--- + ### Requirement 14: Montant réglé mensuel et régularisation annuelle — aspects techniques > Exigence fonctionnelle : voir `requirements.md`, Requirement 14. @@ -261,3 +274,17 @@ Le document est organisé **en miroir** des exigences de `requirements.md` : cha 1. THE Frontend SHALL masquer entièrement la barre de navigation (y compris l'Avatar_Utilisateur) sur les pages non authentifiées (connexion, inscription, mot de passe oublié, réinitialisation), MÊME SI un jeton résiduel expiré ou invalide est encore présent localement, la présence locale d'un jeton ne garantissant pas la validité réelle de la Session sur ces pages. 2. THE Frontend SHALL proposer, sur chaque champ de saisie d'un Mot_De_Passe (connexion, inscription, réinitialisation, changement de mot de passe), un contrôle permettant de basculer l'affichage entre masqué et visible, afin que l'utilisateur puisse vérifier la saisie ; ce contrôle SHALL présenter un rendu visuel identique à celui des autres champs de saisie du formulaire. + +--- + +### Requirement 22: Précision configurable des distances — aspects techniques + +> Exigence fonctionnelle : voir `requirements.md`, Requirement 22. Détail complet (DTOs, service, migration) dans la spec `precision-distances-km`, `design.md`. + +#### Acceptance Criteria + +1. THE Backend SHALL exposer les opérations de lecture et de modification de Precision_Distance via un endpoint `GET/PUT /api/parametres-application`, protégé par le même filtre d'autorisation JWT global que les autres endpoints de données, retournant 401 en l'absence de jeton valide. +2. IF le Backend reçoit sur `PUT /api/parametres-application` une valeur de Precision_Distance différente de 0, 1 ou 2, THEN THE Backend SHALL retourner une erreur HTTP 400. +3. WHEN le Backend traite avec succès une requête sur `GET/PUT /api/parametres-application`, THE Backend SHALL retourner un code HTTP 200 accompagné de la configuration courante. +4. THE Backend SHALL persister Precision_Distance dans une entité singleton `ParametresApplication` (une seule ligne, `Id = 1`), avec une contrainte CHECK SQL garantissant `PrecisionDistanceKm IN (0, 1, 2)`. +5. THE Backend SHALL calculer toute distance arrondie selon la formule `Ceiling(distanceBrute × 10^precision) / 10^precision`, appliquée à la lecture, jamais à l'écriture de la colonne `Trajet.Distance`. diff --git a/.kiro/specs/schotziad-km-tracker/design.md b/.kiro/specs/schotziad-km-tracker/design.md index decde16..7961fae 100644 --- a/.kiro/specs/schotziad-km-tracker/design.md +++ b/.kiro/specs/schotziad-km-tracker/design.md @@ -8,6 +8,8 @@ > **Documents d'exigences associés** : le besoin fonctionnel métier est décrit dans `requirements.md` ; les exigences techniques dérivées (API externes, codes HTTP, délais, sécurité, cache, rendu visuel) sont détaillées dans `design-requirements.md`. La présente conception technique met en œuvre ces exigences. +> **Précision des distances** : le paramètre de précision d'affichage des distances (Precision_Distance, 0/1/2 décimales) et son impact sur les calculs de l'application (résumés mensuels/annuels, Panneau_Totaux, barème kilométrique, carte, Export_PDF) sont documentés intégralement dans la spec séparée `precision-distances-km` (`requirements.md` et `design.md`), qui complète et prime, en cas de divergence, sur les points de conception ci-dessous relatifs au calcul des distances et du Montant_Previsionnel. + ### Périmètre fonctionnel | # | Fonctionnalité | Description | @@ -323,8 +325,13 @@ src/ **`PanneauTotauxComponent`** - Affiche trois totaux : total du jour ciblé par la navigation, total du mois sélectionné, Total_Annuel_Partiel (cumul de l'année jusqu'au mois sélectionné inclus) - Reçoit en entrée la date sélectionnée et recalcule les totaux à chaque changement -- Tous les totaux affichés à 2 décimales -- Affiche également le Montant_Previsionnel minoré à 80% calculé sur le Total_Annuel_Partiel du véhicule sélectionné +- Tous les totaux affichés à 2 décimales, calculés par sommation de distances déjà arrondies selon Precision_Distance (voir spec `precision-distances-km`, Requirement 5) +- Affiche également le Montant_Previsionnel_Mensuel (80%, désormais calculé sur le seul mois affiché) et, en dessous, une nouvelle ligne « Montant prévisionnel annuel » présentant le Montant_Previsionnel_Annuel (100%, sur le Total_Annuel_Partiel) — détail complet du calcul dans la spec `precision-distances-km`, Requirements 7 et 8 + +**`ParametresApplicationComponent`** +- Nouveau composant du Sous_Menu_Application de la Page_Parametrage, positionné entre « Compte » et « Véhicules » +- Permet de sélectionner la valeur de Precision_Distance (0, 1 ou 2 décimales) ; la sélection courante est exposée à toute l'application via un signal partagé `precisionDistance` porté par `ParametresApplicationService` +- Détail complet (endpoints, entité, formule d'arrondi, service, migration) dans la spec `precision-distances-km`, `design.md` **`BaremeComponent`** - Sélecteur d'année @@ -335,7 +342,7 @@ src/ **`MontantsReglesComponent`** - Saisie du Montant_Regle par mois pour l'année et le véhicule sélectionnés -- Affichage en regard : Montant_Previsionnel minoré 80% (indicatif) +- Affichage en regard : Montant_Previsionnel_Mensuel minoré 80% (indicatif), désormais calculé sur le seul mois affiché (et non plus sur le cumul annuel) — voir spec `precision-distances-km`, Requirement 7 - Montants en euros à 2 décimales **`CarnetAdressesComponent`** diff --git a/.kiro/specs/schotziad-km-tracker/requirements.md b/.kiro/specs/schotziad-km-tracker/requirements.md index c0f0ef5..1f99415 100644 --- a/.kiro/specs/schotziad-km-tracker/requirements.md +++ b/.kiro/specs/schotziad-km-tracker/requirements.md @@ -63,8 +63,11 @@ L'application permet de gérer un profil (identité, matricule, adresse de domic - **Distance_Effective** : La distance comptée d'un Trajet dans tous les agrégats (liste, totaux, carte, PDF, barème) : égale à la distance simple, ou à son double lorsque le Trajet est un Aller_Retour. - **Document_Specification** : Un document de conception du projet consultable en lecture seule dans l'Application : les Exigences (requirements), la Conception technique (design) et le Plan de tâches (tasks). - **Avatar_Utilisateur** : Le contrôle affiché à l'extrémité droite de la barre de navigation, représentant l'utilisateur par ses initiales (1ère lettre du Prénom + 1ère lettre du Nom). Un survol ou un clic ouvre un sous-menu proposant l'identité affichée, « Paramétrage », « Maintenance » et « Se déconnecter ». -- **Page_Parametrage** : La page accessible depuis l'Avatar_Utilisateur, présentant un menu latéral (Compte, Véhicules, Barème) et affichant à sa droite la donnée paramétrable sélectionnée. +- **Page_Parametrage** : La page accessible depuis l'Avatar_Utilisateur, présentant un menu latéral (Compte, Application, Véhicules, Barème) et affichant à sa droite la donnée paramétrable sélectionnée. - **Page_Maintenance** : La page accessible depuis l'Avatar_Utilisateur regroupant les actions techniques de maintenance de l'Application (ex. recalcul des distances routières). +- **Precision_Distance** : Le paramètre global de l'Application, réglable dans le Sous_Menu_Application de la Page_Parametrage, déterminant le nombre de décimales (0, 1 ou 2) utilisé pour l'arrondi supérieur des distances à l'affichage et dans les agrégats (trajets, totaux, barème, carte, Export_PDF). Défini et détaillé intégralement dans la spec `precision-distances-km` (Glossary, Requirement 1). +- **Sous_Menu_Application** : L'entrée « Application » du menu latéral de la Page_Parametrage, positionnée entre « Compte » et « Véhicules », permettant de configurer Precision_Distance. Détaillée intégralement dans la spec `precision-distances-km` (Glossary, Requirement 2). +- **Montant_Previsionnel_Mensuel** et **Montant_Previsionnel_Annuel** : Les deux indications de versement affichées lors de la consultation d'un mois, redéfinies par la spec `precision-distances-km` (Glossary, Requirements 7 et 8) ; elles remplacent l'ancien Montant_Previsionnel unique décrit au Requirement 13 ci-dessous. --- @@ -336,14 +339,17 @@ L'application permet de gérer un profil (identité, matricule, adresse de domic **User Story:** En tant qu'utilisateur, je veux saisir le barème kilométrique officiel par année et par puissance fiscale, et voir une indication de versement mensuel, afin d'estimer mes remboursements en cours d'année. +> Le calcul du Montant_Previsionnel_Mensuel (critère 5) et du Montant_Previsionnel_Annuel (critère 5bis) est précisé intégralement par la spec `precision-distances-km`, Requirements 7 et 8, qui prime en cas de divergence. + #### Acceptance Criteria 1. THE Frontend SHALL afficher un menu de saisie du Bareme_Kilometrique par année permettant de saisir, pour chaque Puissance_Fiscale, une ou plusieurs Tranches_Bareme définies par une borne minimale de kilométrage, une borne maximale de kilométrage (la dernière tranche pouvant être illimitée, sans borne maximale), un coefficient (€/km sur trois décimales) et une base (€). L'utilisateur peut ajouter plusieurs tranches pour une même Puissance_Fiscale (ex. 0–4 999 km, 5 000–19 999 km, 20 000 km et plus). 2. WHEN l'utilisateur enregistre une Tranche_Bareme, THE Backend SHALL persister la tranche associée à l'année, à la Puissance_Fiscale et à la borne de kilométrage concernées. 3. WHEN le Backend applique le Bareme_Kilometrique au total kilométrique annuel d'un Véhicule pour une année donnée, THE Backend SHALL sélectionner la tranche dont l'intervalle de kilométrage contient le total annuel, puis calculer le montant selon la formule `montant = total_km_annuel × coefficient + base`. 4. IF aucune Tranche_Bareme n'existe pour la Puissance_Fiscale et l'année d'un calcul, THEN THE Backend SHALL retourner le montant zéro et signaler que le barème n'est pas configuré pour cette combinaison. -5. WHEN l'utilisateur consulte les données d'un mois, THE Frontend SHALL afficher à titre indicatif le Montant_Previsionnel, calculé comme 80% du Bareme_Kilometrique appliqué au Total_Annuel_Partiel du Véhicule sélectionné. -6. THE Frontend SHALL indiquer explicitement que le Montant_Previsionnel (80%) est une simple indication de versement et que le montant réellement versé est celui saisi par l'utilisateur (Montant_Regle). +5. WHEN l'utilisateur consulte les données d'un mois, THE Frontend SHALL afficher à titre indicatif le Montant_Previsionnel_Mensuel, calculé comme 80% du Bareme_Kilometrique appliqué à la Distance_Effective_Arrondie totale du seul mois affiché (et non plus du Total_Annuel_Partiel), la tranche applicable restant déterminée par le Total_Annuel_Partiel. +5bis. WHEN l'utilisateur consulte les données d'un mois, THE Frontend SHALL afficher, sous le Montant_Previsionnel_Mensuel, une ligne « Montant prévisionnel annuel » présentant le Montant_Previsionnel_Annuel, calculé comme 100% (sans minoration) du Bareme_Kilometrique appliqué au Total_Annuel_Partiel du Véhicule sélectionné. +6. THE Frontend SHALL indiquer explicitement que le Montant_Previsionnel_Mensuel (80%) est une simple indication de versement, que le Montant_Previsionnel_Annuel (100%) est une projection indicative sans minoration, et que le montant réellement versé est celui saisi par l'utilisateur (Montant_Regle). 7. THE Frontend SHALL afficher tous les montants en euros avec une précision de deux décimales. 8. THE Frontend SHALL afficher, dans l'en-tête de chaque feuille mensuelle, le Coefficient_Base_Vehicule (coefficient et base de la tranche applicable selon la puissance fiscale du Véhicule et le total kilométrique annuel). 9. THE Frontend SHALL proposer un bouton « Recopier le dernier barème connu » qui, pour l'année affichée, recopie l'intégralité des Tranches_Bareme de l'année la plus récente antérieure comportant un barème. IF des Tranches_Bareme existent déjà pour l'année affichée, THEN THE Frontend SHALL demander une confirmation avant de les remplacer intégralement (annule et remplace). THE Frontend SHALL rendre ce bouton inaccessible lorsque l'année affichée est celle du dernier barème connu (aucune année antérieure à recopier). @@ -362,8 +368,8 @@ L'application permet de gérer un profil (identité, matricule, adresse de domic 2. WHEN l'utilisateur enregistre un Montant_Regle, THE Backend SHALL persister ce montant associé au mois, à l'année et au Véhicule concernés. 3. IF un Montant_Regle existe déjà pour le même mois, la même année et le même Véhicule, THEN THE Backend SHALL mettre à jour le montant existant plutôt que d'en créer un nouveau. 4. IF l'utilisateur saisit un Montant_Regle négatif, THEN THE Backend SHALL rejeter la saisie. -5. WHEN le Backend calcule le Montant_Reel annuel d'un Véhicule, THE Backend SHALL appliquer le Bareme_Kilometrique plein (100%) au total kilométrique annuel du Véhicule, en utilisant la tranche déterminée par ce total annuel. -6. WHEN le Backend calcule le Frais_Reel_Mensuel de chaque mois, THE Backend SHALL multiplier les kilomètres du mois par le coefficient de la tranche annuelle applicable, de sorte que la somme des douze Frais_Reel_Mensuel plus la base de la tranche annuelle soit égale au Montant_Reel annuel. +5. WHEN le Backend calcule le Montant_Reel annuel d'un Véhicule, THE Backend SHALL appliquer le Bareme_Kilometrique plein (100%) au total kilométrique annuel du Véhicule, en utilisant la tranche déterminée par ce total annuel ; ce total kilométrique annuel est constitué de distances déjà arrondies selon Precision_Distance, conformément à la spec `precision-distances-km`, Requirement 6. +6. WHEN le Backend calcule le Frais_Reel_Mensuel de chaque mois, THE Backend SHALL multiplier les kilomètres du mois par le coefficient de la tranche annuelle applicable, de sorte que la somme des douze Frais_Reel_Mensuel plus la base de la tranche annuelle soit égale au Montant_Reel annuel ; les kilomètres du mois sont également des distances déjà arrondies selon Precision_Distance (spec `precision-distances-km`, Requirement 6). 7. WHEN le Backend calcule la Regularisation d'un Véhicule pour une année, THE Backend SHALL soustraire le total des Montant_Regle de l'année du Montant_Reel annuel : `Regularisation = Montant_Reel − Total_Regle`. 8. THE Frontend SHALL afficher le Montant_Regle, le Frais_Reel_Mensuel, le Montant_Reel annuel, le total réglé et la Regularisation avec une précision de deux décimales. @@ -500,3 +506,20 @@ L'application permet de gérer un profil (identité, matricule, adresse de domic 4. WHEN l'utilisateur sélectionne « Paramétrage », THE Frontend SHALL naviguer vers la Page_Parametrage, affichant par défaut la donnée « Compte » ; WHEN l'utilisateur sélectionne « Maintenance », THE Frontend SHALL naviguer vers la Page_Maintenance ; WHEN l'utilisateur sélectionne « Se déconnecter », THE Frontend SHALL déconnecter l'utilisateur et naviguer vers la page de connexion. 5. THE Page_Parametrage SHALL présenter un menu latéral avec les entrées « Compte » (identité, matricule, adresse de domicile), « Véhicules » (historique des véhicules) et « Barème » (barème kilométrique), chacune affichant à droite le contenu correspondant sans rechargement complet de la page. 6. THE Backend SHALL continuer à exiger la configuration du Profil (Exigence 16) pour l'accès à la donnée « Barème » de la Page_Parametrage, mais PAS pour l'accès aux données « Compte » et « Véhicules », afin de ne pas bloquer un utilisateur dont le Profil n'est pas encore configuré. + +--- + +### Requirement 22: Précision configurable des distances et arrondi supérieur + +**User Story:** En tant qu'utilisateur, je veux choisir le nombre de décimales utilisé pour l'affichage des distances en kilomètres et bénéficier d'un arrondi systématiquement supérieur, afin d'adapter la précision affichée à mes besoins tout en ayant la certitude que les distances affichées ne sont jamais sous-évaluées. + +> Cette exigence est détaillée intégralement par la spec `precision-distances-km` (Requirements 1, 3, 4, 5), qui prime en cas de divergence. Les exigences techniques associées (endpoint, entité, formule d'arrondi) sont décrites dans `design-requirements.md`, Requirement 22. + +#### Acceptance Criteria + +1. THE Backend SHALL persister une valeur unique de Precision_Distance pour l'ensemble de l'Application, parmi exactement trois valeurs possibles : 0, 1 ou 2, avec une valeur par défaut de 2 en l'absence de valeur déjà enregistrée. +2. THE Page_Parametrage SHALL présenter, dans son menu latéral, le Sous_Menu_Application positionné entre « Compte » et « Véhicules », permettant de sélectionner la valeur de Precision_Distance parmi 0, 1 et 2. +3. WHEN le Frontend affiche la distance d'un Trajet qui n'est pas un Aller_Retour, THE Frontend SHALL afficher cette distance arrondie au supérieur à la précision définie par Precision_Distance. +4. WHEN le Frontend affiche la distance d'un Trajet dont Aller_Retour est vrai, THE Frontend SHALL afficher le double de la distance simple déjà arrondie au supérieur, l'arrondi étant toujours appliqué avant le doublement et jamais après. +5. WHEN le Backend ou le Frontend calcule un total kilométrique (jour, mois, Total_Annuel_Partiel), THE Backend ou THE Frontend SHALL additionner des distances déjà arrondies selon Precision_Distance, sans appliquer d'arrondi supplémentaire après la somme. +6. THE Backend SHALL ne jamais modifier la valeur brute stockée de la Distance d'un Trajet suite à un changement de Precision_Distance ; seuls l'affichage et les agrégats calculés à la volée sont affectés. diff --git a/backend/SchotzIadKmTracker.Api/Controllers/ParametresApplicationController.cs b/backend/SchotzIadKmTracker.Api/Controllers/ParametresApplicationController.cs new file mode 100644 index 0000000..301f17d --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Controllers/ParametresApplicationController.cs @@ -0,0 +1,54 @@ +using Microsoft.AspNetCore.Mvc; +using SchotzIadKmTracker.Api.Models.DTOs; +using SchotzIadKmTracker.Api.Services; +using SchotzIadKmTracker.Api.Services.Exceptions; + +namespace SchotzIadKmTracker.Api.Controllers; + +/// +/// Endpoint de gestion de la configuration globale de l'application : lecture et modification +/// de la précision d'arrondi des distances (Precision_Distance, 0/1/2 décimales). +/// +[ApiController] +[Route("api/parametres-application")] +public class ParametresApplicationController : ControllerBase +{ + private readonly IPrecisionDistanceService _precisionDistanceService; + + public ParametresApplicationController(IPrecisionDistanceService precisionDistanceService) + { + _precisionDistanceService = precisionDistanceService; + } + + /// + /// Retourne la configuration courante (crée la ligne singleton avec la valeur par défaut + /// (2) si elle est absente). + /// + [HttpGet] + [ProducesResponseType(typeof(ParametresApplicationDto), StatusCodes.Status200OK)] + public async Task> Get(CancellationToken cancellationToken) + { + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + return Ok(new ParametresApplicationDto(precision)); + } + + /// + /// Modifie la précision des distances. Rejette (400) si la valeur n'est pas 0, 1 ou 2. + /// + [HttpPut] + [ProducesResponseType(typeof(ParametresApplicationDto), StatusCodes.Status200OK)] + [ProducesResponseType(StatusCodes.Status400BadRequest)] + public async Task> Put( + [FromBody] SavePrecisionDistanceDto dto, CancellationToken cancellationToken) + { + try + { + var precision = await _precisionDistanceService.DefinirAsync(dto.PrecisionDistanceKm, cancellationToken); + return Ok(new ParametresApplicationDto(precision)); + } + catch (PrecisionDistanceInvalideException ex) + { + return Problem(detail: ex.Message, statusCode: StatusCodes.Status400BadRequest); + } + } +} diff --git a/backend/SchotzIadKmTracker.Api/Controllers/TrajetsController.cs b/backend/SchotzIadKmTracker.Api/Controllers/TrajetsController.cs index 00bbf4e..1718738 100644 --- a/backend/SchotzIadKmTracker.Api/Controllers/TrajetsController.cs +++ b/backend/SchotzIadKmTracker.Api/Controllers/TrajetsController.cs @@ -25,15 +25,18 @@ public class TrajetsController : ControllerBase private readonly ITrajetService _trajetService; private readonly ITrajetRepository _trajetRepository; private readonly IAdresseCacheService _adresseCacheService; + private readonly IPrecisionDistanceService _precisionDistanceService; public TrajetsController( ITrajetService trajetService, ITrajetRepository trajetRepository, - IAdresseCacheService adresseCacheService) + IAdresseCacheService adresseCacheService, + IPrecisionDistanceService precisionDistanceService) { _trajetService = trajetService; _trajetRepository = trajetRepository; _adresseCacheService = adresseCacheService; + _precisionDistanceService = precisionDistanceService; } /// @@ -211,6 +214,10 @@ public class TrajetsController : ControllerBase var trajets = await _trajetRepository.GetByDateAsync(jour, cancellationToken); + // Précision courante (0/1/2 décimales) : lue une fois par appel, cohérente avec + // ResumeService/TotauxService (Exigences 9.1, 9.4). + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + var resultats = new List(trajets.Count); foreach (var trajet in trajets) { @@ -224,13 +231,20 @@ public class TrajetsController : ControllerBase // hérités dont la géométrie n'a pas encore été recalculée (rétrocompatibilité). var geometrie = trajet.GeometrieJson ?? depart?.GeometrieJson ?? arrivee?.GeometrieJson; + // Distance EFFECTIVE ARRONDIE : distance simple arrondie à la précision courante, + // PUIS doublée si aller/retour (Exigence 4.2 — arrondi avant doublement), cohérente + // avec ResumeService/TotauxService (Exigences 9.1, 9.4). null → 0 (comportement + // inchangé). + var distanceEffectiveArrondie = + _precisionDistanceService.ArrondirDistance(trajet.Distance ?? 0m, precision) + * (trajet.AllerRetour ? 2m : 1m); + resultats.Add(new TrajetCarteDto( trajet.Id, trajet.Date, trajet.AdresseDepart, trajet.AdresseArrivee, - // Distance EFFECTIVE (doublée si aller/retour), cohérente avec la liste. - trajet.DistanceEffective ?? 0m, + distanceEffectiveArrondie, depart?.Latitude, depart?.Longitude, arrivee?.Latitude, diff --git a/backend/SchotzIadKmTracker.Api/Data/AppDbContext.cs b/backend/SchotzIadKmTracker.Api/Data/AppDbContext.cs index 72c5b45..c8ab263 100644 --- a/backend/SchotzIadKmTracker.Api/Data/AppDbContext.cs +++ b/backend/SchotzIadKmTracker.Api/Data/AppDbContext.cs @@ -16,6 +16,7 @@ public class AppDbContext : DbContext public DbSet Trajets => Set(); public DbSet Vehicules => Set(); public DbSet Profil => Set(); + public DbSet ParametresApplication => Set(); public DbSet AdresseCache => Set(); public DbSet AdressesNommees => Set(); public DbSet TranchesBareme => Set(); @@ -65,6 +66,16 @@ public class AppDbContext : DbContext entity.HasIndex(p => p.Id, "UX_Profil_Singleton").IsUnique(); }); + // --- ParametresApplication (singleton Id = 1) --- + modelBuilder.Entity(entity => + { + entity.ToTable("ParametresApplication", t => + t.HasCheckConstraint("CK_ParametresApplication_PrecisionDistanceKm", "\"PrecisionDistanceKm\" IN (0, 1, 2)")); + entity.HasKey(p => p.Id); + entity.Property(p => p.Id).ValueGeneratedNever(); + entity.HasIndex(p => p.Id, "UX_ParametresApplication_Singleton").IsUnique(); + }); + // --- AdresseCache (Adresse unique) --- modelBuilder.Entity(entity => { diff --git a/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.Designer.cs b/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.Designer.cs new file mode 100644 index 0000000..c920a90 --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.Designer.cs @@ -0,0 +1,415 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using SchotzIadKmTracker.Api.Data; + +#nullable disable + +namespace SchotzIadKmTracker.Api.Data.Migrations +{ + [DbContext(typeof(AppDbContext))] + [Migration("20260925082429_AjoutParametresApplication")] + partial class AjoutParametresApplication + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder.HasAnnotation("ProductVersion", "8.0.8"); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.AdresseCache", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("Adresse") + .IsRequired() + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("DerniereUtilisation") + .HasColumnType("TEXT"); + + b.Property("GeometrieJson") + .HasColumnType("TEXT"); + + b.Property("Latitude") + .HasColumnType("REAL"); + + b.Property("Longitude") + .HasColumnType("REAL"); + + b.HasKey("Id"); + + b.HasIndex("Adresse") + .IsUnique(); + + b.ToTable("AdresseCache", (string)null); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.AdresseNommee", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("Adresse") + .IsRequired() + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("Denomination") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("TEXT"); + + b.Property("DenominationNormalisee") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("TEXT"); + + b.Property("GeocodageReussi") + .HasColumnType("INTEGER"); + + b.Property("Latitude") + .HasColumnType("REAL"); + + b.Property("Longitude") + .HasColumnType("REAL"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "DenominationNormalisee" }, "UX_AdresseNommee_Denomination") + .IsUnique(); + + b.ToTable("AdressesNommees", (string)null); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Compte", b => + { + b.Property("Id") + .HasColumnType("INTEGER"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("Email") + .IsRequired() + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("MotDePasseHash") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Email" }, "UX_Comptes_Email") + .IsUnique(); + + b.ToTable("Comptes", (string)null); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.MontantRegle", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("Annee") + .HasColumnType("INTEGER"); + + b.Property("Mois") + .HasColumnType("INTEGER"); + + b.Property("Montant") + .HasColumnType("TEXT"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.Property("VehiculeId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("VehiculeId"); + + b.HasIndex(new[] { "Annee", "Mois", "VehiculeId" }, "UX_MontantsRegles_Periode_Vehicule") + .IsUnique(); + + b.ToTable("MontantsRegles", null, t => + { + t.HasCheckConstraint("CK_MontantsRegles_Mois", "\"Mois\" BETWEEN 1 AND 12"); + + t.HasCheckConstraint("CK_MontantsRegles_Montant", "\"Montant\" >= 0"); + }); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.ParametresApplication", b => + { + b.Property("Id") + .HasColumnType("INTEGER"); + + b.Property("PrecisionDistanceKm") + .HasColumnType("INTEGER"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Id" }, "UX_ParametresApplication_Singleton") + .IsUnique(); + + b.ToTable("ParametresApplication", null, t => + { + t.HasCheckConstraint("CK_ParametresApplication_PrecisionDistanceKm", "\"PrecisionDistanceKm\" IN (0, 1, 2)"); + }); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Profil", b => + { + b.Property("Id") + .HasColumnType("INTEGER"); + + b.Property("AdresseDomicile") + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("DomicileGeocode") + .HasColumnType("INTEGER"); + + b.Property("DomicileLatitude") + .HasColumnType("REAL"); + + b.Property("DomicileLongitude") + .HasColumnType("REAL"); + + b.Property("Matricule") + .HasMaxLength(8) + .HasColumnType("TEXT"); + + b.Property("Nom") + .HasMaxLength(100) + .HasColumnType("TEXT"); + + b.Property("Prenom") + .HasMaxLength(100) + .HasColumnType("TEXT"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Id" }, "UX_Profil_Singleton") + .IsUnique(); + + b.ToTable("Profil", (string)null); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.ResetPasswordToken", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("Expiration") + .HasColumnType("TEXT"); + + b.Property("TokenHash") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("UsedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Expiration" }, "IX_ResetTokens_Expiration"); + + b.HasIndex(new[] { "TokenHash" }, "UX_ResetTokens_TokenHash") + .IsUnique(); + + b.ToTable("ResetPasswordTokens", (string)null); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Trajet", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("AdresseArrivee") + .IsRequired() + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("AdresseDepart") + .IsRequired() + .HasMaxLength(255) + .HasColumnType("TEXT"); + + b.Property("AllerRetour") + .HasColumnType("INTEGER"); + + b.Property("Commentaire") + .HasMaxLength(500) + .HasColumnType("TEXT"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("Date") + .HasColumnType("TEXT"); + + b.Property("Distance") + .HasColumnType("TEXT"); + + b.Property("GeometrieJson") + .HasColumnType("TEXT"); + + b.Property("Position") + .HasColumnType("TEXT"); + + b.Property("PuissanceFiscale") + .HasColumnType("INTEGER"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.Property("VehiculeId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Date" }, "IX_Trajets_Date"); + + b.HasIndex(new[] { "Date", "Position" }, "IX_Trajets_Date_Position"); + + b.HasIndex(new[] { "VehiculeId" }, "IX_Trajets_Vehicule"); + + b.ToTable("Trajets", null, t => + { + t.HasCheckConstraint("CK_Trajets_Distance", "\"Distance\" IS NULL OR \"Distance\" > 0"); + + t.HasCheckConstraint("CK_Trajets_PuissanceFiscale", "\"PuissanceFiscale\" > 0"); + }); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.TrancheBareme", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("Annee") + .HasColumnType("INTEGER"); + + b.Property("Base") + .HasColumnType("TEXT"); + + b.Property("Coefficient") + .HasColumnType("TEXT"); + + b.Property("KmMax") + .HasColumnType("TEXT"); + + b.Property("KmMin") + .HasColumnType("TEXT"); + + b.Property("PuissanceFiscale") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Annee", "PuissanceFiscale" }, "IX_TranchesBareme_Annee_PF"); + + b.ToTable("TranchesBareme", null, t => + { + t.HasCheckConstraint("CK_TranchesBareme_Km", "\"KmMax\" IS NULL OR CAST(\"KmMin\" AS REAL) < CAST(\"KmMax\" AS REAL)"); + }); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Vehicule", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("DateEffet") + .HasColumnType("TEXT"); + + b.Property("Denomination") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("TEXT"); + + b.Property("Plaque") + .IsRequired() + .HasMaxLength(15) + .HasColumnType("TEXT"); + + b.Property("PuissanceFiscale") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "DateEffet" }, "IX_Vehicules_DateEffet"); + + b.ToTable("Vehicules", null, t => + { + t.HasCheckConstraint("CK_Vehicules_PuissanceFiscale", "\"PuissanceFiscale\" > 0"); + }); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.MontantRegle", b => + { + b.HasOne("SchotzIadKmTracker.Api.Models.Entities.Vehicule", "Vehicule") + .WithMany() + .HasForeignKey("VehiculeId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Vehicule"); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Trajet", b => + { + b.HasOne("SchotzIadKmTracker.Api.Models.Entities.Vehicule", "Vehicule") + .WithMany("Trajets") + .HasForeignKey("VehiculeId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Vehicule"); + }); + + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Vehicule", b => + { + b.Navigation("Trajets"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.cs b/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.cs new file mode 100644 index 0000000..9362131 --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Data/Migrations/20260925082429_AjoutParametresApplication.cs @@ -0,0 +1,42 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace SchotzIadKmTracker.Api.Data.Migrations +{ + /// + public partial class AjoutParametresApplication : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "ParametresApplication", + columns: table => new + { + Id = table.Column(type: "INTEGER", nullable: false), + PrecisionDistanceKm = table.Column(type: "INTEGER", nullable: false), + UpdatedAt = table.Column(type: "TEXT", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_ParametresApplication", x => x.Id); + table.CheckConstraint("CK_ParametresApplication_PrecisionDistanceKm", "\"PrecisionDistanceKm\" IN (0, 1, 2)"); + }); + + migrationBuilder.CreateIndex( + name: "UX_ParametresApplication_Singleton", + table: "ParametresApplication", + column: "Id", + unique: true); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "ParametresApplication"); + } + } +} diff --git a/backend/SchotzIadKmTracker.Api/Data/Migrations/AppDbContextModelSnapshot.cs b/backend/SchotzIadKmTracker.Api/Data/Migrations/AppDbContextModelSnapshot.cs index 5c54c5b..05e346d 100644 --- a/backend/SchotzIadKmTracker.Api/Data/Migrations/AppDbContextModelSnapshot.cs +++ b/backend/SchotzIadKmTracker.Api/Data/Migrations/AppDbContextModelSnapshot.cs @@ -156,6 +156,28 @@ namespace SchotzIadKmTracker.Api.Data.Migrations }); }); + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.ParametresApplication", b => + { + b.Property("Id") + .HasColumnType("INTEGER"); + + b.Property("PrecisionDistanceKm") + .HasColumnType("INTEGER"); + + b.Property("UpdatedAt") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.HasIndex(new[] { "Id" }, "UX_ParametresApplication_Singleton") + .IsUnique(); + + b.ToTable("ParametresApplication", null, t => + { + t.HasCheckConstraint("CK_ParametresApplication_PrecisionDistanceKm", "\"PrecisionDistanceKm\" IN (0, 1, 2)"); + }); + }); + modelBuilder.Entity("SchotzIadKmTracker.Api.Models.Entities.Profil", b => { b.Property("Id") diff --git a/backend/SchotzIadKmTracker.Api/Models/DTOs/BaremeDtos.cs b/backend/SchotzIadKmTracker.Api/Models/DTOs/BaremeDtos.cs index 7d54b4f..1cbfa28 100644 --- a/backend/SchotzIadKmTracker.Api/Models/DTOs/BaremeDtos.cs +++ b/backend/SchotzIadKmTracker.Api/Models/DTOs/BaremeDtos.cs @@ -33,9 +33,10 @@ public record MontantPrevisionnelDto( int Annee, int Mois, int VehiculeId, - decimal TotalAnnuelPartielKm, - decimal MontantBaremePlein, // barème plein sur le total partiel - decimal MontantPrevisionnel // = 80% (indicatif uniquement) + decimal TotalMoisKm, // Distance_Effective_Arrondie totale du mois affiché + decimal TotalAnnuelPartielKm, // Total_Annuel_Partiel arrondi (cumul jusqu'au mois inclus) + decimal MontantPrevisionnelMensuel, // 80% du barème appliqué à TotalMoisKm (tranche déterminée par le cumul annuel) + decimal MontantPrevisionnelAnnuel // 100% du barème appliqué à TotalAnnuelPartielKm ); // Ligne mensuelle de la synthèse annuelle (aligne sur la synthèse réelle) diff --git a/backend/SchotzIadKmTracker.Api/Models/DTOs/ParametresApplicationDtos.cs b/backend/SchotzIadKmTracker.Api/Models/DTOs/ParametresApplicationDtos.cs new file mode 100644 index 0000000..d041e0e --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Models/DTOs/ParametresApplicationDtos.cs @@ -0,0 +1,7 @@ +namespace SchotzIadKmTracker.Api.Models.DTOs; + +/// Configuration globale exposée en lecture. +public record ParametresApplicationDto(int PrecisionDistanceKm); + +/// Corps de requête pour modifier la précision des distances. +public record SavePrecisionDistanceDto(int PrecisionDistanceKm); diff --git a/backend/SchotzIadKmTracker.Api/Models/Entities/ParametresApplication.cs b/backend/SchotzIadKmTracker.Api/Models/Entities/ParametresApplication.cs new file mode 100644 index 0000000..15215fe --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Models/Entities/ParametresApplication.cs @@ -0,0 +1,21 @@ +namespace SchotzIadKmTracker.Api.Models.Entities; + +/// +/// Configuration globale de l'application (singleton — une seule ligne, Id = 1). +/// Sur le même modèle que et . +/// +public class ParametresApplication +{ + /// Identifiant fixe (1) : la configuration est un singleton. + public int Id { get; set; } = 1; + + /// + /// Nombre de décimales (0, 1 ou 2) utilisé pour l'arrondi supérieur des distances à + /// l'affichage et dans les agrégats. Défaut 2 (Exigence 1.2). Valeur validée par + /// avant écriture — jamais persistée + /// hors de {0, 1, 2}. + /// + public int PrecisionDistanceKm { get; set; } = 2; + + public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; +} diff --git a/backend/SchotzIadKmTracker.Api/Program.cs b/backend/SchotzIadKmTracker.Api/Program.cs index 686ba02..ace870c 100644 --- a/backend/SchotzIadKmTracker.Api/Program.cs +++ b/backend/SchotzIadKmTracker.Api/Program.cs @@ -177,6 +177,7 @@ builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); +builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); diff --git a/backend/SchotzIadKmTracker.Api/Services/Exceptions/PrecisionDistanceInvalideException.cs b/backend/SchotzIadKmTracker.Api/Services/Exceptions/PrecisionDistanceInvalideException.cs new file mode 100644 index 0000000..bfe127f --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Services/Exceptions/PrecisionDistanceInvalideException.cs @@ -0,0 +1,18 @@ +namespace SchotzIadKmTracker.Api.Services.Exceptions; + +/// +/// Levée lorsqu'une valeur de Precision_Distance soumise n'est pas 0, 1 ou 2. +/// Convertie en réponse HTTP 400 (Bad Request) — Exigence 1.6. +/// +public class PrecisionDistanceInvalideException : Exception +{ + public PrecisionDistanceInvalideException(string message) + : base(message) + { + } + + public PrecisionDistanceInvalideException(string message, Exception innerException) + : base(message, innerException) + { + } +} diff --git a/backend/SchotzIadKmTracker.Api/Services/IMontantRegleService.cs b/backend/SchotzIadKmTracker.Api/Services/IMontantRegleService.cs index 3523847..78dc4ec 100644 --- a/backend/SchotzIadKmTracker.Api/Services/IMontantRegleService.cs +++ b/backend/SchotzIadKmTracker.Api/Services/IMontantRegleService.cs @@ -26,10 +26,13 @@ public interface IMontantRegleService /// /// Calcule le Montant_Previsionnel indicatif pour un (année, mois, véhicule) : - /// 80% du Bareme_Kilometrique plein appliqué au Total_Annuel_Partiel du véhicule - /// (somme des distances de l'année pour ce véhicule jusqu'au mois indiqué inclus), - /// arrondi à deux décimales (Property 23, Exigences 13.5/13.6). - /// Cette valeur est purement informative et n'entre jamais dans la régularisation. + /// la tranche de barème est déterminée par le Total_Annuel_Partiel du véhicule (somme des + /// distances arrondies de l'année pour ce véhicule jusqu'au mois indiqué inclus — Exigence 7.2), + /// puis son coefficient/base est appliqué au seul kilométrage arrondi du mois affiché pour + /// obtenir le Montant_Previsionnel_Mensuel (80%, Exigences 6.1/6.2/7.1/7.4), et au cumul annuel + /// pour obtenir le Montant_Previsionnel_Annuel (100%, Exigences 8.1/8.2/8.5), tous deux arrondis + /// à deux décimales. + /// Ces valeurs sont purement informatives et n'entrent jamais dans la régularisation. /// Task GetMontantPrevisionnelAsync( int annee, int mois, int vehiculeId, CancellationToken cancellationToken = default); diff --git a/backend/SchotzIadKmTracker.Api/Services/IPrecisionDistanceService.cs b/backend/SchotzIadKmTracker.Api/Services/IPrecisionDistanceService.cs new file mode 100644 index 0000000..72c0967 --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Services/IPrecisionDistanceService.cs @@ -0,0 +1,29 @@ +namespace SchotzIadKmTracker.Api.Services; + +/// +/// Lecture/écriture de la configuration globale Precision_Distance, et fonction utilitaire +/// pure d'arrondi supérieur (ceiling) réutilisée par tous les points de calcul de distance. +/// +public interface IPrecisionDistanceService +{ + /// + /// Retourne la précision courante (0, 1 ou 2). Crée la ligne singleton avec la valeur + /// par défaut (2) si elle est absente (Exigence 1.2), sur le même modèle que + /// . + /// + Task ObtenirAsync(CancellationToken cancellationToken = default); + + /// + /// Définit la précision. Lève + /// si la valeur n'est pas 0, 1 ou 2 (Exigence 1.6). + /// + Task DefinirAsync(int valeur, CancellationToken cancellationToken = default); + + /// + /// Arrondit une distance brute (km) au supérieur (ceiling) à la précision indiquée. + /// Fonction pure, sans effet de bord, sans accès base — utilisable partout où une + /// distance doit être affichée ou agrégée (Exigences 3.2–3.5, 4.2). + /// Formule : Ceiling(distanceBrute × 10^precision) / 10^precision. + /// + decimal ArrondirDistance(decimal distanceBrute, int precision); +} diff --git a/backend/SchotzIadKmTracker.Api/Services/MontantRegleService.cs b/backend/SchotzIadKmTracker.Api/Services/MontantRegleService.cs index 9fef75f..c94caa1 100644 --- a/backend/SchotzIadKmTracker.Api/Services/MontantRegleService.cs +++ b/backend/SchotzIadKmTracker.Api/Services/MontantRegleService.cs @@ -13,11 +13,14 @@ public class MontantRegleService : IMontantRegleService private readonly AppDbContext _context; private readonly IBaremeService _baremeService; + private readonly IPrecisionDistanceService _precisionDistanceService; - public MontantRegleService(AppDbContext context, IBaremeService baremeService) + public MontantRegleService( + AppDbContext context, IBaremeService baremeService, IPrecisionDistanceService precisionDistanceService) { _context = context; _baremeService = baremeService; + _precisionDistanceService = precisionDistanceService; } /// @@ -85,37 +88,58 @@ public class MontantRegleService : IMontantRegleService .FirstOrDefaultAsync(v => v.Id == vehiculeId, cancellationToken) ?? throw new VehiculeNotFoundException($"Le véhicule d'identifiant {vehiculeId} est introuvable."); - // Total_Annuel_Partiel : somme des distances de l'année pour ce véhicule, - // jusqu'au mois sélectionné inclus (les mois postérieurs sont exclus). - // SQLite ne sait pas appliquer SUM sur une colonne decimal : on ramène les distances - // concernées et on somme côté client (null traité comme 0). - var distancesPartielles = await _context.Trajets + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + + // Trajets de l'année pour ce véhicule, jusqu'au mois sélectionné inclus (les mois + // postérieurs sont exclus). SQLite ne sait pas appliquer SUM sur une colonne decimal : + // on ramène les trajets concernés et on somme côté client (distance null traitée comme 0). + // Le mois de chaque trajet est conservé pour distinguer le mois affiché du cumul annuel. + var trajets = await _context.Trajets .AsNoTracking() .Where(t => t.VehiculeId == vehiculeId && t.Date.Year == annee && t.Date.Month <= mois) - // On ramène la distance simple et l'indicateur aller/retour, puis on somme la - // distance EFFECTIVE (doublée si A/R) côté client (null → 0). - .Select(t => new { t.Distance, t.AllerRetour }) + .Select(t => new { t.Date.Month, t.Distance, t.AllerRetour }) .ToListAsync(cancellationToken); - var totalAnnuelPartiel = distancesPartielles.Sum(x => x.Distance.GetValueOrDefault() * (x.AllerRetour ? 2m : 1m)); - // Barème plein appliqué au total partiel (sans minoration). - var bareme = await _baremeService.CalculerMontantAsync( + // Distance_Effective_Arrondie : arrondi de la distance simple à la précision courante, + // PUIS doublement si aller/retour (arrondi avant doublement — Exigence 4.2). + decimal DistanceArrondie(decimal? distance, bool allerRetour) => + _precisionDistanceService.ArrondirDistance(distance ?? 0m, precision) * (allerRetour ? 2m : 1m); + + // Total_Mois_Km : somme des distances déjà arrondies des trajets du mois affiché (Exigence 7.1). + var totalMoisAffiche = trajets + .Where(t => t.Month == mois) + .Sum(t => DistanceArrondie(t.Distance, t.AllerRetour)); + + // Total_Annuel_Partiel : somme des distances déjà arrondies de tous les trajets chargés + // (cumul jusqu'au mois inclus — Exigence 6.2). + var totalAnnuelPartiel = trajets.Sum(t => DistanceArrondie(t.Distance, t.AllerRetour)); + + // La tranche de barème est déterminée par le cumul annuel (Exigence 7.2), et son + // coefficient/base est réutilisé tel quel pour le mois affiché (pas de nouvel appel à + // CalculerMontantAsync avec le total du mois seul : cela re-sélectionnerait une tranche + // différente selon le mois seul au lieu de la tranche du cumul annuel, ce qui serait faux). + var baremeAnnuel = await _baremeService.CalculerMontantAsync( annee, vehicule.PuissanceFiscale, totalAnnuelPartiel, cancellationToken); - var montantBaremePlein = Math.Round(bareme.Montant, 2, MidpointRounding.AwayFromZero); + var montantMoisSelonTrancheAnnuelle = totalMoisAffiche * baremeAnnuel.Coefficient + baremeAnnuel.Base; - // Montant_Previsionnel = 80% du barème plein, arrondi à 2 décimales (indicatif — Exigences 13.5/13.6). - var montantPrevisionnel = Math.Round(bareme.Montant * TauxPrevisionnel, 2, MidpointRounding.AwayFromZero); + // Montant_Previsionnel_Mensuel = 80% du barème (tranche du cumul annuel) appliqué au mois affiché. + var montantPrevisionnelMensuel = Math.Round( + montantMoisSelonTrancheAnnuelle * TauxPrevisionnel, 2, MidpointRounding.AwayFromZero); + + // Montant_Previsionnel_Annuel = 100% du barème plein appliqué au cumul annuel. + var montantPrevisionnelAnnuel = Math.Round(baremeAnnuel.Montant, 2, MidpointRounding.AwayFromZero); return new MontantPrevisionnelDto( Annee: annee, Mois: mois, VehiculeId: vehiculeId, - TotalAnnuelPartielKm: Math.Round(totalAnnuelPartiel, 2, MidpointRounding.AwayFromZero), - MontantBaremePlein: montantBaremePlein, - MontantPrevisionnel: montantPrevisionnel); + TotalMoisKm: totalMoisAffiche, + TotalAnnuelPartielKm: totalAnnuelPartiel, + MontantPrevisionnelMensuel: montantPrevisionnelMensuel, + MontantPrevisionnelAnnuel: montantPrevisionnelAnnuel); } private static MontantRegleDto ToDto(MontantRegle m) => diff --git a/backend/SchotzIadKmTracker.Api/Services/PrecisionDistanceService.cs b/backend/SchotzIadKmTracker.Api/Services/PrecisionDistanceService.cs new file mode 100644 index 0000000..4c2c0fc --- /dev/null +++ b/backend/SchotzIadKmTracker.Api/Services/PrecisionDistanceService.cs @@ -0,0 +1,69 @@ +using Microsoft.EntityFrameworkCore; +using SchotzIadKmTracker.Api.Data; +using SchotzIadKmTracker.Api.Models.Entities; +using SchotzIadKmTracker.Api.Services.Exceptions; + +namespace SchotzIadKmTracker.Api.Services; + +/// +public class PrecisionDistanceService : IPrecisionDistanceService +{ + // La configuration est un singleton : une seule ligne dont l'identifiant est toujours 1. + private const int ParametresId = 1; + + private readonly AppDbContext _context; + + public PrecisionDistanceService(AppDbContext context) + { + _context = context; + } + + /// + public async Task ObtenirAsync(CancellationToken cancellationToken = default) + { + var parametres = await GetOrCreateAsync(cancellationToken); + return parametres.PrecisionDistanceKm; + } + + /// + public async Task DefinirAsync(int valeur, CancellationToken cancellationToken = default) + { + if (valeur is not (0 or 1 or 2)) + { + throw new PrecisionDistanceInvalideException( + "La précision des distances doit être 0, 1 ou 2 décimale(s)."); + } + + var parametres = await GetOrCreateAsync(cancellationToken); + parametres.PrecisionDistanceKm = valeur; + parametres.UpdatedAt = DateTime.UtcNow; + await _context.SaveChangesAsync(cancellationToken); + return parametres.PrecisionDistanceKm; + } + + /// + public decimal ArrondirDistance(decimal distanceBrute, int precision) + { + var facteur = (decimal)Math.Pow(10, precision); + return Math.Ceiling(distanceBrute * facteur) / facteur; + } + + /// + /// Récupère la configuration singleton (Id = 1) ou la crée à la volée si elle est absente, + /// avec la valeur par défaut (2 décimales). + /// + private async Task GetOrCreateAsync(CancellationToken cancellationToken) + { + var parametres = await _context.ParametresApplication + .FirstOrDefaultAsync(p => p.Id == ParametresId, cancellationToken); + if (parametres is not null) + { + return parametres; + } + + parametres = new ParametresApplication { Id = ParametresId }; + await _context.ParametresApplication.AddAsync(parametres, cancellationToken); + await _context.SaveChangesAsync(cancellationToken); + return parametres; + } +} diff --git a/backend/SchotzIadKmTracker.Api/Services/RemboursementService.cs b/backend/SchotzIadKmTracker.Api/Services/RemboursementService.cs index e22635b..2ef045d 100644 --- a/backend/SchotzIadKmTracker.Api/Services/RemboursementService.cs +++ b/backend/SchotzIadKmTracker.Api/Services/RemboursementService.cs @@ -12,15 +12,18 @@ public class RemboursementService : IRemboursementService private readonly AppDbContext _context; private readonly IBaremeService _baremeService; private readonly IMontantRegleService _montantRegleService; + private readonly IPrecisionDistanceService _precisionDistanceService; public RemboursementService( AppDbContext context, IBaremeService baremeService, - IMontantRegleService montantRegleService) + IMontantRegleService montantRegleService, + IPrecisionDistanceService precisionDistanceService) { _context = context; _baremeService = baremeService; _montantRegleService = montantRegleService; + _precisionDistanceService = precisionDistanceService; } /// @@ -32,6 +35,9 @@ public class RemboursementService : IRemboursementService .FirstOrDefaultAsync(v => v.Id == vehiculeId, cancellationToken) ?? throw new VehiculeNotFoundException($"Le véhicule d'identifiant {vehiculeId} est introuvable."); + // Précision d'arrondi courante (Exigence 4.1) : lue une fois pour toute la requête. + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + // Kilomètres du véhicule par mois pour l'année (Distance nullable → 0 quand null). // Le GROUP BY + SUM sur decimal n'est pas traduisible par SQLite : on ramène les // trajets de l'année puis on agrège côté client. @@ -39,13 +45,15 @@ public class RemboursementService : IRemboursementService .AsNoTracking() .Where(t => t.VehiculeId == vehiculeId && t.Date.Year == annee) // On ramène la distance simple et l'indicateur aller/retour, puis on agrège la - // distance EFFECTIVE (doublée si A/R) côté client. + // distance EFFECTIVE (arrondie AVANT doublement si A/R — Exigence 4.2) côté client. .Select(t => new { t.Date.Month, t.Distance, t.AllerRetour }) .ToListAsync(cancellationToken); var kmMoisMap = trajetsAnnee .GroupBy(t => t.Month) - .ToDictionary(g => g.Key, g => g.Sum(t => (t.Distance ?? 0m) * (t.AllerRetour ? 2m : 1m))); + .ToDictionary( + g => g.Key, + g => g.Sum(t => _precisionDistanceService.ArrondirDistance(t.Distance ?? 0m, precision) * (t.AllerRetour ? 2m : 1m))); // Total kilométrique annuel COMPLET (détermine la tranche — Exigence 14.5, Property 27). var totalKmAnnuel = kmMoisMap.Values.Sum(); @@ -78,7 +86,7 @@ public class RemboursementService : IRemboursementService lignes.Add(new LigneSyntheseMoisDto( Mois: mois, - KmMois: Math.Round(kmMois, 2, MidpointRounding.AwayFromZero), + KmMois: kmMois, FraisPaye: fraisPaye, FraisReelMensuel: fraisReelMensuel)); } @@ -97,7 +105,7 @@ public class RemboursementService : IRemboursementService BaseTranche: baseTranche, TrancheLibelle: trancheLibelle, Mois: lignes, - TotalKmAnnuel: Math.Round(totalKmAnnuel, 2, MidpointRounding.AwayFromZero), + TotalKmAnnuel: totalKmAnnuel, TotalPaye: totalPaye, MontantReel: montantReel, Regularisation: regularisation); diff --git a/backend/SchotzIadKmTracker.Api/Services/ResumeService.cs b/backend/SchotzIadKmTracker.Api/Services/ResumeService.cs index f0a6d24..094877c 100644 --- a/backend/SchotzIadKmTracker.Api/Services/ResumeService.cs +++ b/backend/SchotzIadKmTracker.Api/Services/ResumeService.cs @@ -15,10 +15,12 @@ public class ResumeService : IResumeService private const int AnneeMax = 2100; private readonly AppDbContext _context; + private readonly IPrecisionDistanceService _precisionDistanceService; - public ResumeService(AppDbContext context) + public ResumeService(AppDbContext context, IPrecisionDistanceService precisionDistanceService) { _context = context; + _precisionDistanceService = precisionDistanceService; } /// @@ -28,9 +30,10 @@ public class ResumeService : IResumeService ValiderAnnee(annee); ValiderMois(mois); + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); var trajets = await ChargerTrajetsDuMoisAsync(annee, mois, vehiculeId, cancellationToken); - return ConstruireResumeMensuel(annee, mois, trajets); + return ConstruireResumeMensuel(annee, mois, trajets, precision); } /// @@ -39,6 +42,8 @@ public class ResumeService : IResumeService { ValiderAnnee(annee); + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + // Charge une seule fois tous les trajets de l'année, puis répartit par mois. var query = _context.Trajets .AsNoTracking() @@ -58,11 +63,11 @@ public class ResumeService : IResumeService .Where(t => t.Date.Month == mois) .ToList(); - resumesMensuels.Add(ConstruireResumeMensuel(annee, mois, trajetsDuMois)); + resumesMensuels.Add(ConstruireResumeMensuel(annee, mois, trajetsDuMois, precision)); } - // Total annuel = somme des 12 totaux mensuels (Exigences 4.3, 4.7, 6.6). - var totalAnnuel = Arrondir(resumesMensuels.Sum(r => r.TotalKm)); + // Total annuel = somme des 12 totaux mensuels, déjà arrondis (Exigences 4.3, 4.7, 6.6, 5.2, 5.3). + var totalAnnuel = resumesMensuels.Sum(r => r.TotalKm); return new ResumeAnnuelDto(annee, resumesMensuels, totalAnnuel); } @@ -93,17 +98,39 @@ public class ResumeService : IResumeService /// /// Construit un à partir d'une liste de Trajets déjà triée. - /// Le total est la somme des distances (null → 0) arrondie à 2 décimales (Property 1). + /// Chaque distance est arrondie (Precision_Distance) AVANT doublement aller/retour ; le total + /// est la somme de ces valeurs déjà arrondies, sans second arrondi (Property 1, Property 2, Property 3). /// - private static ResumeMensuelDto ConstruireResumeMensuel(int annee, int mois, IReadOnlyList trajets) + private ResumeMensuelDto ConstruireResumeMensuel( + int annee, int mois, IReadOnlyList trajets, int precision) { - var trajetsDto = trajets.Select(ToDto).ToList(); - // Total = somme des distances EFFECTIVES (doublées si aller/retour), null → 0 (Property 1). - var totalKm = Arrondir(trajets.Sum(t => t.DistanceEffective ?? 0m)); + // Calculée une seule fois par trajet, puis réutilisée pour le DTO et la somme du total + // afin de garantir la même valeur (Distance_Effective_Arrondie) aux deux endroits. + var distancesArrondies = trajets.Select(t => (t, distance: DistanceEffectiveArrondie(t, precision))).ToList(); + + var trajetsDto = distancesArrondies.Select(x => ToDto(x.t, x.distance)).ToList(); + // Total = somme des Distance_Effective_Arrondie déjà calculées par trajet, null → 0 (Property 1, Property 3). + var totalKm = distancesArrondies.Sum(x => x.distance ?? 0m); return new ResumeMensuelDto(annee, mois, trajetsDto, totalKm); } + /// + /// Calcule la Distance_Effective_Arrondie d'un trajet : arrondi (Precision_Distance) appliqué + /// à la distance SIMPLE brute AVANT doublement aller/retour (Exigence 4.1, 4.2, 4.3). null si la + /// distance brute n'a pas pu être calculée (Exigence 2.4 du résumé existant). + /// + private decimal? DistanceEffectiveArrondie(Trajet t, int precision) + { + if (!t.Distance.HasValue) + { + return null; + } + + var distanceArrondie = _precisionDistanceService.ArrondirDistance(t.Distance.Value, precision); + return t.AllerRetour ? distanceArrondie * 2m : distanceArrondie; + } + private void ValiderMois(int mois) { if (mois < MoisMin || mois > MoisMax) @@ -122,17 +149,15 @@ public class ResumeService : IResumeService } } - private static decimal Arrondir(decimal valeur) => - Math.Round(valeur, 2, MidpointRounding.AwayFromZero); - - private static TrajetDto ToDto(Trajet t) => + private static TrajetDto ToDto(Trajet t, decimal? distanceEffectiveArrondie) => new( t.Id, t.Date, t.AdresseDepart, t.AdresseArrivee, - // Distance EFFECTIVE (doublée si aller/retour), alignée sur le TrajetDto commun. - t.DistanceEffective, + // Distance_Effective_Arrondie (arrondi Precision_Distance puis doublement si aller/retour), + // alignée sur le TrajetDto commun (au lieu de DistanceEffective brut). + distanceEffectiveArrondie, t.Commentaire, t.Position, t.VehiculeId, diff --git a/backend/SchotzIadKmTracker.Api/Services/TotauxService.cs b/backend/SchotzIadKmTracker.Api/Services/TotauxService.cs index 31dd4ff..1d3cec1 100644 --- a/backend/SchotzIadKmTracker.Api/Services/TotauxService.cs +++ b/backend/SchotzIadKmTracker.Api/Services/TotauxService.cs @@ -9,11 +9,14 @@ public class TotauxService : ITotauxService { private readonly AppDbContext _context; private readonly IVehiculeService _vehiculeService; + private readonly IPrecisionDistanceService _precisionDistanceService; - public TotauxService(AppDbContext context, IVehiculeService vehiculeService) + public TotauxService( + AppDbContext context, IVehiculeService vehiculeService, IPrecisionDistanceService precisionDistanceService) { _context = context; _vehiculeService = vehiculeService; + _precisionDistanceService = precisionDistanceService; } /// @@ -24,6 +27,10 @@ public class TotauxService : ITotauxService var vehiculeCible = vehiculeId ?? (await _vehiculeService.GetVehiculeCourantAsync(cancellationToken)).Id; + // Précision courante (0/1/2 décimales) : lue une fois par appel, stable pour tous les + // totaux calculés ci-dessous (Exigences 4.1, 4.2, 4.3). + var precision = await _precisionDistanceService.ObtenirAsync(cancellationToken); + // Trajets du véhicule pour l'année sélectionnée (Property 21 : filtrage par véhicule). // Distance nullable → 0 lors des sommes (traitée côté client après projection). var trajetsAnnee = await _context.Trajets @@ -34,9 +41,10 @@ public class TotauxService : ITotauxService .Select(t => new { t.Date, t.Distance, t.AllerRetour }) .ToListAsync(cancellationToken); - // Distance comptée (effective) : distance simple × 2 si aller/retour, null → 0. - static decimal Effective(decimal? distance, bool allerRetour) => - distance.GetValueOrDefault() * (allerRetour ? 2m : 1m); + // Distance comptée (effective) : distance simple arrondie à la précision courante, + // PUIS doublée si aller/retour (Exigence 4.2 — arrondi avant doublement), null → 0. + decimal Effective(decimal? distance, bool allerRetour) => + _precisionDistanceService.ArrondirDistance(distance.GetValueOrDefault(), precision) * (allerRetour ? 2m : 1m); // TotalJour : somme des distances effectives de la journée sélectionnée (Exigence 12.7). var totalJour = trajetsAnnee @@ -54,12 +62,15 @@ public class TotauxService : ITotauxService .Where(t => t.Date.Month <= date.Month) .Sum(t => Effective(t.Distance, t.AllerRetour)); + // Les distances sommées sont déjà arrondies à la précision courante (via + // ArrondirDistance) : aucun second arrondi forcé à 2 décimales n'est appliqué ici + // (Exigences 5.1, 5.4). return new TotauxDto( Date: date, VehiculeId: vehiculeCible, - TotalJour: Math.Round(totalJour, 2, MidpointRounding.AwayFromZero), - TotalMois: Math.Round(totalMois, 2, MidpointRounding.AwayFromZero), - TotalAnnuelPartiel: Math.Round(totalAnnuelPartiel, 2, MidpointRounding.AwayFromZero)); + TotalJour: totalJour, + TotalMois: totalMois, + TotalAnnuelPartiel: totalAnnuelPartiel); } /// diff --git a/backend/SchotzIadKmTracker.Tests/PrecisionDistance/AgregationDistanceProperties.cs b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/AgregationDistanceProperties.cs new file mode 100644 index 0000000..1d62fe7 --- /dev/null +++ b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/AgregationDistanceProperties.cs @@ -0,0 +1,154 @@ +using System.Threading; +using FluentAssertions; +using FsCheck; +using FsCheck.Xunit; +using SchotzIadKmTracker.Api.Services; +using Xunit; + +namespace SchotzIadKmTracker.Tests.PrecisionDistance; + +/// +/// Tests de propriétés (FsCheck.Xunit, >= 100 itérations) de la sommation des distances +/// arrondies (feature precision-distances-km), couvrant les Correctness Properties 2 et 3 +/// de la conception, ainsi que le test unitaire de l'exemple chiffré aller/retour (tâche 5.5). +/// +public class AgregationDistanceProperties +{ + /// Distances brutes positives et raisonnables (0 exclu, jusqu'à 1 000 km). + private static Arbitrary DistancePositiveArb() + { + var g = + from entier in Gen.Choose(1, 100_000) + select entier / 100m; // pas de 0.01 km, jusqu'à 1 000.00 km + + return Arb.From(g); + } + + private static Arbitrary PrecisionValideArb() => Arb.From(Gen.Elements(0, 1, 2)); + + /// Génère une petite liste (0 à 15 éléments) de (distance nullable, allerRetour). + private static Arbitrary> ListeTrajetsArb() + { + var distanceNullable = + Gen.Frequency( + Tuple.Create(1, Gen.Constant((decimal?)null)), + Tuple.Create(9, DistancePositiveArb().Generator.Select(d => (decimal?)d))); + + var element = + from distance in distanceNullable + from allerRetour in Gen.Elements(true, false) + select (distance, allerRetour); + + var liste = + from n in Gen.Choose(0, 15) + from items in Gen.ListOf(n, element) + select items.ToList(); + + return Arb.From(liste); + } + + // Feature: precision-distances-km, Property 2: Arrondi avant doublement pour Aller_Retour + // distanceEffectiveArrondie(distance, allerRetour=true, precision) == 2 × ArrondirDistance(distance, precision), + // différent en général de ArrondirDistance(2×distance, precision). + // Validates: Requirements 4.1, 4.2, 4.3 + [Property(MaxTest = 100)] + public Property P2_Arrondi_avant_doublement_pour_aller_retour() + { + return Prop.ForAll(DistancePositiveArb(), PrecisionValideArb(), (distance, precision) => + { + using var h = new PrecisionDistanceTestHarness(); + var service = h.PrecisionDistanceService; + + var arrondiSimple = service.ArrondirDistance(distance, precision); + var distanceEffectiveAllerRetour = arrondiSimple * 2m; + var distanceEffectiveSimple = arrondiSimple; + + // allerRetour = true => arrondi PUIS doublement. + distanceEffectiveAllerRetour.Should().Be(2m * service.ArrondirDistance(distance, precision)); + + // allerRetour = false => pas de doublement. + distanceEffectiveSimple.Should().Be(service.ArrondirDistance(distance, precision)); + + // L'implémentation ne doit jamais doubler AVANT d'arrondir : les deux ordres + // diffèrent en général (on vérifie qu'au moins il existe des cas où ils diffèrent, + // via l'exemple chiffré dédié ci-dessous ; ici on vérifie que l'ordre retenu est + // bien "arrondir puis doubler", ce qui est la seule propriété universelle garantie). + var doublerPuisArrondir = service.ArrondirDistance(distance * 2m, precision); + (distanceEffectiveAllerRetour >= distance * 2m).Should().BeTrue(); + (doublerPuisArrondir >= distance * 2m).Should().BeTrue(); + }); + } + + // Feature: precision-distances-km, Property 3: Sommation de distances déjà arrondies sans arrondi supplémentaire + // Pour une liste de trajets, la somme des distances effectives arrondies individuellement + // égale exactement le total retourné par le service d'agrégation. + // Validates: Requirements 5.1, 5.2, 5.3, 5.4 + [Property(MaxTest = 100)] + public Property P3_Sommation_de_distances_deja_arrondies_sans_arrondi_supplementaire() + { + return Prop.ForAll(ListeTrajetsArb(), PrecisionValideArb(), (trajetsSpec, precision) => + { + using var h = new PrecisionDistanceTestHarness(); + + h.PrecisionDistanceService.DefinirAsync(precision, CancellationToken.None) + .GetAwaiter().GetResult(); + + var vehiculeId = h.AjouterVehicule(); + var position = 1m; + foreach (var (distance, allerRetour) in trajetsSpec) + { + h.AjouterTrajet(vehiculeId, new DateOnly(2025, 3, 10), distance, allerRetour, position: position); + position += 1m; + } + + // Somme attendue : distance effective arrondie de CHAQUE trajet, calculée individuellement. + var sommeAttendue = trajetsSpec.Sum(t => + t.Distance.HasValue + ? h.PrecisionDistanceService.ArrondirDistance(t.Distance.Value, precision) * (t.AllerRetour ? 2m : 1m) + : 0m); + + var resume = h.ResumeService.GetResumeMensuelAsync(2025, 3, vehiculeId, CancellationToken.None) + .GetAwaiter().GetResult(); + + resume.TotalKm.Should().Be(sommeAttendue); + }); + } + + // Tâche 5.5 — Test unitaire de l'exemple chiffré Aller_Retour + // Cas concret : distance brute 12.30 km, précision 0 → résultat 26 km (PAS 25 km, qui serait + // le résultat si on doublait avant d'arrondir). + // Validates: Requirements 4.2 + [Fact] + public void Exemple_chiffre_12_30km_precision_0_aller_retour_donne_26km_et_pas_25km() + { + using var h = new PrecisionDistanceTestHarness(); + var service = h.PrecisionDistanceService; + + const decimal distanceBrute = 12.30m; + const int precision = 0; + + // Ordre correct : arrondir (13 km) PUIS doubler => 26 km. + var arrondiSimple = service.ArrondirDistance(distanceBrute, precision); + arrondiSimple.Should().Be(13m); + + var distanceEffectiveArrondie = arrondiSimple * 2m; + distanceEffectiveArrondie.Should().Be(26m); + + // Contre-exemple explicite de l'ordre INCORRECT (doubler puis arrondir => 25 km) : + // on vérifie que ce résultat, bien que "plausible", diffère de la valeur correcte. + var doublerPuisArrondir = service.ArrondirDistance(distanceBrute * 2m, precision); + doublerPuisArrondir.Should().Be(25m); + distanceEffectiveArrondie.Should().NotBe(doublerPuisArrondir); + + // Vérification bout en bout via ResumeService (même formule utilisée en production). + h.PrecisionDistanceService.DefinirAsync(precision, CancellationToken.None).GetAwaiter().GetResult(); + var vehiculeId = h.AjouterVehicule(); + h.AjouterTrajet(vehiculeId, new DateOnly(2025, 4, 1), distanceBrute, allerRetour: true); + + var resume = h.ResumeService.GetResumeMensuelAsync(2025, 4, vehiculeId, CancellationToken.None) + .GetAwaiter().GetResult(); + + resume.TotalKm.Should().Be(26m); + resume.Trajets.Single().Distance.Should().Be(26m); + } +} diff --git a/backend/SchotzIadKmTracker.Tests/PrecisionDistance/MontantPrevisionnelProperties.cs b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/MontantPrevisionnelProperties.cs new file mode 100644 index 0000000..a1cbd10 --- /dev/null +++ b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/MontantPrevisionnelProperties.cs @@ -0,0 +1,122 @@ +using System.Threading; +using FluentAssertions; +using FsCheck; +using FsCheck.Xunit; +using Xunit; + +namespace SchotzIadKmTracker.Tests.PrecisionDistance; + +/// +/// Tests de propriétés (FsCheck.Xunit, >= 100 itérations) du calcul prévisionnel +/// (feature precision-distances-km), couvrant les Correctness Properties 6 et 7 de la +/// conception (). +/// +public class MontantPrevisionnelProperties +{ + private const int Annee = 2025; + private const int PuissanceFiscale = 5; + + /// Distances brutes positives et raisonnables (0 exclu, jusqu'à 500 km par trajet). + private static Arbitrary DistancePositiveArb() + { + var g = + from entier in Gen.Choose(1, 50_000) + select entier / 100m; // pas de 0.01 km, jusqu'à 500.00 km + + return Arb.From(g); + } + + private static Arbitrary PrecisionValideArb() => Arb.From(Gen.Elements(0, 1, 2)); + + /// Mois autre que le mois M passé en paramètre (1..12, différent de M). + private static Gen AutreMoisGen(int mois) => + Gen.Elements(Enumerable.Range(1, 12).Where(m => m != mois).ToArray()); + + // Feature: precision-distances-km, Property 6: Montant_Previsionnel_Mensuel dépend uniquement du mois affiché + // Pour tout mois M, le montant mensuel ne change pas si on modifie les distances d'un autre + // mois, tant que le cumul annuel reste dans la même tranche de barème. + // Validates: Requirements 7.1, 7.2 + [Property(MaxTest = 100)] + public Property P6_Montant_previsionnel_mensuel_depend_uniquement_du_mois_affiche() + { + var entreesArb = Arb.From( + from mois in Gen.Choose(1, 12) + from distanceMois in DistancePositiveArb().Generator + from distanceAutre in DistancePositiveArb().Generator + from precision in PrecisionValideArb().Generator + select (mois, distanceMois, distanceAutre, precision)); + + return Prop.ForAll(entreesArb, entree => + { + var (moisAffiche, distanceMoisAffiche, distanceAutreMoisInitiale, precision) = entree; + using var h = new PrecisionDistanceTestHarness(); + + h.PrecisionDistanceService.DefinirAsync(precision, CancellationToken.None) + .GetAwaiter().GetResult(); + + // Une seule tranche illimitée : garantit que le cumul annuel reste TOUJOURS + // dans la même tranche, quelle que soit la distance de l'autre mois modifiée. + h.AjouterTrancheBaremeUnique(Annee, PuissanceFiscale, coefficient: 0.35m, baseFixe: 0m); + + var vehiculeId = h.AjouterVehicule(PuissanceFiscale); + var autreMois = AutreMoisGen(moisAffiche).Sample(0, 1).First(); + + h.AjouterTrajet(vehiculeId, new DateOnly(Annee, moisAffiche, 1), distanceMoisAffiche); + var trajetAutreMoisId = h.AjouterTrajet( + vehiculeId, new DateOnly(Annee, autreMois, 1), distanceAutreMoisInitiale, position: 2m); + + var avant = h.MontantRegleService + .GetMontantPrevisionnelAsync(Annee, moisAffiche, vehiculeId, CancellationToken.None) + .GetAwaiter().GetResult(); + + // Modification de la distance de l'AUTRE mois (le mois affiché n'est jamais touché). + var trajetAutreMois = h.Context.Trajets.Single(t => t.Id == trajetAutreMoisId); + trajetAutreMois.Distance = distanceAutreMoisInitiale + 10m; + h.Context.SaveChanges(); + + var apres = h.MontantRegleService + .GetMontantPrevisionnelAsync(Annee, moisAffiche, vehiculeId, CancellationToken.None) + .GetAwaiter().GetResult(); + + // Le montant prévisionnel mensuel du mois affiché est inchangé (Requirement 7.1). + apres.MontantPrevisionnelMensuel.Should().Be(avant.MontantPrevisionnelMensuel); + apres.TotalMoisKm.Should().Be(avant.TotalMoisKm); + }); + } + + // Feature: precision-distances-km, Property 7: Montant_Previsionnel_Annuel égal au barème plein sur le cumul + // Pour tout Total_Annuel_Partiel arrondi, MontantPrevisionnelAnnuel == montant retourné par + // CalculerMontantAsync appliqué à ce total, coefficient 1.00 (pas de minoration), arrondi 2 décimales. + // Validates: Requirements 8.2, 8.5 + [Property(MaxTest = 100)] + public Property P7_Montant_previsionnel_annuel_egal_au_bareme_plein_sur_le_cumul() + { + return Prop.ForAll(DistancePositiveArb(), PrecisionValideArb(), (distance, precision) => + { + using var h = new PrecisionDistanceTestHarness(); + + h.PrecisionDistanceService.DefinirAsync(precision, CancellationToken.None) + .GetAwaiter().GetResult(); + + h.AjouterTrancheBaremeUnique(Annee, PuissanceFiscale, coefficient: 0.35m, baseFixe: 10m); + + var vehiculeId = h.AjouterVehicule(PuissanceFiscale); + h.AjouterTrajet(vehiculeId, new DateOnly(Annee, 6, 1), distance); + + var mois = 6; + var resultat = h.MontantRegleService + .GetMontantPrevisionnelAsync(Annee, mois, vehiculeId, CancellationToken.None) + .GetAwaiter().GetResult(); + + // Montant retourné par CalculerMontantAsync appliqué au même Total_Annuel_Partiel arrondi, + // sans minoration (coefficient 1.00), arrondi à 2 décimales. + var baremePlein = h.BaremeService + .CalculerMontantAsync(Annee, PuissanceFiscale, resultat.TotalAnnuelPartielKm, CancellationToken.None) + .GetAwaiter().GetResult(); + + var montantAttendu = Math.Round(baremePlein.Montant, 2, MidpointRounding.AwayFromZero); + + resultat.MontantPrevisionnelAnnuel.Should().Be(montantAttendu); + }); + } +} diff --git a/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceServiceProperties.cs b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceServiceProperties.cs new file mode 100644 index 0000000..187551d --- /dev/null +++ b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceServiceProperties.cs @@ -0,0 +1,122 @@ +using System.Threading; +using FluentAssertions; +using FsCheck; +using FsCheck.Xunit; +using SchotzIadKmTracker.Api.Services; +using SchotzIadKmTracker.Api.Services.Exceptions; +using Xunit; + +namespace SchotzIadKmTracker.Tests.PrecisionDistance; + +/// +/// Tests de propriétés (FsCheck.Xunit, >= 100 itérations) du service de précision des +/// distances (feature precision-distances-km), couvrant les Correctness Properties +/// 1, 4 et 5 de la conception. +/// +public class PrecisionDistanceServiceProperties +{ + // --- Générateurs contraints à l'espace d'entrée pertinent ------------------ + + /// Distances brutes positives et raisonnables (0 exclu, jusqu'à 100 000 km). + private static Arbitrary DistancePositiveArb() + { + var g = + from entier in Gen.Choose(1, 100_000_00) + select entier / 100m; // pas de 0.01 km, jusqu'à 100 000.00 km + + return Arb.From(g); + } + + /// Précisions valides : 0, 1 ou 2. + private static Arbitrary PrecisionValideArb() => Arb.From(Gen.Elements(0, 1, 2)); + + /// Entiers arbitraires, y compris hors de {0, 1, 2} (négatifs et > 2). + private static Arbitrary EntierArbitraireArb() => Arb.From(Gen.Choose(-1000, 1000)); + + // --------------------------------------------------------------------------- + + // Feature: precision-distances-km, Property 1: Arrondi supérieur exact et jamais inférieur à la distance brute + // Pour toute distance brute positive et toute précision valide (0,1,2), ArrondirDistance + // retourne une valeur >= distance brute, et le résultat × 10^precision est un entier. + // Validates: Requirements 3.1, 3.2, 3.3, 3.4, 3.5 + [Property(MaxTest = 100)] + public Property P1_Arrondi_superieur_exact_et_jamais_inferieur() + { + return Prop.ForAll(DistancePositiveArb(), PrecisionValideArb(), (distance, precision) => + { + using var h = new PrecisionDistanceTestHarness(); + + var resultat = h.PrecisionDistanceService.ArrondirDistance(distance, precision); + + // Jamais inférieur à la distance brute. + resultat.Should().BeGreaterThanOrEqualTo(distance); + + // Le résultat × 10^precision est un entier exact (multiple du pas de précision). + var facteur = (decimal)Math.Pow(10, precision); + var mis = resultat * facteur; + mis.Should().Be(Math.Round(mis, 0)); + }); + } + + // Feature: precision-distances-km, Property 4: Validation stricte de la précision + // Pour tout entier, DefinirAsync accepte et persiste si et seulement si la valeur ∈ {0,1,2} ; + // sinon exception levée et valeur précédente inchangée. + // Validates: Requirements 1.6 + [Property(MaxTest = 100)] + public Property P4_Validation_stricte_de_la_precision() + { + return Prop.ForAll(EntierArbitraireArb(), valeur => + { + using var h = new PrecisionDistanceTestHarness(); + + // Valeur initiale connue, différente des valeurs de test invalides typiques. + var precedente = h.PrecisionDistanceService.DefinirAsync(1, CancellationToken.None) + .GetAwaiter().GetResult(); + + if (valeur is 0 or 1 or 2) + { + var resultat = h.PrecisionDistanceService.DefinirAsync(valeur, CancellationToken.None) + .GetAwaiter().GetResult(); + + resultat.Should().Be(valeur); + h.PrecisionDistanceService.ObtenirAsync(CancellationToken.None) + .GetAwaiter().GetResult().Should().Be(valeur); + } + else + { + Func action = () => h.PrecisionDistanceService.DefinirAsync(valeur, CancellationToken.None); + action.Should().ThrowAsync().GetAwaiter().GetResult(); + + // La valeur précédemment persistée (1) reste inchangée. + h.PrecisionDistanceService.ObtenirAsync(CancellationToken.None) + .GetAwaiter().GetResult().Should().Be(precedente); + } + }); + } + + // Feature: precision-distances-km, Property 5: Invariance de la distance brute stockée + // Un changement de Precision_Distance ne modifie jamais Trajet.Distance en base. + // Validates: Requirements 1.5, 1.8 + [Property(MaxTest = 100)] + public Property P5_Invariance_de_la_distance_brute_stockee() + { + return Prop.ForAll(DistancePositiveArb(), PrecisionValideArb(), PrecisionValideArb(), + (distanceBrute, premierePrecision, deuxiemePrecision) => + { + using var h = new PrecisionDistanceTestHarness(); + + var vehiculeId = h.AjouterVehicule(); + var trajetId = h.AjouterTrajet(vehiculeId, new DateOnly(2025, 6, 15), distanceBrute); + + // Deux changements successifs de précision (valides). + h.PrecisionDistanceService.DefinirAsync(premierePrecision, CancellationToken.None) + .GetAwaiter().GetResult(); + h.PrecisionDistanceService.DefinirAsync(deuxiemePrecision, CancellationToken.None) + .GetAwaiter().GetResult(); + + // La distance brute stockée en base reste strictement inchangée. + var trajet = h.Context.Trajets.Single(t => t.Id == trajetId); + trajet.Distance.Should().Be(distanceBrute); + }); + } +} diff --git a/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceTestHarness.cs b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceTestHarness.cs new file mode 100644 index 0000000..64c20ef --- /dev/null +++ b/backend/SchotzIadKmTracker.Tests/PrecisionDistance/PrecisionDistanceTestHarness.cs @@ -0,0 +1,114 @@ +using Microsoft.Data.Sqlite; +using Microsoft.EntityFrameworkCore; +using SchotzIadKmTracker.Api.Data; +using SchotzIadKmTracker.Api.Models.Entities; +using SchotzIadKmTracker.Api.Services; + +namespace SchotzIadKmTracker.Tests.PrecisionDistance; + +/// +/// Banc d'essai pour tester les services liés à la précision des distances +/// (feature precision-distances-km) en isolation. +/// +/// Utilise un adossé à une base SQLite EN MÉMOIRE +/// ("Data Source=:memory:") dont la connexion est maintenue ouverte pour la +/// durée du harnais (la base disparaît à la fermeture de la connexion), sur le +/// même modèle que . +/// +/// Expose les services réels (, , +/// , , , +/// ) branchés sur le même contexte, ainsi que des méthodes +/// utilitaires pour insérer rapidement Véhicules/Trajets/Tranches de barème de test. +/// +public sealed class PrecisionDistanceTestHarness : IDisposable +{ + private readonly SqliteConnection _connection; + + public AppDbContext Context { get; } + public IPrecisionDistanceService PrecisionDistanceService { get; } + public IBaremeService BaremeService { get; } + public IResumeService ResumeService { get; } + public IMontantRegleService MontantRegleService { get; } + + public PrecisionDistanceTestHarness() + { + _connection = new SqliteConnection("Data Source=:memory:"); + _connection.Open(); // maintenue ouverte : garde la base en vie + + var options = new DbContextOptionsBuilder() + .UseSqlite(_connection) + .Options; + + Context = new AppDbContext(options); + Context.Database.EnsureCreated(); + + PrecisionDistanceService = new SchotzIadKmTracker.Api.Services.PrecisionDistanceService(Context); + BaremeService = new SchotzIadKmTracker.Api.Services.BaremeService(Context); + ResumeService = new SchotzIadKmTracker.Api.Services.ResumeService(Context, PrecisionDistanceService); + MontantRegleService = new SchotzIadKmTracker.Api.Services.MontantRegleService( + Context, BaremeService, PrecisionDistanceService); + } + + /// Insère un véhicule de test et retourne son identifiant. + public int AjouterVehicule(int puissanceFiscale = 5, string plaque = "AA-000-AA", DateOnly? dateEffet = null) + { + var vehicule = new Vehicule + { + Denomination = "Véhicule de test", + Plaque = plaque, + PuissanceFiscale = puissanceFiscale, + DateEffet = dateEffet ?? new DateOnly(2020, 1, 1), + }; + + Context.Vehicules.Add(vehicule); + Context.SaveChanges(); + return vehicule.Id; + } + + /// Insère un trajet de test et retourne son identifiant. + public int AjouterTrajet( + int vehiculeId, + DateOnly date, + decimal? distance, + bool allerRetour = false, + int puissanceFiscale = 5, + decimal position = 1m) + { + var trajet = new Trajet + { + Date = date, + AdresseDepart = "Départ test", + AdresseArrivee = "Arrivée test", + Distance = distance, + AllerRetour = allerRetour, + Position = position, + VehiculeId = vehiculeId, + PuissanceFiscale = puissanceFiscale, + }; + + Context.Trajets.Add(trajet); + Context.SaveChanges(); + return trajet.Id; + } + + /// Insère une tranche de barème unique (illimitée) couvrant tous les kilométrages. + public void AjouterTrancheBaremeUnique(int annee, int puissanceFiscale, decimal coefficient, decimal baseFixe = 0m) + { + Context.TranchesBareme.Add(new TrancheBareme + { + Annee = annee, + PuissanceFiscale = puissanceFiscale, + KmMin = 0m, + KmMax = null, + Coefficient = coefficient, + Base = baseFixe, + }); + Context.SaveChanges(); + } + + public void Dispose() + { + Context.Dispose(); + _connection.Dispose(); + } +} diff --git a/frontend/chromium_152.0.7977.82~linuxmint1+zena_amd64.deb b/frontend/chromium_152.0.7977.82~linuxmint1+zena_amd64.deb deleted file mode 100644 index 55362bb..0000000 Binary files a/frontend/chromium_152.0.7977.82~linuxmint1+zena_amd64.deb and /dev/null differ diff --git a/frontend/src/app/app.component.ts b/frontend/src/app/app.component.ts index 749bc96..290270b 100644 --- a/frontend/src/app/app.component.ts +++ b/frontend/src/app/app.component.ts @@ -4,6 +4,7 @@ import { toSignal } from '@angular/core/rxjs-interop'; import { catchError, filter, map, of, startWith } from 'rxjs'; import { AuthService } from './core/services/auth.service'; +import { ParametresApplicationService } from './core/services/parametres-application.service'; import { ProfilService } from './core/services/profil.service'; /** @@ -28,6 +29,7 @@ export class AppComponent { private readonly authService = inject(AuthService); private readonly profilService = inject(ProfilService); + private readonly parametresService = inject(ParametresApplicationService); private readonly router = inject(Router); /** Chemin de la route active, mis à jour à chaque navigation terminée. */ @@ -89,6 +91,12 @@ export class AppComponent { this.prenom.set(profil?.prenom ?? null); this.nom.set(profil?.nom ?? null); }); + // Charge la précision de distance globale ; en cas d'échec, le signal + // `precisionDistance` reste à sa valeur par défaut (2) sans bloquer l'application. + this.parametresService + .charger() + .pipe(catchError(() => of(null))) + .subscribe(); } else { this.prenom.set(null); this.nom.set(null); diff --git a/frontend/src/app/app.routes.ts b/frontend/src/app/app.routes.ts index 6b30a41..733d3ea 100644 --- a/frontend/src/app/app.routes.ts +++ b/frontend/src/app/app.routes.ts @@ -13,6 +13,7 @@ import { MontantsReglesComponent } from './features/montants-regles/montants-reg import { MaintenanceComponent } from './features/maintenance/maintenance.component'; import { OnboardingComponent } from './features/onboarding/onboarding.component'; import { ParametrageComponent } from './features/parametrage/parametrage.component'; +import { ParametresApplicationComponent } from './features/parametres-application/parametres-application.component'; import { ProfilComponent } from './features/profil/profil.component'; import { ResumeAnnuelComponent } from './features/resume-annuel/resume-annuel.component'; import { ResumeMensuelComponent } from './features/resume-mensuel/resume-mensuel.component'; @@ -29,10 +30,11 @@ import { VehiculesComponent } from './features/vehicules/vehicules.component'; * et du premier véhicule — comportement inchangé). * `authGuard` est vérifiée en premier ; on n'y applique pas `profilConfigureGuard` * pour ne pas piéger un utilisateur partiellement configuré. - * - `parametrage` (menu latéral + routes enfants `compte` / `vehicules` / `bareme`, - * accessible depuis le sous-menu de l'avatar utilisateur) : `parametrage` lui-même - * et ses enfants `compte` / `vehicules` ne portent que `authGuard` (mêmes raisons - * que ci-dessus) ; seul l'enfant `bareme` ajoute `profilConfigureGuard`. + * - `parametrage` (menu latéral + routes enfants `compte` / `application` / `vehicules` / + * `bareme`, accessible depuis le sous-menu de l'avatar utilisateur) : `parametrage` + * lui-même et ses enfants `compte` / `application` / `vehicules` ne portent que + * `authGuard` (mêmes raisons que ci-dessus) ; seul l'enfant `bareme` ajoute + * `profilConfigureGuard`. * - Routes de données PROTEGEES par `[authGuard, profilConfigureGuard]` : * `consultation`, `carnet-adresses`, `resume-mensuel`, `resume-annuel`, * `montants-regles`. L'authentification est contrôlée d'abord, puis la @@ -64,8 +66,8 @@ export const routes: Routes = [ canActivate: [authGuard] }, - // Paramétrage : menu latéral (Compte, Véhicules, Barème) + contenu en routes enfants. - // - 'compte' et 'vehicules' : authGuard SEUL (pas profilConfigureGuard, pour ne pas + // Paramétrage : menu latéral (Compte, Application, Véhicules, Barème) + contenu en routes enfants. + // - 'compte', 'application' et 'vehicules' : authGuard SEUL (pas profilConfigureGuard, pour ne pas // piéger un utilisateur dont le profil n'est pas encore configuré). // - 'bareme' : authGuard + profilConfigureGuard (comportement inchangé). { @@ -75,6 +77,7 @@ export const routes: Routes = [ children: [ { path: '', redirectTo: 'compte', pathMatch: 'full' }, { path: 'compte', component: ProfilComponent }, + { path: 'application', component: ParametresApplicationComponent }, { path: 'vehicules', component: VehiculesComponent }, { path: 'bareme', component: BaremeComponent, canActivate: [profilConfigureGuard] } ] diff --git a/frontend/src/app/core/models/bareme.model.ts b/frontend/src/app/core/models/bareme.model.ts index 9fbb8c4..5b536ec 100644 --- a/frontend/src/app/core/models/bareme.model.ts +++ b/frontend/src/app/core/models/bareme.model.ts @@ -34,9 +34,10 @@ export interface MontantPrevisionnel { annee: number; mois: number; vehiculeId: number; + totalMoisKm: number; totalAnnuelPartielKm: number; - montantBaremePlein: number; // barème plein sur le total partiel - montantPrevisionnel: number; // = 80% (indicatif uniquement) + montantPrevisionnelMensuel: number; + montantPrevisionnelAnnuel: number; } /** Ligne mensuelle de la synthèse annuelle — miroir de LigneSyntheseMoisDto. */ diff --git a/frontend/src/app/core/models/index.ts b/frontend/src/app/core/models/index.ts index fa4a3e5..6b3b526 100644 --- a/frontend/src/app/core/models/index.ts +++ b/frontend/src/app/core/models/index.ts @@ -9,3 +9,4 @@ export * from './bareme.model'; export * from './adresse.model'; export * from './auth.model'; export * from './spec.model'; +export * from './parametres-application.model'; diff --git a/frontend/src/app/core/models/parametres-application.model.ts b/frontend/src/app/core/models/parametres-application.model.ts new file mode 100644 index 0000000..646a6e3 --- /dev/null +++ b/frontend/src/app/core/models/parametres-application.model.ts @@ -0,0 +1,6 @@ +// Modèle ParametresApplication — miroir de ParametresApplicationDtos.cs. + +/** Paramètres globaux de l'application — miroir de ParametresApplicationDto. */ +export interface ParametresApplication { + precisionDistanceKm: number; +} diff --git a/frontend/src/app/core/services/index.ts b/frontend/src/app/core/services/index.ts index 11f82a9..9134327 100644 --- a/frontend/src/app/core/services/index.ts +++ b/frontend/src/app/core/services/index.ts @@ -9,3 +9,4 @@ export * from './profil.service'; export * from './bareme.service'; export * from './remboursement.service'; export * from './spec.service'; +export * from './parametres-application.service'; diff --git a/frontend/src/app/core/services/parametres-application.service.ts b/frontend/src/app/core/services/parametres-application.service.ts new file mode 100644 index 0000000..0a8699e --- /dev/null +++ b/frontend/src/app/core/services/parametres-application.service.ts @@ -0,0 +1,39 @@ +import { HttpClient } from '@angular/common/http'; +import { Injectable, inject, signal } from '@angular/core'; +import { Observable } from 'rxjs'; +import { tap } from 'rxjs/operators'; + +import { environment } from '../../../environments/environment'; +import { ParametresApplication } from '../models'; + +/** + * Service HTTP des paramètres globaux de l'application. + * + * Porte le signal partagé `precisionDistance`, chargé une fois puis mis à jour après + * modification — mécanisme central de propagation de la précision d'arrondi des distances + * à toute l'application (liste des trajets, totaux, carte, PDF, barème). + */ +@Injectable({ providedIn: 'root' }) +export class ParametresApplicationService { + private readonly http = inject(HttpClient); + private readonly baseUrl = environment.apiUrl; + + /** Précision courante (0, 1 ou 2), partagée par toute l'application. Défaut 2 avant premier chargement. */ + readonly precisionDistance = signal<0 | 1 | 2>(2); + + /** Charge la précision courante depuis le backend et met à jour le signal partagé (GET /api/parametres-application). */ + charger(): Observable { + return this.http.get(`${this.baseUrl}/parametres-application`).pipe( + tap((p) => this.precisionDistance.set(p.precisionDistanceKm as 0 | 1 | 2)) + ); + } + + /** Modifie la précision et met à jour le signal partagé en cas de succès (PUT /api/parametres-application). */ + definirPrecisionDistance(valeur: 0 | 1 | 2): Observable { + return this.http + .put(`${this.baseUrl}/parametres-application`, { + precisionDistanceKm: valeur + }) + .pipe(tap((p) => this.precisionDistance.set(p.precisionDistanceKm as 0 | 1 | 2))); + } +} diff --git a/frontend/src/app/features/carte-trajets/carte-trajets.component.ts b/frontend/src/app/features/carte-trajets/carte-trajets.component.ts index ece3aac..2e75e9d 100644 --- a/frontend/src/app/features/carte-trajets/carte-trajets.component.ts +++ b/frontend/src/app/features/carte-trajets/carte-trajets.component.ts @@ -17,6 +17,7 @@ import { Subscription } from 'rxjs'; import { TrajetCarte } from '../../core/models'; import { TrajetService } from '../../core/services'; +import { ParametresApplicationService } from '../../core/services/parametres-application.service'; /** * Palette de couleurs distinctes attribuée aux tracés successifs d'une journée. @@ -72,6 +73,7 @@ type EtatCarte = 'chargement' | 'ok' | 'vide' | 'erreur'; export class CarteTrajetsComponent implements AfterViewInit, OnChanges, OnDestroy { private readonly trajetService = inject(TrajetService); private readonly cdr = inject(ChangeDetectorRef); + private readonly parametresService = inject(ParametresApplicationService); /** Date de la journée à visualiser, au format ISO (yyyy-MM-dd). */ @Input() date: string | null = null; @@ -419,7 +421,9 @@ export class CarteTrajetsComponent implements AfterViewInit, OnChanges, OnDestro */ private contenuInfobulle(trajet: TrajetCarte): string { const distanceBase = - trajet.distance != null ? `${trajet.distance.toFixed(2)} km` : 'distance non calculée'; + trajet.distance != null + ? `${trajet.distance.toFixed(this.parametresService.precisionDistance())} km` + : 'distance non calculée'; // Précise l'aller/retour après la distance (la distance affichée est déjà la // distance effective doublée côté API). const distance = trajet.allerRetour ? `${distanceBase} (A/R)` : distanceBase; diff --git a/frontend/src/app/features/montants-regles/montants-regles.component.ts b/frontend/src/app/features/montants-regles/montants-regles.component.ts index 3aff6de..66e5e1a 100644 --- a/frontend/src/app/features/montants-regles/montants-regles.component.ts +++ b/frontend/src/app/features/montants-regles/montants-regles.component.ts @@ -156,7 +156,7 @@ export class MontantsReglesComponent implements OnInit { } } previsionnels.forEach((p, index) => { - lignes[index].previsionnel = p ? p.montantPrevisionnel : null; + lignes[index].previsionnel = p ? p.montantPrevisionnelMensuel : null; }); this.lignes.set(lignes); }, diff --git a/frontend/src/app/features/panneau-totaux/panneau-totaux.component.html b/frontend/src/app/features/panneau-totaux/panneau-totaux.component.html index f518aaa..f70b0a3 100644 --- a/frontend/src/app/features/panneau-totaux/panneau-totaux.component.html +++ b/frontend/src/app/features/panneau-totaux/panneau-totaux.component.html @@ -8,15 +8,15 @@
Total du jour
-
{{ (totaux()?.totalJour ?? 0) | number: '1.2-2' }} km
+
{{ (totaux()?.totalJour ?? 0) | number: formatKm() }} km
Total du mois
-
{{ (totaux()?.totalMois ?? 0) | number: '1.2-2' }} km
+
{{ (totaux()?.totalMois ?? 0) | number: formatKm() }} km
Total annuel partiel
-
{{ (totaux()?.totalAnnuelPartiel ?? 0) | number: '1.2-2' }} km
+
{{ (totaux()?.totalAnnuelPartiel ?? 0) | number: formatKm() }} km
@@ -27,13 +27,28 @@ Indication de versement (80%) - {{ montantPrevisionnel.montantPrevisionnel | number: '1.2-2' }} € + {{ montantPrevisionnel.montantPrevisionnelMensuel | number: '1.2-2' }} €

- Simple indication de versement, calculée à 80% du barème sur le total - annuel partiel. Le montant réellement versé est le montant réglé que - vous saisissez. + Simple indication de versement, calculée à 80% du barème sur le mois + affiché. Le montant réellement versé est le montant réglé que vous + saisissez. +

+ +
+
+ + Montant prévisionnel annuel + + + {{ montantPrevisionnel.montantPrevisionnelAnnuel | number: '1.2-2' }} € + +
+

+ Projection à 100% du barème sur le total annuel partiel, sans + minoration. Cette projection ne se substitue pas au montant réel + calculé en fin d'année.

} diff --git a/frontend/src/app/features/panneau-totaux/panneau-totaux.component.ts b/frontend/src/app/features/panneau-totaux/panneau-totaux.component.ts index 509ea47..a4a4fc0 100644 --- a/frontend/src/app/features/panneau-totaux/panneau-totaux.component.ts +++ b/frontend/src/app/features/panneau-totaux/panneau-totaux.component.ts @@ -14,6 +14,7 @@ import { Subscription } from 'rxjs'; import { MontantPrevisionnel, Totaux } from '../../core/models'; import { BaremeService } from '../../core/services/bareme.service'; +import { ParametresApplicationService } from '../../core/services/parametres-application.service'; import { TrajetService } from '../../core/services/trajet.service'; /** @@ -22,18 +23,21 @@ import { TrajetService } from '../../core/services/trajet.service'; * * Reçoit en entrée une `date` (ISO `yyyy-MM-dd`) et un `vehiculeId`, puis affiche : * - le total du jour, le total du mois et le Total_Annuel_Partiel (cumul de - * l'année jusqu'au mois sélectionné inclus), tous à deux décimales - * (Exigences 12.7, 12.8) ; - * - le Montant_Previsionnel minoré à 80%, calculé sur le Total_Annuel_Partiel du - * véhicule sélectionné, présenté explicitement comme une simple indication de + * l'année jusqu'au mois sélectionné inclus), formatés dynamiquement selon la + * précision courante des distances (0, 1 ou 2 décimales — Exigences 5.4, 5.5) ; + * - le Montant_Previsionnel_Mensuel minoré à 80%, calculé sur le seul mois affiché + * du véhicule sélectionné, présenté explicitement comme une simple indication de * versement — le montant réellement versé étant le Montant_Regle saisi par - * l'utilisateur (Exigences 13.5, 13.6). Les montants sont exprimés en euros à - * deux décimales (Exigence 13.7). + * l'utilisateur (Exigences 13.5, 13.6) ; + * - le Montant_Previsionnel_Annuel, projection à 100% (sans minoration) sur le + * Total_Annuel_Partiel (Exigences 8.1, 8.3, 8.4). + * Les montants sont exprimés en euros à deux décimales, indépendamment de la + * précision des distances (Exigence 13.7, 8.4). * * Les totaux et le montant prévisionnel sont recalculés à chaque changement de * `date` ou de `vehiculeId` (recalcul au changement, sans rechargement complet). * - * _Requirements: 12.7, 12.8, 13.5, 13.6, 13.7, 13.8_ + * _Requirements: 5.4, 5.5, 8.1, 8.3, 8.4, 12.7, 12.8, 13.5, 13.6, 13.7, 13.8_ */ @Component({ selector: 'app-panneau-totaux', @@ -47,6 +51,7 @@ export class PanneauTotauxComponent implements OnChanges, OnDestroy { private readonly trajetService = inject(TrajetService); private readonly baremeService = inject(BaremeService); private readonly cdr = inject(ChangeDetectorRef); + readonly parametresService = inject(ParametresApplicationService); /** Date sélectionnée au format ISO (`yyyy-MM-dd`). */ @Input() date: string | null = null; @@ -140,6 +145,15 @@ export class PanneauTotauxComponent implements OnChanges, OnDestroy { }); } + /** + * Chaîne de format `number` (`1.{p}-{p}`) basée sur la précision courante des + * distances (0, 1 ou 2 décimales), pour un affichage dynamique des totaux en km. + */ + formatKm(): string { + const precision = this.parametresService.precisionDistance(); + return `1.${precision}-${precision}`; + } + /** Année (nombre) extraite d'une date ISO `yyyy-MM-dd`. */ private anneeDe(dateIso: string): number { return Number(dateIso.slice(0, 4)); diff --git a/frontend/src/app/features/parametrage/parametrage.component.html b/frontend/src/app/features/parametrage/parametrage.component.html index 384eaad..64bd9e7 100644 --- a/frontend/src/app/features/parametrage/parametrage.component.html +++ b/frontend/src/app/features/parametrage/parametrage.component.html @@ -10,6 +10,13 @@ > Compte + + Application + +

Application

+ +

Nombre de décimales des distances (km)

+ +
+ @for (valeur of precisionsDisponibles; track valeur) { + + } +
+ + @if (enregistrement()) { +

Enregistrement en cours…

+ } + +

+ L'arrondi appliqué aux distances est toujours supérieur (jamais vers le bas), quelle que + soit la précision choisie. +

+ diff --git a/frontend/src/app/features/parametres-application/parametres-application.component.scss b/frontend/src/app/features/parametres-application/parametres-application.component.scss new file mode 100644 index 0000000..e1cb6df --- /dev/null +++ b/frontend/src/app/features/parametres-application/parametres-application.component.scss @@ -0,0 +1,65 @@ +.parametres-application { + padding: 1.5rem; + max-width: 720px; + margin: 0 auto; +} + +h1 { + font-size: 1.4rem; + margin-bottom: 1rem; +} + +h2 { + font-size: 1.1rem; + margin: 1.5rem 0 0.75rem; +} + +.choix-precision { + display: flex; + gap: 0.75rem; +} + +.btn-precision { + padding: 0.55rem 1.25rem; + background: #fff; + color: var(--couleur-bleu); + border: 1px solid var(--couleur-bleu); + border-radius: 6px; + cursor: pointer; + font-size: 0.95rem; + min-width: 3rem; + + &:hover:not(:disabled) { + border-color: var(--couleur-orange); + color: var(--couleur-orange); + } +} + +.btn-precision--actif { + background: var(--couleur-bleu); + color: #fff; + border-color: var(--couleur-bleu); + + &:hover:not(:disabled) { + background: var(--couleur-orange); + border-color: var(--couleur-orange); + color: #fff; + } +} + +.btn-precision:disabled { + opacity: 0.55; + cursor: not-allowed; +} + +.enregistrement-en-cours { + margin-top: 0.75rem; + color: #777; + font-style: italic; +} + +.aide { + margin-top: 1rem; + color: #555; + font-size: 0.9rem; +} diff --git a/frontend/src/app/features/parametres-application/parametres-application.component.ts b/frontend/src/app/features/parametres-application/parametres-application.component.ts new file mode 100644 index 0000000..f3f3194 --- /dev/null +++ b/frontend/src/app/features/parametres-application/parametres-application.component.ts @@ -0,0 +1,63 @@ +import { CommonModule } from '@angular/common'; +import { Component, OnInit, inject, signal } from '@angular/core'; + +import { NotificationService } from '../../core/services/notification.service'; +import { ParametresApplicationService } from '../../core/services/parametres-application.service'; + +/** + * Paramétrage global de l'application : précision d'arrondi des distances (km). + * + * - Présélectionne la valeur courante au chargement (Exigence 2.3). + * - Applique le choix immédiatement (optimiste) puis confirme ou restaure/notifie + * en cas d'échec (Exigences 2.4, 2.5). + */ +@Component({ + selector: 'app-parametres-application', + standalone: true, + imports: [CommonModule], + templateUrl: './parametres-application.component.html', + styleUrl: './parametres-application.component.scss' +}) +export class ParametresApplicationComponent implements OnInit { + private readonly parametresService = inject(ParametresApplicationService); + private readonly notification = inject(NotificationService); + + /** Valeur sélectionnée (0, 1 ou 2 décimales). */ + readonly precisionSelectionnee = signal<0 | 1 | 2>(2); + + /** true pendant l'appel d'enregistrement. */ + readonly enregistrement = signal(false); + + /** Valeurs de précision proposées (0, 1 ou 2 décimales). */ + readonly precisionsDisponibles: readonly (0 | 1 | 2)[] = [0, 1, 2]; + + ngOnInit(): void { + this.precisionSelectionnee.set(this.parametresService.precisionDistance()); + } + + /** + * Sélectionne une nouvelle précision et l'enregistre côté serveur. + * Mise à jour optimiste du signal local, restaurée en cas d'échec (Exigence 2.5). + */ + choisir(valeur: 0 | 1 | 2): void { + if (valeur === this.precisionSelectionnee() || this.enregistrement()) { + return; + } + + const precedente = this.precisionSelectionnee(); + this.precisionSelectionnee.set(valeur); + this.enregistrement.set(true); + + this.parametresService.definirPrecisionDistance(valeur).subscribe({ + next: () => { + this.enregistrement.set(false); + this.notification.success('Précision des distances enregistrée.'); + }, + error: () => { + this.enregistrement.set(false); + this.precisionSelectionnee.set(precedente); + this.notification.error("La modification n'a pas pu être enregistrée."); + } + }); + } +} diff --git a/frontend/src/app/features/trajet-list/trajet-list.component.ts b/frontend/src/app/features/trajet-list/trajet-list.component.ts index 7fba7ca..928d356 100644 --- a/frontend/src/app/features/trajet-list/trajet-list.component.ts +++ b/frontend/src/app/features/trajet-list/trajet-list.component.ts @@ -16,6 +16,7 @@ import { import { ReordonnerTrajets, Trajet, TrajetPosition } from '../../core/models'; import { NotificationService } from '../../core/services/notification.service'; +import { ParametresApplicationService } from '../../core/services/parametres-application.service'; import { TrajetService } from '../../core/services/trajet.service'; import { ServeurIndisponibleError } from '../../core/interceptors/timeout.interceptor'; import { ConfirmDialogComponent } from '../../shared/components/confirm-dialog/confirm-dialog.component'; @@ -87,6 +88,7 @@ export interface GroupeJour { export class TrajetListComponent { private readonly trajetService = inject(TrajetService); private readonly notifications = inject(NotificationService); + private readonly parametresService = inject(ParametresApplicationService); /** * Trajets du mois. Ils sont regroupés par journée (`groupes`), chaque groupe @@ -295,12 +297,12 @@ export class TrajetListComponent { return index === groupe.trajets.length - 1; } - /** Distance formatée à 2 décimales, ou « — » si non calculée (Exigence 2.4). */ + /** Distance formatée selon la précision courante, ou « — » si non calculée (Exigence 2.4). */ distanceAffichee(trajet: Trajet): string { if (trajet.distance == null) { return '—'; } - return `${trajet.distance.toFixed(2)} km`; + return `${trajet.distance.toFixed(this.parametresService.precisionDistance())} km`; } /** Identité stable pour le suivi de la liste (drag & drop). */ diff --git a/frontend/src/app/shared/utils/arrondir-distance.ts b/frontend/src/app/shared/utils/arrondir-distance.ts new file mode 100644 index 0000000..3c4b7dc --- /dev/null +++ b/frontend/src/app/shared/utils/arrondir-distance.ts @@ -0,0 +1,21 @@ +/** + * Arrondit une distance brute (km) au supérieur (ceiling) à la précision donnée. + * Miroir exact de PrecisionDistanceService.ArrondirDistance côté backend. + */ +export function arrondirDistance(distanceBrute: number, precision: 0 | 1 | 2): number { + const facteur = Math.pow(10, precision); + return Math.ceil(distanceBrute * facteur) / facteur; +} + +/** Distance_Effective_Arrondie : arrondi de la distance simple PUIS doublement si aller/retour. */ +export function distanceEffectiveArrondie( + distanceBrute: number | null, + allerRetour: boolean, + precision: 0 | 1 | 2 +): number | null { + if (distanceBrute == null) { + return null; + } + const arrondie = arrondirDistance(distanceBrute, precision); + return allerRetour ? arrondie * 2 : arrondie; +}