java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalArgumentException - si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
Test si le groupe g est connu de l'usine (connu maintenant).
+ Si la réponse est true, les méthodes avec ce groupe en paramètre devraient bien fonctionner.
+ Si la réponse est false, le comportement n'est pas garanti.
permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
+ Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
+
+
Throws:
+
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalStateException - si le groupe contient des groupes
+
java.lang.IllegalArgumentException - si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
void createPartition(Groupe pere,
+ java.lang.String name,
+ int n)
+
permet de créer une partition automatiquement sous un groupe donné.
+
+
Parameters:
+
pere - le groupe père du groupe à partitionner
+
name - le nom des groupe à créer (on ajoutera à la suite un numéro ou une lettre pour distinguer chaque groupe)
+
n - le nombre de partitions
+
Throws:
+
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalArgumentException - si le groupe pere est de type PARTITION
+ ou n négatif ou nul
+
+ NB. doit créer une "copie" de pere
+ sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
+ les valeurs min et max de ces n groupes sont
+ min = 0 et
+ max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
permet de retrouver un étudiant à partir d'un String.
+
+ NB. dans une version simple il doit s'agir du nom exact.
+ dans une version un peu plus complexe, il s'agit des premières lettres du nom
+ dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
+
+
Parameters:
+
String - nomEtu le nom approximmatif de l'étudiant
+
Returns:
+
Set l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
+
Throws:
+
java.lang.NullPointerException - si le String est null.
Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
+ Toutes nos interfaces vont étendre cette interface.
Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
+ Toutes nos interfaces vont étendre cette interface.
Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
+ Toutes nos interfaces vont étendre cette interface.
Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
+ Toutes nos interfaces vont étendre cette interface.
Returns an array containing the constants of this enum type, in
+the order they are declared. This method may be used to iterate
+over the constants as follows:
+
+for (TypeGroupe c : TypeGroupe.values())
+ System.out.println(c);
+
+
+
Returns:
+
an array containing the constants of this enum type, in the order they are declared
public static TypeGroupe valueOf(java.lang.String name)
+
Returns the enum constant of this type with the specified name.
+The string must match exactly an identifier used to declare an
+enum constant in this type. (Extraneous whitespace characters are
+not permitted.)
+
+
Parameters:
+
name - the name of the enum constant to be returned.
+
Returns:
+
the enum constant with the specified name
+
Throws:
+
java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
+
java.lang.NullPointerException - if the argument is null
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalStateException - si le changement n'a pas de sens en l'état actuel (e.g. étudiant pas dans le groupe de départ a, groupe b inconnu, groupe a inconnu, etc).
+
java.lang.IllegalArgumentException - si inconnu de l'usine abstraite
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalArgumentException - si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
+ Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalStateException - si le groupe contient des groupes
+
java.lang.IllegalArgumentException - si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
name - le nom des groupe à créer (on ajoute à la suite un numéro de 1 à n pour distinguer chaque groupe formant la partition)
+
n - le nombre de partitions
+
Throws:
+
java.lang.NullPointerException - si un argument est null
+
java.lang.IllegalArgumentException - si le groupe pere est de type PARTITION
+ ou n négatif ou nul
+
+ NB. doit créer une "copie" de pere
+ sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
+ les valeurs min et max de ces n groupes sont
+ min = 0 et
+ max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
public java.util.Set<Etudiant> getEtudiants(java.lang.String nomEtu)
+
permet de retrouver un étudiant à partir d'un String.
+
+ NB. dans une version simple il doit s'agir du nom exact.
+ dans une version un peu plus complexe, il s'agit des premières lettres du nom
+ dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
public class ChangementNP
+extends java.lang.Object
+implements Changement
+
Une demande de changement de groupe
+ concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
+
+ Implémentation non persistante fournie avec l'API.
Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
+
+
+
+
GroupeNP(Groupe pere,
+ java.lang.String name,
+ int min,
+ int max)
+
Nouveau groupe vide de type FREE sans étudiants, sans sous-Groupe
+
+
+
+
GroupeNP(java.lang.String name,
+ int min,
+ int max)
+
Nouveau groupe vide de type ROOT sans étudiants, sans sous-Groupe
Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
BFrame(java.lang.String titlee,
+ int size_x,
+ int size_y,
+ int oC)
+
Avec le titre, la taille (en L et l) et mode de fermeture.
+
+
+
+
BFrame(java.lang.String title,
+ int loca_x,
+ int loca_y,
+ int size_x,
+ int size_y,
+ int oC)
+
Avec le titre, la locasation (en x et y), la taille (en L et l) et mode de
+ fermeture.
+
+
+
+
BFrame(java.lang.String title,
+ int loca_x,
+ int loca_y,
+ int size_x,
+ int size_y,
+ java.lang.String layout,
+ int layout_row,
+ int layout_col,
+ int oC)
+
Avec le titre, la locasation (en x et y), la taille (en L et l), le layout et
+ le mode de fermeture.
public BFrame(java.lang.String title,
+ int loca_x,
+ int loca_y,
+ int size_x,
+ int size_y,
+ java.lang.String layout,
+ int layout_row,
+ int layout_col,
+ int oC)
+
Avec le titre, la locasation (en x et y), la taille (en L et l), le layout et
+ le mode de fermeture.
+
+
Parameters:
+
title - Le titre de la fenetre
+
loca_x - La localisation en x de la fenetre
+
loca_y - La localisation en y de la fenetre
+
size_x - La longueur de la fenetre
+
size_y - La largeur de la fenetre
+
layout - Layout a utiliser dispo : GridBagLayout / GridLayout
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+
+
+
+
+
Overview
+
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
+
+
+
Package
+
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
+
+
Interfaces (italic)
+
Classes
+
Enums
+
Exceptions
+
Errors
+
Annotation Types
+
+
+
+
Class/Interface
+
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
+
+
Class inheritance diagram
+
Direct Subclasses
+
All Known Subinterfaces
+
All Known Implementing Classes
+
Class/interface declaration
+
Class/interface description
+
+
+
Nested Class Summary
+
Field Summary
+
Constructor Summary
+
Method Summary
+
+
+
Field Detail
+
Constructor Detail
+
Method Detail
+
+
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
+
+
+
Annotation Type
+
Each annotation type has its own separate page with the following sections:
+
+
Annotation Type declaration
+
Annotation Type description
+
Required Element Summary
+
Optional Element Summary
+
Element Detail
+
+
+
+
Enum
+
Each enum has its own separate page with the following sections:
+
+
Enum declaration
+
Enum description
+
Enum Constant Summary
+
Enum Constant Detail
+
+
+
+
Tree (Class Hierarchy)
+
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
+
+
When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
+
When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
+
+
+
+
Deprecated API
+
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
+
+
+
Index
+
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
+
+
+
Prev/Next
+
These links take you to the next or previous class, interface, package, or related page.
+
+
+
Frames/No Frames
+
These links show and hide the HTML frames. All pages are available with or without frames.
+
+
+
All Classes
+
The All Classes link shows all classes and interfaces except non-static nested types.
+
+
+
Serialized Form
+
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
+ * NB. Attention. C'était Iterator dans la version beta.
+ */
+ public Set getAllChangements();
+
+ /**
+ * permet de mettre en oeuvre un changement connu de l'usine abstraite.
+ * En cas de succès, le changement est oublié (détruit).
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
+ */
+ public void applyChangement(Changement c);
+
+ /**
+ * permet de supprimer un changement connu de l'usine abstraite.
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
+ */
+ public void deleteChangement(Changement c);
+
+ /**
+ * permet d'ajouter un nouveau changement.
+ *
+ * @param A groupe actuel
+ * @param B groupe demandé
+ * @param e étudiant concerné par le changement
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
+ */
+ public void createChangement(Groupe A, Etudiant e, Groupe B);
+
+}
diff --git a/src/API/AbstractGroupeFactory.java b/src/API/AbstractGroupeFactory.java
new file mode 100644
index 0000000..9cf4962
--- /dev/null
+++ b/src/API/AbstractGroupeFactory.java
@@ -0,0 +1,112 @@
+package API;
+
+import java.util.*;
+
+/**
+ * Usine abstraite gérant l'ensemble des groupes.
+ */
+
+public interface AbstractGroupeFactory {
+
+ /**
+ * permet de récupérer le Groupe qui contient les étudiants de toute la promotion
+ *
+ * @return la promo.
+ */
+ public Groupe getPromotion();
+
+
+ /**
+ * Test si le groupe g est connu de l'usine (connu maintenant).
+ * Si la réponse est true, les méthodes avec ce groupe en paramètre devraient bien fonctionner.
+ * Si la réponse est false, le comportement n'est pas garanti.
+ */
+ public Boolean knows(Groupe g);
+
+
+ /**
+ * permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
+ * Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalStateException si le groupe contient des groupes
+ * @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
+ */
+ public void deleteGroupe(Groupe g);
+
+ /**
+ * permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
+ *
+ * @param pere le groupe père du groupe à créer
+ * @param name le nom du groupe à créer
+ * @param min,max bornes indicatives sur la taille du groupe à créer
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
+ * ou si il n'y a pas 0 < min <= max
+ */
+ public void createGroupe(Groupe pere, String name, int min, int max);
+
+ /**
+ * permet de créer une partition automatiquement sous un groupe donné.
+ *
+ * @param pere le groupe père du groupe à partitionner
+ * @param name le nom des groupe à créer (on ajoutera à la suite un numéro ou une lettre pour distinguer chaque groupe)
+ * @param n le nombre de partitions
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
+ * ou n négatif ou nul
+ *
+ * NB. doit créer une "copie" de pere
+ * sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
+ * les valeurs min et max de ces n groupes sont
+ * min = 0 et
+ * max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
+ */
+ public void createPartition(Groupe pere, String name, int n);
+
+ /**
+ * permet d'ajouter un étudiant à un groupe.
+ *
+ * @param g le groupe dans lequel il faut ajouter l'étudiant
+ * @param e l'étudiant à ajouter
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException la factory ne connaît pas g
+ * @throws java.lang.IllegalStateException le père de g ne contient pas e
+ */
+ public void addToGroupe(Groupe g, Etudiant e);
+
+ /**
+ * permet d'enlever un étudiant d'un groupe.
+ *
+ * @param g le groupe dans lequel il faut enlever l'étudiant
+ * @param e l'étudiant à enlever
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalStateException g ne contient pas e
+ * @throws java.lang.IllegalArgumentException la factory ne connaît pas g
+ */
+ public void dropFromGroupe(Groupe g, Etudiant e);
+
+ /**
+ * permet de retrouver un étudiant à partir d'un String.
+ *
+ * NB. dans une version simple il doit s'agir du nom exact.
+ * dans une version un peu plus complexe, il s'agit des premières lettres du nom
+ * dans une version avancée, on peut autoriser une expression régulière plus ou moins complexe qui est générée si la première recherche n'a pas renvoyé de candidat.
+ *
+ * @param String nomEtu le nom approximmatif de l'étudiant
+ * @return Set l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
+ * @throws java.lang.NullPointerException si le String est null.
+ */
+ public Set getEtudiants(String nomEtu);
+
+ /**
+ * permet de retrouver les groupes d'un étudiant.
+ *
+ * @param Etu un étudiant
+ * @return Etudiant l'étudiant connu de la factory ayant cet identifiant
+ * @throws java.lang.NullPointerException si le String est null.
+ */
+ public Set getGroupesOfEtudiant(Etudiant etu);
+
+
+}
diff --git a/src/API/Changement.java b/src/API/Changement.java
new file mode 100644
index 0000000..81d1070
--- /dev/null
+++ b/src/API/Changement.java
@@ -0,0 +1,52 @@
+package API;
+
+import java.util.*;
+
+/**
+ * Une demande de changement de groupe
+ * concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
+ */
+public interface Changement extends MonPrint {
+
+ /**
+ * permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
+ *
+ * @return l'identifiant.
+ */
+ public int getId();
+
+ /**
+ * permet de récupérer le groupe de depart
+ *
+ * @return ce groupe.
+ */
+ public Groupe getA();
+
+ /**
+ * permet de récupérer le groupe d'arrivée
+ *
+ * @return ce groupe.
+ */
+ public Groupe getB();
+
+ /**
+ * permet de récupérer l'étudiant demandant le changement
+ *
+ * @return cet étudiant
+ */
+ public Etudiant getEtu();
+
+
+ /**
+ * @see MonPrint
+ * NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
+ *
+ * NB2. On ne peut pas utiliser le toString de Objects
+ * https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
+ */
+ public default String monPrint() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("Changement de " + this.getEtu().monPrint() + " depuis le groupe " + this.getA().getName() + " vers le groupe " + this.getB().getName());
+ return sb.toString();
+ }
+}
diff --git a/src/API/Etudiant.java b/src/API/Etudiant.java
new file mode 100644
index 0000000..b529441
--- /dev/null
+++ b/src/API/Etudiant.java
@@ -0,0 +1,44 @@
+package API;
+
+/**
+ * Un étudiant
+ */
+
+public interface Etudiant extends MonPrint {
+
+ /**
+ * permet de récupérer l'identifiant de l'étudiant.
+ *
+ * @return l'identifiant.
+ */
+ public int getId();
+
+ /**
+ * permet de récupérer
+ *
+ * @return le nom de l'étudiant.
+ */
+ public String getNom();
+
+ /**
+ * permet de récupérer
+ *
+ * @return le prénom de l'étudiant
+ */
+ public String getPrenom();
+
+ /**
+ * Ajout de l'equipe pour recuperer son groupe
+ *
+ * @return Le groupe en entier
+ * */
+ public int getGroupe();
+
+ /**
+ * @see MonPrint
+ * NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
+ */
+ public default String monPrint() {
+ return String.format("Nom " + getNom() + " Prenom " + getPrenom() + " Groupe " + getGroupe() + " (id=" + getId() + ")");
+ }
+}
diff --git a/src/API/Groupe.java b/src/API/Groupe.java
new file mode 100644
index 0000000..486f2ee
--- /dev/null
+++ b/src/API/Groupe.java
@@ -0,0 +1,131 @@
+package API;
+
+import java.util.*;
+
+/**
+ * Un groupe
+ */
+
+public interface Groupe extends MonPrint {
+ /**
+ * Ajoute un étudiant. Se comporte comme add de l'interface Set.
+ *
+ * @return true iff e est ajouté
+ */
+ public boolean addEtudiant(Etudiant e);
+
+ /**
+ * Enlève un étudiant. Se comporte comme remove de l'interface Set.
+ *
+ * @return true iff e est enlevé
+ */
+ boolean removeEtudiant(Etudiant e);
+
+ /**
+ * Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
+ * vérifie que le groupe passé en argument a bien renseigné this comme son père.
+ *
+ * @return true iff g est ajouté
+ */
+ public boolean addSousGroupe(Groupe g);
+
+ /**
+ * Enlève un groupe. Se comporte comme remove de l'interface Set.
+ *
+ * @return true iff e est enlevé
+ */
+ public boolean removeSousGroupe(Groupe g);
+
+ /**
+ * permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
+ *
+ * @return l'identifiant.
+ */
+ public int getId();
+
+ /**
+ * permet de récupérer le nom d'un groupe (utile irl).
+ *
+ * @return le nom.
+ */
+ public String getName();
+
+ /**
+ * permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
+ *
+ * @return le minimum souhaité
+ */
+ public int getMin();
+
+ /**
+ * permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
+ *
+ * @return le maximum souhaité
+ */
+ public int getMax();
+
+ /**
+ * permet de récupérer le nombre d'étudiants dans ce groupe.
+ *
+ * @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
+ */
+ public int getSize();
+
+ /**
+ * permet de récupérer la nature du groupe
+ *
+ * @return le type du groupe
+ */
+ public TypeGroupe getType();
+
+ /**
+ * permet de récupérer le groupe père
+ * un groupe racine devrait retourner lui-même
+ *
+ * @return le père
+ */
+ public Groupe getPointPoint();
+
+ /**
+ * Potentiellement "vide"
+ *
+ * @return l'ensemble des sous-groupes.
+ */
+ public Set getSousGroupes();
+
+ /**
+ * Potentiellement "vide"
+ *
+ * @return l'ensemble des étudiants.
+ */
+ public Set getEtudiants();
+
+ /**
+ * @see MonPrint
+ * NB. On n'utilise le mécanisme des méthodes par défaut pour donner du code dans une interface. C'est un petit peu laid et à contre-emploi mais pratique ici.
+ *
+ * NB2. On ne peut pas utiliser le toString de Objects
+ * https://stackoverflow.com/questions/24016962/java8-why-is-it-forbidden-to-define-a-default-method-for-a-method-from-java-lan
+ */
+ public default String monPrint() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("Groupe " + getName() + " (" + getType() + ", capacité " + getMin() + " à " + getMax() + ", id " + getId() + ")");
+ sb.append("\n");
+ // NB. getEtudiants() retourne un Set qui étend Iterable
+ // On peut utiliser les mécanismes de boucle "moderne" de puis la version 8
+ // pour se faciliter la vie quand le traitement est assez simple
+ // voir https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html
+ sb.append(" ** Étudiants **\n");
+ for (Etudiant s : getEtudiants()) {
+ sb.append("\t _ " + s.monPrint());
+ sb.append("\n");
+ }
+ sb.append(" ** Sous Groupes **\n");
+ for (Groupe g : getSousGroupes()) {
+ sb.append("\t _ " + g.getName() + " (" + g.getType() + ", capacité " + g.getMin() + " à " + g.getMax() + ", id " + g.getId() + ")");
+ sb.append("\n");
+ }
+ return sb.toString();
+ }
+
+}
diff --git a/src/API/MonPrint.java b/src/API/MonPrint.java
new file mode 100644
index 0000000..3e5cc7b
--- /dev/null
+++ b/src/API/MonPrint.java
@@ -0,0 +1,13 @@
+package API;
+
+/**
+ * Toutes nos interfaces vont étendre cette interface.
+ */
+public interface MonPrint {
+
+ /**
+ * Fonctionne comme ToPrint() sauf car une interface n'a pas le droit de faire un override sur ToPrint().
+ * Toutes nos interfaces vont étendre cette interface.
+ */
+ public String monPrint();
+}
diff --git a/src/API/TypeGroupe.java b/src/API/TypeGroupe.java
new file mode 100644
index 0000000..96a32d6
--- /dev/null
+++ b/src/API/TypeGroupe.java
@@ -0,0 +1,11 @@
+package API;
+
+public enum TypeGroupe {
+ ROOT("Tous les étudiants"), PARTITION("partition"), FREE("libre");
+
+ private final String name;
+
+ private TypeGroupe(String s) {
+ name = s;
+ }
+}
diff --git a/src/MNP/AbstractChangementFactoryNP.java b/src/MNP/AbstractChangementFactoryNP.java
new file mode 100644
index 0000000..be1b863
--- /dev/null
+++ b/src/MNP/AbstractChangementFactoryNP.java
@@ -0,0 +1,105 @@
+package MNP;
+
+import API.*;
+import java.util.*;
+/**
+ * Usine abstraite gérant l'ensemble des changements.
+ *
+ */
+
+public class AbstractChangementFactoryNP implements AbstractChangementFactory {
+
+ // l'usine à groupe travaillant en tandem avec cette usine.
+ private AbstractGroupeFactory agf;
+
+ // On utilise une table de hachage pour retrouver facilement un changement (à partir de son id).
+ // Si il y a beaucoup de changements c'est plus rapide que de parcourir toute une liste.
+ private HashMap brain;
+
+ public AbstractChangementFactoryNP(AbstractGroupeFactory agf){
+ Objects.requireNonNull(agf,"On ne peut pas créer une usine à changement dont l'usine à groupe parternaire est null");
+ this.agf=agf;
+ this.brain=new HashMap();
+ }
+
+
+ /**
+ * permet de récupérer l'usine abstraite pour les groupes qui fonctionne en tandem avec cette usine abstraite
+ * @return cette usine abstraite pour les groupes
+ */
+ public AbstractGroupeFactory getGroupeFactory(){
+ return this.agf;
+ }
+
+ /**
+ * permet de récupérer les changements
+ * @return l'ensemble de tous les changements en attente
+ */
+ public Set getAllChangements(){
+ // la méthode value() d'un hashmap retourne la collection des valeurs.
+ // Il faut transformer la collection en Set.
+ // Un constructeur de HashSet permet de faire cette opération.
+ Set out = new HashSet(this.brain.values());
+ return out;
+ }
+
+ /**
+ * permet de mettre en oeuvre un changement connu de l'usine abstraite.
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalStateException si le changement n'a pas de sens en l'état actuel (e.g. étudiant pas dans le groupe de départ a, groupe b inconnu, groupe a inconnu, etc).
+ * @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
+ */
+ public void applyChangement(Changement c){
+ Objects.requireNonNull(c,"On ne peut pas appliquer un changement qui est null");
+ Etudiant e = c.getEtu();
+ Groupe a = c.getA();
+ Groupe b = c.getB();
+
+ if (!agf.knows(a)) throw new IllegalStateException("Le groupe de départ du changement est inconnu. Impossible à mettre en oeuvre.");
+
+ if (!agf.knows(b)) throw new IllegalStateException("Le groupe d'arrivée du changement est inconnu. Impossible à mettre en oeuvre.");
+ // pas encore implanté.
+ // if(!agf.getGroupesOfEtudiant(e).contains(a)) throw new IllegalStateException("Le groupe de départ ne contient pas l'étudiant. Impossible à mettre en oeuvre.");
+
+ agf.dropFromGroupe(a,e);
+ agf.addToGroupe(b,e);
+ // En cas de succès, on enlève le changement du cerveau
+ this.brain.remove(Integer.valueOf(c.getId()));
+ }
+
+
+ /**
+ * permet de supprimer un changement connu de l'usine abstraite.
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si inconnu de l'usine abstraite
+ */
+ public void deleteChangement(Changement c){
+ Objects.requireNonNull(c,"On ne peut pas demander la suppression d'un changement qui est null");
+
+ this.brain.remove(Integer.valueOf(c.getId()));
+
+ }
+
+ /**
+ * permet d'ajouter un nouveau changement.
+ *
+ * @param A groupe actuel
+ * @param B groupe demandé
+ * @param e étudiant concerné par le changement
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si les groupes ou l'étudiant ne sont pas connus de la factory partenaire, ou e n'appartient pas à A ou A et B ne sont pas frères dans l'arbre des groupes.
+ *
+ */
+ public void createChangement(Groupe A, Etudiant e, Groupe B){
+ Objects.requireNonNull(A,"Le groupe d'origine ne peut pas être null");
+ Objects.requireNonNull(B,"Le groupe d'arrivée ne peut pas être null");
+ Objects.requireNonNull(e,"L'étudiant ne peut pas être null");
+
+ Changement c = new ChangementNP(A,e,B);
+ this.brain.put(Integer.valueOf(c.getId()),c);
+ }
+
+}
diff --git a/src/MNP/AbstractGroupeFactoryNP.java b/src/MNP/AbstractGroupeFactoryNP.java
new file mode 100644
index 0000000..ba048da
--- /dev/null
+++ b/src/MNP/AbstractGroupeFactoryNP.java
@@ -0,0 +1,226 @@
+package MNP;
+
+import API.*;
+import java.util.*;
+/**
+ * Usine abstraite gérant l'ensemble des groupes.
+ *
+ */
+
+public class AbstractGroupeFactoryNP implements AbstractGroupeFactory {
+
+ // la racine (promotion)
+ private Groupe promo;
+
+ // On utilise une table de hachage pour retrouver facilement un groupe (à partir de son id).
+ // Si il y a beaucoup de groupes c'est plus rapide que de parcourir toute une liste.
+ private HashMap brain;
+
+
+
+
+ /**
+ * Le constructeur fabrique le groupe promotion vide.
+ * Il faut ensuite y ajouter les étudiants.
+ */
+ public AbstractGroupeFactoryNP(int id, String name, int min, int max){
+ Objects.requireNonNull(name,"On ne peut pas créer une promotion dont le nom est null");
+ this.promo=new GroupeNP(id, name,min,max);
+ this.brain=new HashMap();
+ this.brain.put(id,this.promo);
+ }
+
+ /**
+ * Test plutôt optimiste. Si la clé est identique alors on fait comme si c'était le bon groupe.
+ */
+ public Boolean knows(Groupe g){
+ return this.brain.containsKey(Integer.valueOf(g.getId()));
+ }
+
+
+
+ /**
+ * permet de récupérer le Groupe qui contient les étudiants de toute la promotion
+ * @return la promo.
+ */
+ public Groupe getPromotion(){
+ return this.promo;
+ }
+
+ /**
+ * permet de supprimer un groupe connu de l'usine abstraite qui ne contient pas de groupes.
+ * Pour détruire un groupe connu qui en contient d'autres il faut le faire récursivement.
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalStateException si le groupe contient des groupes
+ * @throws java.lang.IllegalArgumentException si le groupe n'est pas connu de l'usine abstraite ou bien si le groupe est celui de toute la promotion (renvoyé par getPromotion)
+ */
+ public void deleteGroupe(Groupe g){
+ Objects.requireNonNull(g,"On ne peut pas enlever un groupe null car null n'est pas un groupe autorisé");
+ if (!this.knows(g)){
+ throw new IllegalArgumentException("Impossible d'enlever un groupe inconnu");
+ }
+ if (this.getPromotion().equals(g)){
+ throw new IllegalArgumentException("Impossible de détruire le groupe de toute la promotion");
+ }
+ if (g.getSize()>0){
+ throw new IllegalStateException("Impossible de détruire un groupe contenant un groupe");
+ }
+ g.getPointPoint().removeSousGroupe(g);
+ this.brain.remove(Integer.valueOf(g.getId()));
+ }
+
+ /**
+ * permet d'ajouter un groupe vide de type FREE comme sous-groupe d'un groupe donné.
+ * @param pere le groupe père du groupe à créer
+ * @param name le nom du groupe à créer
+ * @param min,max bornes indicatives sur la taille du groupe à créer
+ *
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
+ * ou si il n'y a pas 0 < min <= max
+ */
+ public void createGroupe(Groupe pere, String name, int min, int max){
+ Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
+ Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
+ if (!this.knows(pere)){
+ throw new IllegalArgumentException("Interdit d'ajouter un fils à un groupe inconnu");
+ }
+ if (pere.getType().equals(TypeGroupe.PARTITION)){
+ throw new IllegalArgumentException("Impossible d'ajouter un groupe à une parition. Il faut utiliser createPartition pour créer une partition");
+ }
+ if ( min <= 0 || max < min){
+ throw new IllegalArgumentException("Il faut que 0 < min <= max");
+ }
+ Groupe g = new GroupeNP(pere,name,min,max);
+ pere.addSousGroupe(g);
+ this.brain.put(Integer.valueOf(g.getId()),g);
+ }
+
+ /**
+ * permet de créer une partition automatiquement sous un groupe donné.
+ *
+ * @param pere le groupe père du groupe à partitionner
+ * @param name le nom des groupe à créer (on ajoute à la suite un numéro de 1 à n pour distinguer chaque groupe formant la partition)
+ * @param n le nombre de partitions
+ * @throws java.lang.NullPointerException si un argument est null
+ * @throws java.lang.IllegalArgumentException si le groupe pere est de type PARTITION
+ * ou n négatif ou nul
+ *
+ * NB. doit créer une "copie" de pere
+ * sous pere de type Partition et ajouter sous ce groupe, n groupes de type "FREE".
+ * les valeurs min et max de ces n groupes sont
+ * min = 0 et
+ * max = partie entière de N/n plus 1, où N est le nombre max du groupe pere.
+ */
+ public void createPartition(Groupe pere, String name, int n){
+ Objects.requireNonNull(pere,"Le groupe pere ne peut pas être null");
+ Objects.requireNonNull(name,"Le nouveau groupe ne peut pas avoir null comme nom");
+ if (!this.knows(pere)){
+ throw new IllegalArgumentException("Impossible de partitionner ce groupe inconnu");
+ }
+ if (pere.getType().equals(TypeGroupe.PARTITION)){
+ throw new IllegalArgumentException("Impossible de créer une partition à ce niveau. Il faut soit repartitionner le groupe au dessus, soit partitionner une partition en dessous.");
+ }
+ if ( n <= 0){
+ throw new IllegalArgumentException("Le nombre de partitions doit être strictement positif");
+ }
+ //Création de la racine de la partition.
+ Groupe copiePereRacinePartition = new GroupeNP(pere);
+ pere.addSousGroupe(copiePereRacinePartition);
+ this.brain.put(Integer.valueOf(copiePereRacinePartition.getId()),copiePereRacinePartition);
+ // création des sous-groupes
+ int min = 0;
+ int max = ((int) Math.floor(pere.getSize()/n))+1;
+ List groupes = new ArrayList(n);
+ for(int i = 0; i l'ensemble des étudiants connus de la factory ayant un nom "proche" de ce string au sens de la remarque ci-dessus.
+ *
+ * @throws java.lang.NullPointerException si le String est null.
+ */
+ public Set getEtudiants(String nomEtu){
+ // on cherche bêtement dans la promo.
+ Set out = new LinkedHashSet();
+ for (Etudiant e : getPromotion().getEtudiants()){
+ if (e.getNom().equals(nomEtu)){
+ out.add(e);
+ break;
+ }
+ }
+ return out;
+ }
+
+ /**
+ * permet de retrouver les groupes d'un étudiant.
+ *
+ * @param Etu un étudiant
+ * @return Etudiant l'étudiant connu de la factory ayant cet identifiant
+ *
+ * @throws java.lang.NullPointerException si le String est null.
+ */
+ public Set getGroupesOfEtudiant(Etudiant etu){
+ throw new UnsupportedOperationException("pas encore implanté");
+ }
+
+
+}
diff --git a/src/MNP/ChangementNP.java b/src/MNP/ChangementNP.java
new file mode 100644
index 0000000..dbc4253
--- /dev/null
+++ b/src/MNP/ChangementNP.java
@@ -0,0 +1,64 @@
+package MNP;
+
+import API.*;
+import java.util.*;
+/**
+ * Une demande de changement de groupe
+ * concerne un étudiant, qui est dans un groupe A et veut aller dans un groupe B.
+ *
+ * Implémentation non persistante fournie avec l'API.
+ */
+
+public class ChangementNP implements Changement {
+
+ //auto-incrément des changements
+ private static int nextId=0;
+
+ private int id;
+ private Groupe a,b;
+ private Etudiant e;
+
+ public ChangementNP(Groupe a, Etudiant e, Groupe b){
+ Objects.requireNonNull(a,"On ne peut pas créer un changement avec un groupe à quitter null");
+ Objects.requireNonNull(b,"On ne peut pas créer un changement avec un groupe à rejoindre null");
+ Objects.requireNonNull(e,"On ne peut pas créer un changement concernant un étudiant null");
+
+ this.id=++this.nextId;
+ this.a=a;
+ this.b=b;
+ this.e=e;
+ }
+
+ /**
+ * permet de récupérer l'identifiant du changement (référence interne sans intérêt irl).
+ * @return l'identifiant.
+ */
+ public int getId(){
+ return this.id;
+ }
+
+ /**
+ * permet de récupérer le groupe de depart
+ * @return ce groupe.
+ */
+ public Groupe getA(){
+ return this.a;
+ }
+
+ /**
+ * permet de récupérer le groupe d'arrivée
+ * @return ce groupe.
+ */
+ public Groupe getB(){
+ return this.b;
+ }
+
+ /**
+ * permet de récupérer l'étudiant demandant le changement
+ * @return cet étudiant
+ */
+ public Etudiant getEtu(){
+ return this.e;
+ }
+
+}
diff --git a/src/MNP/EtudiantNP.java b/src/MNP/EtudiantNP.java
new file mode 100644
index 0000000..b212183
--- /dev/null
+++ b/src/MNP/EtudiantNP.java
@@ -0,0 +1,60 @@
+package MNP;
+
+import API.*;
+import java.util.*;
+/**
+ * Un étudiant
+ */
+
+public class EtudiantNP implements Etudiant{
+
+ private static int nextId=0;
+ private int id, groupe;
+ private String nom, prenom;
+
+ /**
+ * Constructeur. (modification apporter par le groupe pour accueillir un nouveau parametre : groupe)
+ */
+ public EtudiantNP(String nom, String prenom, int groupe){
+ Objects.requireNonNull(nom,"On ne peut pas créer un étudiant avec un nom null");
+ Objects.requireNonNull(prenom,"On ne peut pas créer un étudiant avec un nom null");
+ // auto incrément de l'id
+ this.id=++this.nextId;
+ this.groupe = groupe;
+ this.nom=nom;
+ this.prenom=prenom;
+ }
+
+ /**
+ * permet de récupérer l'identifiant de l'étudiant.
+ * @return l'identifiant.
+ */
+ public int getId(){
+ return this.id;
+ }
+
+ /**
+ * permet de récupérer
+ * @return le nom de l'étudiant.
+ */
+ public String getNom(){
+ return this.nom;
+ }
+
+ /**
+ * permet de récupérer
+ * @return le prénom de l'étudiant
+ */
+ public String getPrenom(){
+ return this.prenom;
+ }
+
+ /**
+ * Ajout de l'equipe pour recuperer son groupe
+ *
+ * @return Le groupe en entier
+ * */
+ public int getGroupe() {
+ return this.groupe;
+ }
+}
diff --git a/src/MNP/GroupeNP.java b/src/MNP/GroupeNP.java
new file mode 100644
index 0000000..7d4661b
--- /dev/null
+++ b/src/MNP/GroupeNP.java
@@ -0,0 +1,193 @@
+package MNP;
+
+import API.*;
+import java.util.*;
+/**
+ * Un groupe
+ */
+
+public class GroupeNP implements Groupe {
+
+ //auto-incrément des groupes. (NB. inutile, mais ça fair un exemple d'attribut statique).
+ private static int nextId=0;
+ // attributs naturels induits par getter de l'interface Groupe
+ private int id;
+ private String name;
+ private int min,max;
+ private TypeGroupe type;
+ private Groupe pointPoint;
+ // On utilise une interface set pour les sous-groupes et pour les membres (ce sont bien des ensembles en pratique).
+ private Set sousGroupes;
+ private Set membresDuGroupe;
+
+ /**
+ * Nouveau groupe vide de type ROOT sans étudiants, sans sous-Groupe
+ */
+ public GroupeNP(int id, String name, int min, int max){
+ Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
+ this.id=id;
+ this.name=name;
+ this.min=min;
+ this.max=max;
+ this.type=TypeGroupe.ROOT;
+ this.pointPoint=this;
+ this.sousGroupes=new LinkedHashSet();
+ this.membresDuGroupe=new LinkedHashSet();
+ }
+
+ /**
+ * Nouveau groupe vide de type FREE sans étudiants, sans sous-Groupe
+ */
+ public GroupeNP(Groupe pere, String name, int min, int max){
+ Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
+ Objects.requireNonNull(name,"On ne peut pas créer un groupe dont le nom est null");
+ this.id=++this.nextId;
+ this.name=name;
+ this.min=min;
+ this.max=max;
+ this.type=TypeGroupe.FREE;
+ this.pointPoint=pere;
+ this.sousGroupes=new LinkedHashSet();
+ this.membresDuGroupe=new LinkedHashSet();
+ }
+
+ /**
+ * Nouveau groupe de type PARTITION dupliquant le groupe passé en paramètre (pour servir de racine à une partition de ce groupe de type FREE passé en paramètre).
+ *
+ */
+ public GroupeNP(Groupe pere){
+ Objects.requireNonNull(pere,"On ne peut pas créer un groupe dont le père est null");
+ this.id=++this.nextId;
+ this.name=pere.getName()+"_PARTITION_"+ this.id;
+ this.min=pere.getMin();
+ this.max=pere.getMax();
+ this.type=TypeGroupe.PARTITION;
+ this.pointPoint=pere;
+ this.sousGroupes= new LinkedHashSet();
+ this.membresDuGroupe= pere.getEtudiants();
+ }
+
+ /**
+ * Ajoute un étudiant. Se comporte comme add de l'interface Set.
+ *
+ * @return true iff e est ajouté
+ */
+ public boolean addEtudiant(Etudiant e){
+ Objects.requireNonNull(e,"On ne peut pas ajouter un Étudiant qui est null");
+ return this.membresDuGroupe.add(e);
+ }
+
+ /**
+ * Enlève un étudiant. Se comporte comme remove de l'interface Set.
+ *
+ * @return true iff e est enlevé
+ */
+ public boolean removeEtudiant(Etudiant e){
+ Objects.requireNonNull(e,"On ne peut pas enlever un Étudiant qui est null");
+ return this.membresDuGroupe.remove(e);
+ }
+
+ /**
+ * Ajoute un sous-groupe. Se comporte comme add de l'interface Set.
+ * vérifie que le groupe passé en argument a bien renseigné this comme son père.
+ *
+ * @return true iff g est ajouté
+ */
+ public boolean addSousGroupe(Groupe g){
+ Objects.requireNonNull(g,"On ne peut pas ajouter un sous-groupe qui est null");
+ if (this.equals(g.getPointPoint()))
+ return this.sousGroupes.add(g);
+ else throw new IllegalArgumentException("on ne peut pas ajouter un sous-groupe ont le père n'est pas this");
+ }
+
+ /**
+ * Enlève un groupe. Se comporte comme remove de l'interface Set.
+ *
+ * @return true iff e est enlevé
+ */
+ public boolean removeSousGroupe(Groupe g){
+ Objects.requireNonNull(g,"On ne peut pas enlever un Étudiant qui est null");
+ return this.sousGroupes.remove(g);
+ }
+
+
+ /**
+ * permet de récupérer l'identifiant d'un groupe (référence interne sans intérêt irl).
+ * @return l'identifiant.
+ */
+ public int getId(){
+ return this.id;
+ }
+
+ /**
+ * permet de récupérer le nom d'un groupe (utile irl).
+ * @return le nom.
+ */
+ public String getName(){
+ return this.name;
+ }
+
+ /**
+ * permet de récupérer le nombre minimum d'étudiants souhaités dans le groupe.
+ * @return le minimum souhaité
+ */
+ public int getMin(){
+ return this.min;
+ }
+
+ /**
+ * permet de récupérer le nombre maximum d'étudiants souhaités dans un groupe.
+ * @return le maximum souhaité
+ */
+ public int getMax(){
+ return this.max;
+ }
+
+ /**
+ * permet de récupérer le nombre d'étudiants dans ce groupe.
+ * @return le nombre de places prises (pas forcément limité entre Min et Max, mais c'est le but)
+ */
+ public int getSize(){
+ return this.membresDuGroupe.size();
+ }
+
+ /**
+ * permet de récupérer la nature du groupe
+ * @return le type du groupe
+ */
+ public TypeGroupe getType(){
+ return type;
+ }
+
+ /**
+ * permet de récupérer le groupe père
+ * un groupe racine devrait retourner lui-même
+ *
+ * @return le père
+ */
+ public Groupe getPointPoint(){
+ return this.pointPoint;
+ }
+
+ /**
+ * Potentiellement "vide"
+ * Attention nous renvoyons l'ensemble sans le copier
+ *
+ * @return l'ensemble des sous-groupes.
+ */
+ public Set getSousGroupes(){
+ return this.sousGroupes;
+ }
+
+ /**
+ * Potentiellement "vide"
+ * Attention nous renvoyons l'ensemble sans le copier
+ *
+ * @return l'ensemble des étudiants.
+ */
+ public Set getEtudiants(){
+ return this.membresDuGroupe;
+ }
+
+
+}
diff --git a/src/Test/BDatabase.java b/src/Test/BDatabase.java
new file mode 100644
index 0000000..30cb75b
--- /dev/null
+++ b/src/Test/BDatabase.java
@@ -0,0 +1,178 @@
+package Test;
+
+/* [BPakage.BDatabase]
+ * Desc: To create Operationnal Database Link fast :)
+ * GitHub: https://github.com/lalBi94
+ * Created by: Bilal Boudjemline
+ * 28/09/2022 at 20:35
+ * */
+
+import java.sql.*;
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import org.mariadb.jdbc.*;
+
+/**
+ *
Methodes pour les interaction avec une base de donnees
+ *
+ * @author Bilal Boudjemline
+ */
+
+public class BDatabase {
+ private final String db_host;
+ private final String db_name;
+ private final String db_user;
+ private final String db_password;
+ protected Connection sharedObject;
+ private boolean status;
+
+ public BDatabase() {
+ this.db_host = "jdbc:mariadb://dwarves.iut-fbleau.fr/";
+ this.db_name = "brinet";
+ this.db_user = "brinet";
+ this.db_password = "Aignan41!";
+
+ try {
+ Class.forName("org.mariadb.jdbc.Driver");
+ } catch(ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+
+ try {
+ this.sharedObject = DriverManager.getConnection(this.db_host + this.db_name, this.db_user, this.db_password);
+ this.status = true;
+ } catch (SQLException e) {
+ System.out.println("Erreur de liaison avec la base de donnees.");
+ }
+ }
+
+ /**
+ * Recuperer les informations d'un requete de type SELECT.
+ *
+ * @param request Le SELECT a faire (il y aura plus d'argument prochainement)
+ * @return Les resultats engendre par la requete
+ */
+ public ArrayList fetchAll(String request) {
+ try {
+ ArrayList toReturn = new ArrayList();
+ ResultSet rs = this.sharedObject.prepareStatement(request).executeQuery();
+
+ for(int i = 0; rs.next(); i++) {
+ toReturn.add(i, String.valueOf(rs.getString(1)));
+ }
+
+ return toReturn;
+ } catch(SQLException e) {
+ System.out.println("Erreur de la requete : " + e);
+ return null;
+ }
+ }
+
+ /**
+ * Insert une ligne dans une table.
+ *
+ * @param table La table
+ * @param col Tableau qui contient les colonnes d'affectation
+ * @param value Valeur des colonnes
+ * @return Retourne true si ca a reussit et false dans le cas inverse
+ */
+ public boolean insertRow(String table, String[] col, String[] value) {
+ StringBuilder collumns = new StringBuilder();
+ StringBuilder values = new StringBuilder();
+ Iterator iteCol = Arrays.stream(col).iterator();
+ Iterator iteVal = Arrays.stream(value).iterator();
+
+ collumns.append("(");
+ while(iteCol.hasNext()) {
+ collumns.append(iteCol.next()).append(", ");
+ }
+ collumns.setLength(collumns.length()-2);
+ collumns.append(")");
+
+ values.append("(");
+ while(iteVal.hasNext()) {
+ values.append("\"").append(iteVal.next()).append("\"").append(", ");
+ }
+ values.setLength(values.length()-2);
+ values.append(")");
+
+ String request = "INSERT INTO " + table + collumns + " VALUES" + values + ";";
+ System.out.println(request);
+
+ try {
+ this.sharedObject.prepareStatement(request).executeQuery();
+ System.out.println("Succes: " + request);
+ return true;
+ } catch(SQLException e) {
+ return false;
+ }
+ }
+
+ /**
+ * Faire des requetes de type UPDATE SET (il y aura plus d'argument prochainement).
+ *
+ * @param request La requete
+ * @return Si oui ou non ca a fonctionne
+ */
+ public boolean updateRow(String request) {
+ try {
+ this.sharedObject.prepareStatement(request).executeQuery();
+ System.out.println("Succes: " + request);
+ return true;
+ } catch(SQLException e) {
+ return false;
+ }
+ }
+
+ /**
+ * Recuperer l'objet Connection pour pouvoir utiliser ses methodes.
+ *
+ * @return L 'objet Connection.
+ */
+ public Connection getSharedObject() {
+ return this.sharedObject;
+ }
+
+ /**
+ * Recuperer l'utilisateur courant.
+ *
+ * @return L 'utilisateur.
+ */
+ public String getUser() {
+ return this.db_user;
+ }
+
+ /**
+ * Recuperer l'hote courant.
+ *
+ * @return L 'hote.
+ */
+ public String getHost() {
+ return this.db_host;
+ }
+
+ /**
+ * Recuperer le nom de la base de donnees.
+ *
+ * @return Le nom de la base de donnees.
+ */
+ public String getDatabaseName() {
+ return this.db_name;
+ }
+
+ /**
+ * Recuperer le status de connection.
+ *
+ * @return Le status de connection.
+ */
+ public boolean getStatus() {
+ return this.status;
+ }
+
+ @Override
+ public String toString() {
+ return this.db_host + "\n" + this.db_name + "\n" + this.db_user + "\n";
+ }
+}
\ No newline at end of file
diff --git a/src/Test/BFrame.java b/src/Test/BFrame.java
new file mode 100644
index 0000000..e1e1ae0
--- /dev/null
+++ b/src/Test/BFrame.java
@@ -0,0 +1,174 @@
+package Test;
+
+/* [BPackage.BFrame]
+ * Desc: To create Operationnal JFrame with utils methods fast :)
+ * GitHub: https://github.com/lalBi94
+ * Created by: Bilal Boudjemline
+ * 28/09/2022 at 20:35
+ * */
+
+import javax.swing.JFrame;
+import javax.swing.SwingUtilities;
+import javax.swing.ImageIcon;
+import java.awt.GridBagLayout;
+import java.awt.GridLayout;
+import java.awt.event.WindowEvent;
+
+/**
+ *
Pour creer une fenetre rapidement avec les methodes simplifier
+ *
+ * @author Bilal Boudjemline
+ */
+
+public class BFrame extends JFrame {
+ private final String title;
+ private int location_x = 1;
+ private int location_y = 1;
+ private int width = 500;
+ private int height = 500;
+ private int killProcess = 3;
+ private boolean isOpen = false;
+
+ /**
+ * Avec le titre et mode de fermeture.
+ *
+ * @param title Le titre de la fenetre
+ * @param oC Mode de fermeture de la fenetre
+ */
+ public BFrame(String title, int oC) {
+ this.title = title;
+ this.killProcess = oC;
+ initBFrame();
+ }
+
+ /**
+ * Avec le titre, la taille (en L et l) et mode de fermeture.
+ *
+ * @param titlee Le titre de la fenetre
+ * @param size_x La longueur de la fenetre
+ * @param size_y La largeur y de la fenetre
+ * @param oC Mode de fermeture de la fenetre
+ */
+ public BFrame(String titlee, int size_x, int size_y, int oC) {
+ this.title = titlee;
+ this.width = size_x;
+ this.height = size_y;
+ this.killProcess = oC;
+ initBFrame();
+ }
+
+ /**
+ * Avec le titre, la locasation (en x et y), la taille (en L et l) et mode de fermeture.
+ *
+ * @param title Le titre de la fenetre
+ * @param loca_x La localisation en x de la fenetre
+ * @param loca_y La localisation en y de la fenetre
+ * @param size_x La longueur de la fenetre
+ * @param size_y La largeur de la fenetre
+ * @param oC Mode de fermeture de la fenetre
+ */
+ public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, int oC) {
+ this.title = title;
+ this.location_x = loca_x;
+ this.location_y = loca_y;
+ this.width = size_x;
+ this.height = size_y;
+ this.killProcess = oC;
+ initBFrame();
+ }
+
+ /**
+ * Avec le titre, la locasation (en x et y), la taille (en L et l), le layout et le mode de fermeture.
+ *
+ * @param title Le titre de la fenetre
+ * @param loca_x La localisation en x de la fenetre
+ * @param loca_y La localisation en y de la fenetre
+ * @param size_x La longueur de la fenetre
+ * @param size_y La largeur de la fenetre
+ * @param layout Layout a utiliser dispo : GridBagLayout / GridLayout
+ * @param layout_row the layout row
+ * @param layout_col the layout col
+ * @param oC Mode de fermeture de la fenetre
+ */
+ public BFrame(String title, int loca_x, int loca_y, int size_x, int size_y, String layout, int layout_row, int layout_col, int oC) {
+ this.title = title;
+ this.location_x = loca_x;
+ this.location_y = loca_y;
+ this.width = size_x;
+ this.height = size_y;
+ this.killProcess = oC;
+ initBFrame(layout, layout_row, layout_col);
+ }
+
+ /**
+ * Initialiser la fenetre sans Layout par def.
+ */
+ protected void initBFrame() {
+ ImageIcon icon = new ImageIcon("assets/logo.png");
+ this.setTitle(this.title);
+ this.setLocation(this.location_x, this.location_y);
+ this.setSize(this.width, this.height);
+ this.setLayout(new GridBagLayout());
+ this.setIconImage(icon.getImage());
+ this.setDefaultCloseOperation(this.killProcess);
+ }
+
+ /**
+ * Initialiser la fenetre avec Layout
+ *
+ * @param layout the layout
+ * @param row the row
+ * @param col the col
+ */
+ protected void initBFrame(String layout, int row, int col) {
+ ImageIcon icon = new ImageIcon("assets/logo.png");
+ this.setTitle(this.title);
+ this.setLocation(this.location_x, this.location_y);
+ this.setSize(this.width, this.height);
+
+ if(layout == "GridLayout") {
+ this.setLayout(new GridLayout(row, col));
+ } else {
+ System.out.println("Un layout doit etre fourni.");
+ }
+
+ this.setIconImage(icon.getImage());
+ this.setDefaultCloseOperation(this.killProcess);
+ }
+
+ /**
+ * Ouvrir la fenetre
+ */
+ public void openBFrame() {
+ this.isOpen = true;
+ this.setVisible(true);
+ }
+
+ /**
+ * Fermer la fenetre
+ */
+ public void closeBFrame() {
+ this.isOpen = false;
+ this.setVisible(false);
+ this.dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
+ }
+
+ /**
+ * Rafraichir la fenetre
+ */
+ public void refreshBFrame() {
+ SwingUtilities.updateComponentTreeUI(this);
+ }
+
+ /**
+ * Statut de visibilite de la fenetre
+ */
+ public boolean isVisible() {
+ return this.isOpen;
+ }
+
+ @Override
+ public String toString() {
+ return this.title + ": is opened";
+ }
+}
\ No newline at end of file
diff --git a/src/Test/BLayout.java b/src/Test/BLayout.java
new file mode 100644
index 0000000..aceb7fd
--- /dev/null
+++ b/src/Test/BLayout.java
@@ -0,0 +1,171 @@
+package Test;
+
+/* [BPakage.BLayout]
+ * Desc: To create a layout fast :)
+ * GitHub: https://github.com/lalBi94
+ * Created by: Bilal Boudjemline
+ * 28/09/2022 at 20:35
+ * */
+
+import java.awt.GridBagConstraints;
+import java.awt.Insets;
+
+/**
+ *
Pour creer un layout de type GridBagLayout rapidement avec les methodes simplifier.
+ *
+ * @author Bilal Boudjemline
+ */
+
+public class BLayout extends GridBagConstraints {
+ public int PositionOnX = 0;
+ public int PositionOnY = 0;
+ public int takeCaseOnX = 1;
+ public int takeCaseOnY = 1;
+ public double sizeOnX = 0.0f;
+ public double sizeOnY = 0.0f;
+ public int padding_top = 1;
+ public int padding_left = 1;
+ public int padding_bottom = 1;
+ public int padding_right = 1;
+ public Insets padding = new Insets(this.padding_top, this.padding_left, this.padding_bottom, this.padding_right);
+ public int positionOnScreen = GridBagConstraints.NORTH;
+ public int filler = GridBagConstraints.BASELINE;
+
+ public BLayout() {
+ initLayout();
+ }
+
+ /**
+ * @param positionX Position en X.
+ * @param positionY Position en y.
+ * @param manyCaseX Combien le component prend de case en x.
+ * @param manyCaseY Combien le component prend de case en y.
+ * @param sizeX Taille en double en x.
+ * @param sizeY Taille en double en y.
+ * @param pad Le padding.
+ * @param positionOnScreen La position sur la frame (centre, north etc...).
+ * @param filling Remplissage (H, V, B).
+ */
+ public BLayout(int positionX, int positionY, int manyCaseX, int manyCaseY, double sizeX,
+ double sizeY, Insets pad, int positionOnScreen, int filling) {
+ this.PositionOnX = positionX;
+ this.PositionOnY = positionY;
+ this.takeCaseOnX = manyCaseX;
+ this.takeCaseOnY = manyCaseY;
+ this.sizeOnX = sizeX;
+ this.sizeOnY = sizeY;
+ this.padding_top = pad.top;
+ this.padding_left = pad.left;
+ this.padding_bottom = pad.bottom;
+ this.padding_right = pad.right;
+ this.padding = pad;
+ this.positionOnScreen = positionOnScreen;
+ this.filler = filling;
+ initLayout();
+ }
+
+ /**
+ * Initialiser le layout pour le changer dans GridBagConstraint (Valeur attribuer par def.).
+ * */
+ private void initLayout() {
+ this.gridx = this.PositionOnX;
+ this.gridy = this.PositionOnY;
+ this.gridheight = this.takeCaseOnX;
+ this.gridwidth = this.takeCaseOnY;
+ this.weightx = this.sizeOnX;
+ this.weighty = this.sizeOnY;
+ this.insets = this.padding;
+ this.anchor = this.positionOnScreen;
+ this.fill = this.filler;
+ }
+
+ /**
+ * Changer le cuseur en x.
+ *
+ * @param by par quoi
+ */
+ public void setPositionX(int by) {
+ this.PositionOnX = by;
+ initLayout();
+ }
+
+ /**
+ * Changer le cuseur en y.
+ *
+ * @param by par quoi
+ */
+ public void setPositionY(int by) {
+ this.PositionOnY = by;
+ initLayout();
+ }
+
+ /**
+ * Changer la place occupe en x.
+ *
+ * @param by par quoi
+ */
+ public void setTakeCaseOnX(int by) {
+ this.takeCaseOnX = by;
+ initLayout();
+ }
+
+ /**
+ * Changer la place occupe en y.
+ *
+ * @param by par quoi
+ */
+ public void setTakeCaseOnY(int by) {
+ this.takeCaseOnY = by;
+ initLayout();
+ }
+
+ /**
+ * Mettre sa taille en x.
+ *
+ * @param by par quoi
+ */
+ public void setSizeX(double by) {
+ this.sizeOnX = by;
+ initLayout();
+ }
+
+ /**
+ * Mettre sa taille en y.
+ *
+ * @param by par quoi
+ */
+ public void setSizeY(double by) {
+ this.sizeOnY = by;
+ initLayout();
+ }
+
+ /**
+ * Mettre un padding.
+ *
+ * @param by par quoi
+ */
+ public void setPadding(Insets by) {
+ this.padding = by;
+ initLayout();
+ }
+
+ /**
+ * Mettre une ancre.
+ *
+ * @param by par quoi
+ */
+ public void setAnchor(int by) {
+ this.positionOnScreen = by;
+ initLayout();
+ }
+
+ /**
+ * Mettre un remplissage.
+ *
+ * @param by par quoi
+ */
+ public void setFill(int by) {
+ this.filler = by;
+ initLayout();
+ }
+}
diff --git a/src/Test/ProfView.java b/src/Test/ProfView.java
new file mode 100644
index 0000000..7032f78
--- /dev/null
+++ b/src/Test/ProfView.java
@@ -0,0 +1,266 @@
+package Test;
+
+import API.*;
+import MNP.*;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.ArrayList;
+import javax.swing.*;
+
+public class ProfView extends BFrame implements ActionListener {
+ private final ArrayList e;
+ private final ArrayList g;
+ private JComboBox groupeOption;
+ private JTextField text;
+ private BDatabase db;
+
+ public ProfView(ArrayList e, ArrayList g, BDatabase db) {
+ super(
+ "Vue professeur",
+ 1,
+ 1,
+ 500,
+ 500,
+ 3
+ );
+
+ this.e = e;
+ this.g = g;
+ this.db = db;
+
+ Display();
+ }
+
+ public void Display() {
+ BLayout settings = new BLayout();
+ settings.setPositionX(0);
+ settings.setPositionY(3);
+
+ settings.setPositionY(0);
+ JButton studList = new JButton("Voir la liste des etudiants");
+ studList.setActionCommand("fi::GetStudList");
+ studList.addActionListener(this);
+ this.add(studList, settings);
+
+ settings.setPositionY(1);
+ this.add(new JLabel(" "), settings);
+
+ settings.setPositionY(2);
+ JLabel gs = new JLabel("Afficher les etudiants se trouvant dans le groupe :");
+ this.add(gs, settings);
+
+ settings.setPositionY(3);
+ String[] groupeList = new String[this.g.size()];
+
+ for(int i = 0; i <= this.g.size()-1; i++) {
+ groupeList[i] = this.g.get(i).getName();
+ }
+
+ this.groupeOption = new JComboBox(groupeList);
+ this.groupeOption.setPreferredSize(new Dimension(110, 30));
+ this.add(groupeOption, settings);
+
+ settings.setPositionY(3);
+ settings.setAnchor(GridBagConstraints.EAST);
+ JButton confirm = new JButton("Rechercher");
+ confirm.setActionCommand("fi::GetListFiltered");
+ confirm.addActionListener(this);
+ this.add(confirm, settings);
+
+ settings.setAnchor(GridBagConstraints.CENTER);
+
+ settings.setPositionY(4);
+ this.add(new JLabel(" "), settings);
+
+ settings.setPositionY(5);
+ JLabel pf = new JLabel("Rechercher un etudiant : ");
+ this.add(pf, settings);
+
+ settings.setPositionY(6);
+ this.text = new JTextField();
+ this.text.setPreferredSize(new Dimension(110, 30));
+ text.addKeyListener(new KeyAdapter() {
+ public void keyTyped(KeyEvent e) {
+ if (text.getText().length() >= 3 ) // limit textfield to 3 characters
+ e.consume();
+ }
+ });
+ this.add(this.text, settings);
+
+ settings.setPositionY(6);
+ settings.setAnchor(GridBagConstraints.EAST);
+ JButton searchTLetters = new JButton("Rechercher");
+ searchTLetters.addActionListener(this);
+ searchTLetters.setActionCommand("fi::SearchStudentPer3Letters");
+ this.add(searchTLetters, settings);
+
+ this.openBFrame();
+ this.refreshBFrame();
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ String command = e.getActionCommand();
+
+ if (command == "fi::GetStudList") {
+ BFrame frame = new BFrame(
+ "Liste des eleves",
+ 1,
+ 1,
+ 500,
+ 500,
+ "GridLayout",
+ 1,
+ 1,
+ 2
+ );
+
+ String[][] data = new String[this.e.size()][2];
+
+ String[] titre = {
+ "Nom",
+ "Prenom",
+ "Groupe"
+ };
+
+ for(int i = 0; i <= this.e.size()-1; i++) {
+ String[] info = {
+ this.e.get(i).getNom(),
+ this.e.get(i).getPrenom(),
+ String.valueOf(this.e.get(i).getGroupe())
+ };
+
+ data[i] = info;
+ }
+
+ JTable liste = new JTable(data, titre) {
+ public boolean editCellAt(int row, int column, java.util.EventObject e) {
+ return false;
+ }
+ };
+
+ liste.getTableHeader().setReorderingAllowed(false);
+ liste.setFillsViewportHeight(true);
+
+ JScrollPane scroll = new JScrollPane(liste);
+ frame.getContentPane().add(scroll);
+
+ frame.openBFrame();
+ } else if(command == "fi::GetListFiltered") {
+ BFrame frame = new BFrame(
+ "Liste des eleves du " + this.groupeOption.getSelectedItem(),
+ 1,
+ 1,
+ 500,
+ 500,
+ "GridLayout",
+ 1,
+ 1,
+ 2
+ );
+
+ String[][] data = new String[this.e.size()][1];
+
+ String[] titre = {
+ "Nom",
+ "Prenom"
+ };
+
+ int i, j;
+
+ for(i = 0, j = 0; i <= this.e.size()-1; i++) {
+ if(this.e.get(i).getGroupe() == this.groupeOption.getSelectedIndex()) {
+ String[] info = {
+ this.e.get(i).getNom(),
+ this.e.get(i).getPrenom()
+ };
+
+ data[j] = info;
+ j++;
+ }
+ }
+
+ String[][] data_final = new String[j][1];
+ for(int x = 0; x <= j-1; x++) {
+ data_final[x] = data[x];
+ }
+
+
+ JTable liste = new JTable(data_final, titre) {
+ public boolean editCellAt(int row, int column, java.util.EventObject e) {
+ return false;
+ }
+ };
+
+ liste.getTableHeader().setReorderingAllowed(false);
+ liste.setFillsViewportHeight(true);
+
+ JScrollPane scroll = new JScrollPane(liste);
+ frame.getContentPane().add(scroll);
+
+ frame.openBFrame();
+ } else if(command == "fi::SearchStudentPer3Letters") {
+ /**
+ * Faire l'interface du filtrage.
+ * */
+ char[] beg = this.text.getText().toCharArray();
+ ArrayList listFiltered = new ArrayList<>();
+ char[] cur;
+
+ for(int i = 0; i <= this.e.size()-1; i++) {
+ cur = this.e.get(i).getNom().toCharArray();
+ if(cur[0] == beg[0] && cur[1] == beg[1] && cur[2] == beg[2]) {
+ listFiltered.add(new EtudiantNP(
+ this.e.get(i).getNom(),
+ this.e.get(i).getPrenom(),
+ this.e.get(i).getGroupe()
+ ));
+ }
+ }
+
+ BFrame frame = new BFrame(
+ "Liste d'eleves d'ou les noms commence par " + beg[0] + beg[1] + beg[2],
+ 1,
+ 1,
+ 500,
+ 500,
+ "GridLayout",
+ 1,
+ 1,
+ 2
+ );
+
+ String[] titre = {
+ "Nom",
+ "Prenom",
+ "Groupe"
+ };
+
+ String[][] data = new String[listFiltered.size()][2];
+
+ for(int i = 0; i <= listFiltered.size()-1; i++){
+ data[i] = new String[]{
+ this.e.get(i).getNom(),
+ this.e.get(i).getPrenom(),
+ String.valueOf(this.e.get(i).getGroupe())
+ };
+ }
+
+ JTable liste = new JTable(data, titre) {
+ public boolean editCellAt(int row, int column, java.util.EventObject e) {
+ return false;
+ }
+ };
+
+ liste.getTableHeader().setReorderingAllowed(false);
+ liste.setFillsViewportHeight(true);
+
+ JScrollPane scroll = new JScrollPane(liste);
+ frame.getContentPane().add(scroll);
+
+ frame.openBFrame();
+ frame.refreshBFrame();
+ }
+ }
+}
diff --git a/src/Test/TestTexteMNP.java b/src/Test/TestTexteMNP.java
new file mode 100644
index 0000000..7c5a193
--- /dev/null
+++ b/src/Test/TestTexteMNP.java
@@ -0,0 +1,70 @@
+package Test;
+
+import API.*;
+import MNP.*;
+import java.util.*;
+
+public class TestTexteMNP {
+ public static void main(String[] args) {
+ /**
+ * Objet de la base de donnee contenant des methodes utile a notre developpement
+ * */
+ BDatabase bd = new BDatabase();
+
+ /**
+ * Chargement des eleves
+ * */
+ ArrayList listEtu = new ArrayList<>();
+ ArrayList studPrenom = bd.fetchAll("SELECT prenom FROM fi_eleves");
+ ArrayList studNom = bd.fetchAll("SELECT nom FROM fi_eleves");
+ ArrayList studGroupe = bd.fetchAll("SELECT groupe FROM fi_eleves");
+
+ for(int i = 0; i <= studPrenom.size()-1; i++) {
+ if(studPrenom.get(i) != null && studNom.get(i) != null && studGroupe.get(i) != null) {
+ listEtu.add(
+ new EtudiantNP(
+ studNom.get(i),
+ studPrenom.get(i),
+ Integer.parseInt(studGroupe.get(i), 10)
+ )
+ );
+
+ //System.out.println(listEtu.get(i).monPrint());
+ } else {
+ System.out.println("[!] Erreur lors du chargement de la liste des etudiants.");
+ System.exit(-1);
+ }
+ }
+
+ System.out.println("[+] Liste des etudiants chargees.");
+
+ /**
+ * Chargement des groupes
+ * */
+ ArrayList listGroupe = new ArrayList<>();
+ ArrayList groupeId = bd.fetchAll("SELECT id FROM fi_groupe");
+ ArrayList groupeNom = bd.fetchAll("SELECT nom FROM fi_groupe");
+ ArrayList groupeMin = bd.fetchAll("SELECT min FROM fi_groupe");
+ ArrayList groupeMax = bd.fetchAll("SELECT max FROM fi_groupe");
+
+ for(int i = 0; i <= groupeNom.size()-1; i++) {
+ if(groupeId.get(i) != null && groupeNom.get(i) != null && groupeMin.get(i) != null && groupeMax.get(i) != null) {
+ listGroupe.add(
+ new GroupeNP(
+ Integer.parseInt(groupeId.get(i), 10),
+ groupeNom.get(i),
+ Integer.parseInt(groupeMin.get(i), 10),
+ Integer.parseInt(groupeMax.get(i), 10)
+ )
+ );
+ } else {
+ System.out.println("[!] Erreur lors du chargement de la liste des groupes.");
+ System.exit(-1);
+ }
+ }
+
+ System.out.println("[+] Liste des groupes chargees.");
+
+ new ProfView(listEtu, listGroupe, bd);
+ }
+}
diff --git a/src/Test/libs/mariadb-connector.jar b/src/Test/libs/mariadb-connector.jar
new file mode 100644
index 0000000..58d75f3
Binary files /dev/null and b/src/Test/libs/mariadb-connector.jar differ