Du diagramme de classes au code C#, et rétro-conception

// EtatFiche.cs
namespace AppliFrais.Modele;

// «enumeration» EtatFiche : la base stocke CR, CL, VA, MP, RB
public enum EtatFiche { Creee, Cloturee, Validee, MiseEnPaiement, Remboursee }

// IExportable.cs
public interface IExportable
{
    string VersCsv();
}

// Utilisateur.cs
public abstract class Utilisateur
{
    public int Id { get; }
    public string Nom { get; }
    public string Prenom { get; }
    public string Login { get; }

    protected Utilisateur(int id, string nom, string prenom, string login)
    {
        Id = id;
        Nom = nom;
        Prenom = prenom;
        Login = login;
    }

    public string NomComplet => $"{Prenom} {Nom}";

    public abstract string Role { get; }
}

// Visiteur.cs
public class Visiteur : Utilisateur
{
    private readonly List<FicheFrais> fiches = [];

    public DateOnly DateEmbauche { get; }
    public Region Region { get; private set; }            // agrégation : 1 côté Region
    public IReadOnlyList<FicheFrais> Fiches => fiches;    // association « remplit » : 0..*

    public Visiteur(int id, string nom, string prenom, string login, DateOnly dateEmbauche, Region region)
        : base(id, nom, prenom, login)
    {
        DateEmbauche = dateEmbauche;
        Region = region;
        region.Ajouter(this);                             // les deux côtés restent cohérents
    }

    public override string Role => "visiteur médical";

    public FicheFrais OuvrirFiche(string mois)
    {
        var fiche = new FicheFrais(mois, this);
        fiches.Add(fiche);
        return fiche;
    }
}

// Comptable.cs
public class Comptable : Utilisateur
{
    public Comptable(int id, string nom, string prenom, string login)
        : base(id, nom, prenom, login) { }

    public override string Role => "comptable";
}

// Region.cs
public class Region
{
    private readonly List<Visiteur> visiteurs = [];

    public string Code { get; }
    public string Libelle { get; }
    public IReadOnlyList<Visiteur> Visiteurs => visiteurs;

    public Region(string code, string libelle)
    {
        Code = code;
        Libelle = libelle;
    }

    public void Ajouter(Visiteur visiteur) => visiteurs.Add(visiteur);
}

// FraisForfait.cs
public class FraisForfait
{
    public string Id { get; }          // ETP, KM, NUI, REP
    public string Libelle { get; }
    public decimal Montant { get; }

    public FraisForfait(string id, string libelle, decimal montant)
    {
        Id = id;
        Libelle = libelle;
        Montant = montant;
    }
}

// LigneFraisForfait.cs
public class LigneFraisForfait
{
    public FicheFrais Fiche { get; }
    public FraisForfait Frais { get; }

    public int Quantite
    {
        get;
        set => field = value >= 0
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "La quantité ne peut pas être négative.");
    }

    public LigneFraisForfait(FicheFrais fiche, FraisForfait frais, int quantite)
    {
        Fiche = fiche;
        Frais = frais;
        Quantite = quantite;
    }

    public decimal Montant() => Quantite * Frais.Montant;
}

// LigneFraisHorsForfait.cs
public class LigneFraisHorsForfait
{
    public DateOnly Date { get; }
    public string Libelle { get; }
    public decimal Montant { get; }
    public bool Refuse { get; private set; }
    public string? MotifRefus { get; private set; }

    internal LigneFraisHorsForfait(DateOnly date, string libelle, decimal montant)
    {
        Date = date;
        Libelle = libelle;
        Montant = montant;
    }

    public void Refuser(string motif)
    {
        Refuse = true;
        MotifRefus = motif;
    }
}

// FicheFrais.cs
using System.Globalization;

public class FicheFrais : IExportable
{
    private readonly List<LigneFraisForfait> lignesForfait = [];
    private readonly List<LigneFraisHorsForfait> lignesHorsForfait = [];

    public string Mois { get; }
    public Visiteur Visiteur { get; }
    public EtatFiche Etat { get; private set; } = EtatFiche.Creee;
    public decimal? MontantValide { get; private set; }
    public Comptable? ValideePar { get; private set; }
    public IReadOnlyList<LigneFraisForfait> LignesForfait => lignesForfait;
    public IReadOnlyList<LigneFraisHorsForfait> LignesHorsForfait => lignesHorsForfait;

    public FicheFrais(string mois, Visiteur visiteur)
    {
        Mois = mois;
        Visiteur = visiteur;
    }

