Recap 4 : Anciens examens

public class SiegeController{
    public ReponseSiegeDto trouverMeilleursSiege(DemandeSiegeDto demande) {
        // 1−Créer la bonne classe dans le vol
        ClasseVol classeVol;
        if (demande.classeVol == "E") {
            classeVol = newClasseEconomie(volId);
            // Ignorez comment la classe obtient les sièges
            // pas important pour l’examen
        } else if (demande.classeVol == "A") {
            classeVol = newClasseAffaires(volId);
        } else {
            throw new RuntimeException("Classenonsupportée");
        }

        // 2−Trouver les siège
        List<Siege> siegesTrouves = classeVol.trouverMeilleursSieges(demande);

        // 3−Préparation de la réponse
        if (siegesTrouves.isEmpty()) {
            throw new PasDeSiegeTrouve();
        }
        return ReponseSiegeDto.from(siegesTrouves);
    }
}

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, Double> notesPondereeParEtudiant = new HashMap<>();

        for (Travail travail : travaux) {
            for (Remise remise : travail.getRemises()) {
                Etudiant etudiantRemise = remise.getEtudiant();

                double note = remise.getNote();
                double ponderation = travail.getPonderation();
                double notePonderee = note * ponderation;
                etudiantRemise.getDossier().inscrireResultatTravail(travail.getCode(),
                    notePonderee);

                // Pour l’etudiant ayant soumis cette remise, on cummule ses notes
                // totales de tous les travaux dans une grande
                // Map d "Etudiant => Note_commulee"
                notesPondereeParEtudiant.merge(etudiantRemise, notePonderee, (x, y) -> x + y);
            }
        }

        // Pour chaque etudiant, il faut fixer sa cote a partir
        // de la somme des notes ponderees de tous ses travaux remis
        for (Etudiant etudiant : etudiantsInscrits) {
            double total = notesPondereeParEtudiant.getOrDefault(etudiant, 0.0);
            etudiant.getDossier().fixerCote(total);
        }
    }
}

class Travail {

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

    Travail(String code, double 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 double getPonderation() {
        return ponderation;
    }
}

class Remise {

    private double note;
    private Etudiant etudiant;

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

    public double getNote() {
        return note;
    }

    public Etudiant getEtudiant() {
        return etudiant;
    }
}

class Etudiant {

    private String ni;
    private DossierEtudiantElectronique dossier;

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

    public String getNI() {
        return ni;
    }

    public DossierEtudiantElectronique getDossier() {
        return dossier;
    }
}

interface DossierEtudiantElectronique {
    public void inscrireResultatTravail(String code, double notePonderee);
    public void fixerCote(double noteFinale);
    public void publier();
}

class Registraire {
    private List<DossierEtudiantElectronique> etudiants = new ArrayList<>();

    public void publierCotes() {
        for (DossierEtudiantElectronique dossierEtudiant : etudiants) {
            dossierEtudiant.publier();
        }
    }
}