Recap 4 : Anciens examens

public class GroupeClasse {
    private List<Travail> travaux = new ArrayList<>();
    private List<Etudiant> etudiantsInscrits = new ArrayList<>();

    public void ajouterTravail(Travail travail) {
        this.travaux.add(travail);
    }

    public void inscrireEtudiant(Etudiant etudiant) {
        etudiantsInscrits.add(etudiant);
    }

    /*
     * 1. Pour tous les travaux > Pour tous les etudiants ayant remis
     *   > Inscrire son resultat a son dossier
     *   Le resultat est pondere ( % que vaut le travail)
     *   > Rien inscrire si pas remis
     * 2. Une fois tous resultats inscrits aux dossiers
     * > On fixe la cote en fonction de la note
     *   totale de tous les travaux (sommes des notes ponderees)
     */
    public void publierNotes() {
        if (travaux.size() == 0) {
            return;
        }

        Map<Etudiant, Note> notesPondereeParEtudiant = new HashMap<>();
        for (Travail travail : travaux) {
            travail.comptabiliserNotesPonderees().forEach((etudiant, notePondereeTravail) ->
                    notesPondereeParEtudiant.merge(etudiant, notePondereeTravail, Note::ajouter)
            );
        }

        for (Etudiant etudiant : etudiantsInscrits) {
            etudiant.fixerCote(notesPondereeParEtudiant.getOrDefault(etudiant, new Note(0.0)));
        }
    }
}

public class Travail {

    private String code;
    private Map<Etudiant, Remise> remises = new HashMap<>();
    private Ponderation ponderation;

    Travail(String code, Ponderation ponderation) {
        this.code = code;
        this.ponderation = ponderation;
    }

    public List<Remise> getRemises() {
        return new ArrayList<>(remises.values());
    }

    public void addRemise(Remise remise) {
        remises.put(remise.getEtudiant(), remise);
    }

    public String getCode() {
        return code;
    }

    public Ponderation getPonderation() {
        return ponderation;
    }

    public Map<Etudiant, Note> comptabiliserNotesPonderees() {
        Map<Etudiant, Note> notes = new HashMap<>();
        this.remises.forEach((etudiant, remise) -> {
            var notePonderee = remise.getNotePondereeDuTravail(ponderation);
            etudiant.inscrireResultatDuTravail(this, notePonderee);
            notes.put(etudiant, notePonderee);
        });
        return notes;
    }
}

public class Remise {

    private Note note;
    private Etudiant etudiant;

    Remise(Note note, Etudiant etudiant) {
        this.note = note;
        this.etudiant = etudiant;
    }

    public Note getNote() {
        return note;
    }

    public Etudiant getEtudiant() {
        return etudiant;
    }

    public Note getNotePondereeDuTravail(Ponderation ponderation) {
        return note.ponderee(ponderation);
    }
}

public class Etudiant {

    private NumeroIdentification ni;
    private DossierEtudiantElectronique dossier;

    public Etudiant(NumeroIdentification ni, DossierEtudiantElectronique dossier) {
        this.ni = ni;
        this.dossier = dossier;
    }

    public NumeroIdentification getNI() {
        return ni;
    }

    public DossierEtudiantElectronique getDossier() {
        return dossier;
    }

    public void inscrireResultatDuTravail(Travail travail, Note notePonderee) {
        dossier.inscrireResultatTravail(travail.getCode(), notePonderee);
    }

    public void fixerCote(Note total) {
        dossier.fixerCote(total.note());
    }
}

// DossierEtudiantElectronique est resté identique
// Registraire est resté identique

public record Note(double note) {
    public Note {
        if (note < 0 || note > 100) {
            throw new IllegalArgumentException("La pondération doit être entre 0 et 100");
        }
    }

    public Note ponderee(Ponderation p) {
        return new Note(this.note * p.ponderation());
    }

    public Note ajouter(Note autre) {
        return new Note(this.note + autre.note());
    }
}

public record Ponderation(double ponderation) {
    public Ponderation {
        if (ponderation < 0 || ponderation > 1) {
            throw new IllegalArgumentException("La pondération doit être entre 0 et 1");
        }
    }
}

public record NumeroIdentification(String numeroIdentification) {
    public NumeroIdentification {
        if (numeroIdentification == null || numeroIdentification.isEmpty()) {
            throw new IllegalArgumentException("Laval University ID cannot be empty");
        }
        if (!matches("^[a-zA-Z]{5}($|([1-9]\\d{0,2})$)", numeroIdentification)) {
            throw new IllegalArgumentException(
                    "%s is not a valid Laval University ID (expected 5 letters followed by at most 3 digits)"
                            .formatted(numeroIdentification)
            );
        }
    }
}