MNP pour les préréservation, test simple et documentation

src/fr/iutfbleau/projetIHM2021FI2/MNP/ChambreNP.java

@@ -0,0 +1,76 @@
+package fr.iutfbleau.projetIHM2021FI2.MNP;
+import fr.iutfbleau.projetIHM2021FI2.API.*;
+import java.util.*;
+/**
+ * Une chambre non persistante toute bête
+ */
+
+public class ChambreNP implements Chambre{
+
+    private int numero;
+    private TypeChambre type;
+
+    /**
+     * Constructeur
+     */
+    public ChambreNP(int numero, TypeChambre t){
+        Objects.requireNonNull(t,"On ne peut pas créer une chambre avec un type de chambre à null.");
+        this.numero=numero;
+        this.type=t;
+    }
+
+    /**
+     * permet de récupérer le numéro de la chambre.
+     * @return le numéro.
+     */
+    public int getNumero(){
+        return this.numero;
+    }
+    
+
+    /**
+     * permet de savoir si la chambre a un seul lit qui est simple
+     * @return vrai si c'est le cas.
+     */
+    public boolean unLitSimple(){
+        //https://stackoverflow.com/questions/1750435/comparing-java-enum-members-or-equals
+        return (this.type == TypeChambre.UNLS);
+    }
+
+    /**
+     * permet de savoir si la chambre a deux lits simples
+     * @return vrai si c'est le cas.
+     */
+    public boolean deuxLitsSimples(){
+        return (this.type == TypeChambre.DEUXLS);
+    }
+
+    /**
+     * permet de savoir si la chambre a un lit double
+     * @return vrai si c'est le cas.
+     */
+    public boolean unLitDouble(){
+        return (this.type == TypeChambre.UNLD);
+    }
+
+
+    /**
+     * @return le type de chambre (un type énuméré de l'API)
+     *
+     * NB. Les trois méthodes ci-dessus sont assez moches.
+     * De toute façon Chambre ou Prérerservation exposent le type énuméré TypeChambre à la vue.
+     * Il est donc plus simple d'ajouter des types de chambre à ce type énuméré plutôt que d'ajouter des tests ici.
+     * Je laisse les méthodes obsolètes pour illustrer l'annotation <pre>@deprecated</pre> de la javadoc.
+     */
+    public TypeChambre getType(){
+        return this.type;
+    }
+
+    
+    // voir MonPrint dans l'interface Chambre
+    // @Override
+    // public String toString() {
+    //     return String.format("Chambre " + this.numero + " ("+ this.type +")");
+    // }
+    
+}

src/fr/iutfbleau/projetIHM2021FI2/MNP/ClientNP.java