    public void SaisirForfait(FraisForfait frais, int quantite)
    {
        VerifierEtat(EtatFiche.Creee);
        LigneFraisForfait? ligne = lignesForfait.Find(l => l.Frais == frais);
        if (ligne is null) lignesForfait.Add(new LigneFraisForfait(this, frais, quantite));
        else ligne.Quantite = quantite;              // une seule ligne par forfait
    }

    public LigneFraisHorsForfait AjouterHorsForfait(DateOnly date, string libelle, decimal montant)
    {
        VerifierEtat(EtatFiche.Creee);
        var ligne = new LigneFraisHorsForfait(date, libelle, montant);
        lignesHorsForfait.Add(ligne);
        return ligne;
    }

    public decimal TotalForfait() => lignesForfait.Sum(l => l.Montant());

    public decimal TotalHorsForfait() => lignesHorsForfait.Where(l => !l.Refuse).Sum(l => l.Montant);

    public decimal Total() => TotalForfait() + TotalHorsForfait();

    public void Cloturer()
    {
        VerifierEtat(EtatFiche.Creee);
        Etat = EtatFiche.Cloturee;
    }

    public void Valider(Comptable comptable)
    {
        VerifierEtat(EtatFiche.Cloturee);
        MontantValide = Total();
        ValideePar = comptable;
        Etat = EtatFiche.Validee;
    }

    public void MettreEnPaiement()
    {
        VerifierEtat(EtatFiche.Validee);
        Etat = EtatFiche.MiseEnPaiement;
    }

    public void ConfirmerRemboursement()
    {
        VerifierEtat(EtatFiche.MiseEnPaiement);
        Etat = EtatFiche.Remboursee;
    }

    public string VersCsv() =>
        string.Join(";", Visiteur.Id, Mois, Etat, Total().ToString(CultureInfo.InvariantCulture));

    private void VerifierEtat(EtatFiche attendu)
    {
        if (Etat != attendu)
            throw new InvalidOperationException($"La fiche {Mois} est à l'état {Etat}, l'état {attendu} est attendu.");
    }
}

// Program.cs
var ouest = new Region("OUE", "Ouest");
var lucas = new Visiteur(7, "Moreau", "Lucas", "lmoreau", new DateOnly(2021, 9, 1), ouest);
var ines = new Comptable(2, "Fabre", "Inès", "ifabre");

var etape = new FraisForfait("ETP", "Forfait étape", 110.00m);
var km = new FraisForfait("KM", "Frais kilométrique", 0.62m);
var nuitee = new FraisForfait("NUI", "Nuitée hôtel", 80.00m);
var repas = new FraisForfait("REP", "Repas restaurant", 25.00m);

FicheFrais fiche = lucas.OuvrirFiche("2026-11");
fiche.SaisirForfait(etape, 18);
fiche.SaisirForfait(km, 412);
fiche.SaisirForfait(nuitee, 3);
fiche.SaisirForfait(repas, 12);
fiche.AjouterHorsForfait(new DateOnly(2026, 11, 5), "Taxi gare - hôtel", 23.40m);
fiche.AjouterHorsForfait(new DateOnly(2026, 11, 12), "Repas avec un praticien", 48.50m);
LigneFraisHorsForfait cadeau = fiche.AjouterHorsForfait(new DateOnly(2026, 11, 19), "Cadeau à un praticien", 60.00m);

Console.WriteLine($"Forfait : {fiche.TotalForfait()} ; hors forfait : {fiche.TotalHorsForfait()} ; total : {fiche.Total()}");

try { fiche.Valider(ines); }
catch (InvalidOperationException e) { Console.WriteLine($"Erreur : {e.Message}"); }

fiche.Cloturer();
cadeau.Refuser("Cadeau interdit");
fiche.Valider(ines);
Console.WriteLine($"État : {fiche.Etat}, montant validé : {fiche.MontantValide}, par {fiche.ValideePar?.NomComplet}");

List<Utilisateur> utilisateurs = [lucas, ines];
foreach (Utilisateur u in utilisateurs) Console.WriteLine($"{u.NomComplet} : {u.Role}");

Forfait : 2775,44 ; hors forfait : 131,90 ; total : 2907,34
Erreur : La fiche 2026-11 est à l'état Creee, l'état Cloturee est attendu.
État : Validee, montant validé : 2847,34, par Inès Fabre
Lucas Moreau : visiteur médical
Inès Fabre : comptable

public decimal TotalValide(string mois)
{
    decimal total = 0;
    foreach (Visiteur visiteur in visiteurs)
    {
        foreach (FicheFrais fiche in visiteur.Fiches)
        {
            if (fiche.Mois == mois && fiche.MontantValide is not null)
            {
                total += fiche.MontantValide.Value;
            }
        }
    }
    return total;
}