@@ -2,7 +2,7 @@ package fr.iutfbleau.projetIHM2021FI2.MNP;
 import fr.iutfbleau.projetIHM2021FI2.API.*;
 import java.util.*;
 /**
- * Un client non persistent tout bête
+ * Un client non persistant tout bête
  */
 
 public class ClientNP implements Client {
@@ -14,9 +14,9 @@ public class ClientNP implements Client {
     /**
      * Constructeur
      */
-    public ClientNP(int id, String nom, String prenom){
+    public ClientNP(int id, String prenom, String nom){
         Objects.requireNonNull(nom,"On ne peut pas créer une personne avec un nom à null.");
-        Objects.requireNonNull(nom,"On ne peut pas créer une personne avec un prenom à null.");
+        Objects.requireNonNull(prenom,"On ne peut pas créer une personne avec un prenom à null.");
         this.id=id;
         this.nom=nom;
         this.prenom=prenom;
@@ -46,4 +46,9 @@ public class ClientNP implements Client {
         return this.prenom;
     }
 
+    // voir interface MonPrint
+    // @Override
+    // public String toString() {
+    //     return String.format("Nom " + this.nom + " Prenom " + this.prenom + " (id="+this.id+")");
+    // }
 }

src/fr/iutfbleau/projetIHM2021FI2/MNP/PrereservationFactoryNP.java

@@ -0,0 +1,97 @@
+package fr.iutfbleau.projetIHM2021FI2.MNP;
+import fr.iutfbleau.projetIHM2021FI2.API.*;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.function.Predicate;
+/**
+ *  Usine non persistante stockant les préréservation dans une structure de donnée permettant de simuler un ensemble.
+ * 
+ *  Elle permet de rechercher les préréservations à partir du numéro d'une préréservation, ou bien du nom et prenom d'un Client.
+ *
+ * La recherche par numéro devrait être plus efficace.
+ *
+ */
+public class PrereservationFactoryNP implements PrereservationFactory{
+    
+    // plutôt que d'utiliser un ensemble, on utilise un HashMap car on suppose qu'on va devoir chercher
+    // plutôt les préréservations avec le numéro de référence (un String, voir Prereservation).
+    // Pour la recherche par nom et prenom on va devoir traverser le HashMap.
+    private HashMap<String,Prereservation> brain =new HashMap<String,Prereservation>();//Creating HashMap    
+
+    // ceci n'est pas nécessaire (ce constructeur existe par défaut).
+    // /**
+    //  * Constructeur
+    //  */
+    // public PrereservationFactoryNP(){
+        
+    // }
+
+    /**
+     * Recherche une préréservation par reference
+     * @param  r la référence du système de préréservation 
+     * @return la préréservation.
+     * @throws NullPointerException si un argument est null
+     * @throws IllegalStateException si la Préréservation avec cette référence n'existe pas.
+     *
+     * Ne devrait pas retourner un objet null.
+     */
+    public Prereservation getPrereservation(String r){
+        Objects.requireNonNull(r,"La référence recherchée est null.");
+        if (this.brain.containsKey(r)){
+            return this.brain.get(r);
+        }
+        else {
+            throw new IllegalStateException("Il n'y a pas de préréservation avec la référence : " + r);
+        }
+    }
+    /**
+     * Recherche une préréservation par nom et prenom
+     * @param  n le nom
+     * @param  p le prenom
+     * @return un ensemble de préréservations.
+     * @throws NullPointerException si un argument est null
+     * @throws IllegalStateException si aucune préréservation n'existe avec ce nom
+     *
+     * Ne devrait pas retourner un objet null ou un ensemble vide.
+     */
+    public Set<Prereservation> getPrereservations(String n, String p){
+        Objects.requireNonNull(n,"Le nom recherché est null.");
+        Objects.requireNonNull(p,"Le prénom recherché est null.");
+        // on va extraire toutes les préréservations du cerveau
+        Collection<Prereservation> c = this.brain.values();
+        // on définit un prédicat sur les Préréservations :
+        Predicate<Prereservation> filtre = preresa -> !preresa.getClient().getNom().equals(n) || !preresa.getClient().getPrenom().equals(p);
+        // on filtre la collection.
+        c.removeIf(filtre);
+        if (c.isEmpty()){
+            throw new IllegalStateException("Il n'y a pas de préréservation avec un Client ayant pour nom et prenom : " + n + " et " + p);
+        }
+        // on fabrique un ensemble.
+        Set<Prereservation> found = new HashSet<Prereservation>(c);
+        return found;
+    }
+
+
+    // NB : jusqu'ici on ne dépend pas d'un choix particulier de Prereservation.
+    //      La méthode ci-dessous utilise (de manière très marginale) PrereservationNP
+    //      Elle assure que le cerveau (this.brain) contient au plus une prereservation pour une reference
+
+    /**
+     * Utile pour faire des tests avec cette classe.
+     * A priori ne sert pas si on fait une version persistante 
+     * @throws IllegalStateException si on connaît déjà une préréservation avec cette référence.
+     * @throws NullPointerException si un argument est null
+     * @throws IllegalArgumentException si jours < 1
+     */
+    public void ajoutePrereservation(String reference, LocalDate dateDebut, int jours, TypeChambre t, Client client){
+        if (this.brain.containsKey(reference)){
+            throw new IllegalStateException("Il y a déjà une préréservation avec cette référence : " + reference);
+        }
+        else {
+            Prereservation preresa = new PrereservationNP(reference, dateDebut, jours, t, client);
+            this.brain.put(reference,preresa);
+        }
+    }
+}
+ 
+ 

src/fr/iutfbleau/projetIHM2021FI2/MNP/PrereservationNP.java

@@ -0,0 +1,88 @@
+package fr.iutfbleau.projetIHM2021FI2.MNP;
+import fr.iutfbleau.projetIHM2021FI2.API.*;
+import java.time.LocalDate;
+import java.util.*;
+/**
+ * Une préréservation non persitante toute bête
+ * 
+ * e.g. utilisé par le système de réservation externe à l'hôtel.
+ * 
+ */
+
+public class PrereservationNP implements Prereservation {
+
+    private String reference;
+    private LocalDate dateDebut;
+    private int jours;
+    private TypeChambre type;
+    private Client client;
+
+    /**
+     * Constructeur
+     *
+     * NB. on force jours>0 et les autres attributs à ne pas être null
+     */
+    public PrereservationNP(String reference, LocalDate dateDebut, int jours, TypeChambre t, Client client){
+        Objects.requireNonNull(reference,"On ne peut pas créer une préréservation avec un reference à null.");
+        Objects.requireNonNull(dateDebut,"On ne peut pas créer une préréservation avec un date de début à null.");
+        if (jours<1) {
+            throw new IllegalArgumentException("On ne peut pas créer une réservation avec un nombre de jours négatif ou nul.");
+        }
+        Objects.requireNonNull(t,"On ne peut pas créer une préréservation avec un type de chambre à null.");
+        Objects.requireNonNull(client,"On ne peut pas créer une préréservation avec un client à null.");
+        this.reference=reference;
+        this.dateDebut=dateDebut;
+
+        this.jours=jours;
+        this.type=t;
+        this.client=client;
+    }
+
+    
+    /**
+     * permet de récupérer 
+     * @return la référence.
+     */
+    public String getReference(){
+        return this.reference;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return la date de début
+     *
+     * A priori seule la date est importante, le reste est sans importance.
+     */
+    public LocalDate getDateDebut(){
+        return this.dateDebut;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return la durée en jours (mais comme un entier)
+     */
+    public int getJours(){
+        return this.jours;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return le type de chambre
+     */
+    public TypeChambre getTypeChambre(){
+        return this.type;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return le client
+     */
+    public Client getClient(){
+        return this.client;
+    }
+
+    // @Override
+    // public String toString() {
+    //     return String.format("Préréservation " + this.reference + " au nom de " + this.client + " le " + + " pour " + this.jours + " nuit(s) à partir du " + this.dateDebut);
+    // }
+}

src/fr/iutfbleau/projetIHM2021FI2/MNP/ReservationNP.java

@@ -0,0 +1,87 @@
+package fr.iutfbleau.projetIHM2021FI2.MNP;
+import fr.iutfbleau.projetIHM2021FI2.API.*;
+import java.util.*;
+/**
+ * Une Réservation non presistante toute bête
+ * 
+ * e.g. utilisé par le système de réservation interne à l'hôtel.
+ * 
+ */
+
+public class ReservationNP implements Reservation {
+
+    private String reference;
+    private Date dateDebut;
+    private int jours;
+    private Chambre chambre;
+    private Client client;
+
+    /**
+     * Constructeur
+     *
+     * NB. on force jours>0 et les autres attributs à ne pas être null
+     */
+    public ReservationNP(String reference, Date dateDebut, int jours, Chambre chambre, Client client){
+        Objects.requireNonNull(reference,"On ne peut pas créer une réservation avec un reference à null.");
+        Objects.requireNonNull(dateDebut,"On ne peut pas créer une réservation avec un date de début à null.");
+        if (jours<1) {
+            throw new IllegalArgumentException("On ne peut pas créer une réservation avec un nombre de jours négatif ou nul.");
+        }
+        Objects.requireNonNull(chambre,"On ne peut pas créer une réservation avec une chambre à null.");
+        Objects.requireNonNull(client,"On ne peut pas créer une réservation avec un client à null.");
+        this.reference=reference;
+        this.dateDebut=dateDebut;
+
+        this.jours=jours;
+        this.chambre=chambre;
+        this.client=client;
+    }
+
+    
+    /**
+     * permet de récupérer 
+     * @return la référence.
+     */
+    public String getReference(){
+        return this.reference;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return la date de début
+     *
+     * A priori seule la date est importante, le reste est sans importance.
+     */
+    public Date getDateDebut(){
+        return this.dateDebut;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return la durée en jours (mais comme un entier)
+     */
+    public int getJours(){
+        return this.jours;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return le type de chambre
+     */
+    public Chambre getChambre(){
+        return this.chambre;
+    }
+
+    /**
+     * permet de récupérer 
+     * @return le client
+     */
+    public Client getClient(){
+        return this.client;
+    }
+}
+
+
+
+
+