SendPost fonctionnelle (vraiment fonctionnelle)

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/ChatApp-AL-NM.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="13" project-jdk-type="JavaSDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/ChatApp-AL-NM.iml" filepath="$PROJECT_DIR$/.idea/ChatApp-AL-NM.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Implementation/chatapp/src/main/java/chatapp/Protocol/HttpEchange.java

@@ -0,0 +1,90 @@
+package chatapp.Protocol;
+
+import chatapp.Controller.ChatApp;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.HashMap;
+
+/**
+ * <p>
+ * Classe representant les echanges HTTP entre un utilisateur distant et le servlet.
+ * </p>
+ */
+public class HttpEchange {
+
+    private String url = "http://localhost:8080/JavaEEHelloWorld_war_exploded/"; //Correspond à l'url de notre serveur de presence
+    private static boolean connecte = false; // True si l'utilisateur peut se connecter avec ce nom d'utilisateur , False sinon
+    private ChatApp chatapp;
+
+    /**
+     * <p> Constructeur de la classe HttpEchange</p>
+     * @param chatapp La methode prend toujours en argument un parametre chatApp associe a un utilisateur.
+     */
+    public HttpEchange(ChatApp chatapp){
+        this.chatapp = chatapp;
+    }
+
+    /**
+     * <p> Cette methode permet de communiquer avec le servlet grace a des requetes http de type Post.</p>
+     * @param type Le type de message ("Connexion", "Changement de pseudo" , "Deconnexion") ainsi que les parametres associe
+     * @return True ou False selon la reponse a chaque type de message envoye.
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    public boolean sendPost(String type)  throws IOException, InterruptedException{
+        boolean reussi = false ;
+        if (type.equals("Connexion")){
+            System.out.println("Tentative de connexion distante");
+            HttpClient client = HttpClient.newHttpClient();
+            String requestBody = "Connexion\n" + this.chatapp.getMe().toString() ;
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
+                    .build();
+
+            HttpResponse<String> response = client.send(request,
+                    HttpResponse.BodyHandlers.ofString());
+
+            if(response.body().equals("")){
+                System.out.println("Reponse recue vide");
+            }
+            else {
+                switch (response.body().split("\n")[0]){
+                    case "Reponse Connexion":
+                        reussi = Boolean.parseBoolean(response.body().split("\n")[1]);
+                        System.out.println("Connexion acceptee");
+                        break;
+                    default:
+                        System.out.println("Erreur dans le format de la réponse reçue");
+                }
+            }
+        }
+        else{
+            System.out.println("Erreur de type");
+        }
+        return reussi;
+    }
+
+
+
+
+    /**
+     * Getter
+     * @return le boolean connecte (True s'il peut se connecter avec ce nom d'utilisateur , False sinon)
+     */
+    public static Boolean getConnecte() {
+        return connecte;
+    }
+
+    /**
+     * Setter
+     * @param value La nouvelle valeur du boolean de connexion
+     */
+    public static void setConnecte(Boolean value) {
+        connecte = value ;
+    }
+}

Implementation/src/Model/Historique.java

@@ -0,0 +1,63 @@
+package src.Controller;
+
+import java.util.ArrayList;
+
+/**
+* <p>
+* Classe permettant de sauvegarder les échanges entre deux utilisateurs
+* </p>
+*/
+public class Historique {
+	private Utilisateur User1;
+	private Utilisateur User2;
+	// Liste conservant les differents échanges 
+	private ArrayList<MessageHorodate> HistoriqueHorodate ; 
+	
+	/**
+	* <p>
+	* Constructeur : un historique sauvegarde les echanges entre
+	* User1 et User2
+	* @param User1 - un utilisateur
+	* @param User2 - un second utilisateur
+	* </p>
+	*/
+	public Historique(Utilisateur User1, Utilisateur User2) {
+		this.User1 = User1;
+		this.User2 = User2;
+		this.HistoriqueHorodate = new ArrayList<MessageHorodate>();
+	}
+	
+	/**
+	* <p>
+	* On ajoute un message échangé dans la liste 'HistoriqueHorodate'
+	* 
+	* @param mh - le message horodate échangé
+	* </p>
+	*/
+	public void addMessage(MessageHorodate mh) {
+		this.HistoriqueHorodate.add(mh);
+	}
+
+	/**
+	* <p>
+	* getter pour recuperer le second utilisateur
+	* </p>
+	*/
+	public Utilisateur getUser2() {
+		return User2;
+	}
+	
+	public void afficher10derniers() {
+		System.out.println("Demarrage de l'affichage partiel de l'historique");
+		System.out.println("Il y a actuellement " + HistoriqueHorodate.size() +" elements dans l'historique");
+		int n =10;
+		if(HistoriqueHorodate.size()<=10) {
+			n = HistoriqueHorodate.size();
+		}
+		for(int i = 0; i<n;i++) {
+			String exp = HistoriqueHorodate.get(i).getSource().getPseudo();
+			String payload = HistoriqueHorodate.get(i).getMessage();
+			System.out.println(exp+" : "+payload);
+		}
+	}
+}

Implementation/src/Model/ListUtilisateurs.java

@@ -0,0 +1,125 @@
+package src.Controller;
+
+import java.net.InetAddress;
+import java.util.ArrayList;
+
+public class ListUtilisateurs {
+
+	private ArrayList<Utilisateur> actifUsers ; 
+	
+	public ListUtilisateurs() {
+		this.actifUsers = new ArrayList<Utilisateur>() ;
+	}
+	/**
+     * Ajouter des utilisateurs actifs dans l'attribut liste 'actifUsers'
+     * 
+     * @param u on va rajouter cet utilisateur dans la liste
+     */
+	public void addList(Utilisateur u) {
+		if((verifierUnicite(u.getPseudo()))) {
+			this.actifUsers.add(u);
+		}
+		
+		
+	}
+	
+	/**
+     * Recuperer un utilisateur à partir de son pseudo
+     * 
+     * @param pseudo Pseudo de l'utilisateur que l'on souhaite retrouver
+     */
+	public Utilisateur getPseudoList(String pseudo) {
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 if (elem.getPseudo().equals(pseudo) ) {
+        		 return elem ;
+        	 }
+        }
+		return null ;
+	}
+	
+	public Utilisateur getIPList(InetAddress ip) throws Exception {
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 if (elem.getIp().equals(ip) ) {
+        		 return elem ;
+        	 }
+        }
+		throw new Exception("No such user with this IP address") ;
+	}
+	
+	/**
+     * Supprimer de la liste des utilisateurs actifs 'actifUsers' un certain utilisateur
+     * 
+     * @param u on va supprimer cet utilisateur dans la liste
+     */
+	public void supprimerList(Utilisateur u) {
+		Boolean Sup = false ;
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 if (elem.equals(u) ) {
+        		 this.actifUsers.remove(elem);
+        		 Sup = true ;
+        		 this.afficherListeUtilisateurs();
+        	 }
+        }
+		if (!Sup) {
+		    System.out.println("Tentative de retirer un objet non contenu dans la liste");
+		}
+	}
+	
+	/**
+     * Modifie le nom d'un utilisateur dans la liste des utilisateurs actifs 'actifUsers' 
+     * 
+     * @param ancien correspond au pseudo remplacer
+     * @param nouveau correspond au nouveau pseudo
+     */
+	public void modifierList(String ancien , String nouveau) {
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 if (ancien.equals( elem.getPseudo() ) ) {
+        		 this.actifUsers.remove(elem);
+        		 elem.setPseudo(nouveau);;
+        		 this.addList(elem);
+        		 
+        	 }
+        }
+		this.afficherListeUtilisateurs();
+	} 
+	
+	public Boolean appartient(Utilisateur u) {
+		return this.actifUsers.contains(u);
+	}
+	 
+	
+
+	/**
+     * Verifie qu'aucun autre utilisateur ne possède le même pseudo
+     * 
+     * @param u on va supprimer cet utilisateur dans la liste
+     */
+	public Boolean verifierUnicite(String pseudo) {
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 if (pseudo.equals( elem.getPseudo() ) ) {
+        		 return false ;
+        	 }
+        }
+		return true;
+	}
+	
+	/**
+     * Méthode affichant la liste des utilisateurs actifs
+     * 
+     */
+	public String afficherListeUtilisateurs() {
+		System.out.println ("Liste des utilisateurs actifs : ");
+		String Utilisateur = "" ;
+		for(Utilisateur elem: this.actifUsers)
+        {
+        	 System.out.println (elem.toString());
+        	 Utilisateur += (elem + "\n");
+        }	      
+		return Utilisateur;
+	}
+}

Implementation/src/Model/MessageHorodate.java

@@ -0,0 +1,142 @@
+package src.Controller;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.io.Serializable;
+/**
+* <p>
+* Classe representant les messages envoyés en TCP lors d'une session de clavardage
+* </p>
+*/
+public class MessageHorodate implements Serializable {
+	private Utilisateur destinataire ;
+	private Utilisateur source ;
+	private Date dateHorodatage ;
+	private int type; // 0 = debut de la communication, 1= message de communication, 2 = fin de la communicataion 
+	private String Message;
+	
+	/**
+	* <p>
+	* Constructeur , le message va etre horodate 
+	* @param destinataire - Destinataire du message
+	* @param source - Source du message
+	* @param Message - Message envoye
+	* </p>
+	*/
+	public MessageHorodate(Utilisateur destinataire, Utilisateur source, String Message, int type) {
+		this.setDestinataire(destinataire) ;
+		this.setSource(source) ;
+		this.setMessage(Message) ;
+		this.setDateHorodatage(new Date());
+		this.type = type;
+	}
+	
+	public void setDate(Date d) {
+		this.setDateHorodatage(d);
+	}
+	
+	/**
+	* <p>
+	* permet de creer une representation string du message
+	* @return Les differents attributs de la classe sous forme de string
+	* </p>
+	*/
+	@Override
+	public String toString() {
+		String Msg = "";
+		Msg += ("Destinataire::" + this.getDestinataire() + "\n") ;
+		Msg += ("Source::" + this.getSource()+ "\n") ;
+		Msg += ("Type::"+ this.type+ "\n");
+		Msg += ("Date::" + this.dateToString() + "\n") ;
+		Msg += ("Message::" + this.getMessage() + "\n" );
+		return Msg ;
+	}
+	
+	/**
+	* <p>
+	* permet de creer une representation string de la date d'horodatage
+	* @return La date d'horodatage du message en format yyyy/MM/dd HH:mm:ss
+	* </p>
+	*/
+	public String dateToString() {
+		DateFormat format = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
+		return format.format(this.getDateHorodatage());
+	}
+	
+	
+	/**
+	* <p>
+	* Permet de re creer un message horodate a partir d'un string 
+	* @return un messageHorodate
+	* </p>
+	*/
+	  public static MessageHorodate stringToMessageHorodate(String s) {
+		
+		String mots[] = s.split("\n");
+		Utilisateur destinataire = Utilisateur.stringToUtilisateur(mots[0].split("::")[1]);
+		Utilisateur source = Utilisateur.stringToUtilisateur(mots[1].split("::")[1]);
+		int type = Integer.parseInt(mots[2].split("::")[1]);
+		DateFormat format = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
+		Date date = new Date();
+		/*try {
+			date = format.parse(mots[3].split("::")[1]);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}*/
+		String payload = "";
+		for(int i=4; i< mots.length; i++) {
+			if(mots[i].startsWith("Message::")) {
+				mots[i]=mots[i].split("::")[1];
+			}
+			payload += mots[i]+"\n";
+		}
+		
+		MessageHorodate mh = new MessageHorodate(destinataire, source, payload, type);
+		//mh.setDate(date);
+	
+		return mh ;
+	}
+
+	public Utilisateur getSource() {
+		return source;
+	}
+
+	public void setSource(Utilisateur source) {
+		this.source = source;
+	}
+
+	public Utilisateur getDestinataire() {
+		return destinataire;
+	}
+
+	public void setDestinataire(Utilisateur destinataire) {
+		this.destinataire = destinataire;
+	}
+
+	public String getMessage() {
+		return Message;
+	}
+
+	public void setMessage(String message) {
+		Message = message;
+	}
+	
+	public int getType() {
+		return type;
+	}
+
+	public void setType(int Type) {
+		this.type = type;
+	}
+
+	public Date getDateHorodatage() {
+		return dateHorodatage;
+	}
+
+	public void setDateHorodatage(Date dateHorodatage) {
+		this.dateHorodatage = dateHorodatage;
+	}
+
+}

Implementation/src/Model/Utilisateur.java

@@ -0,0 +1,77 @@
+package src.Controller;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class Utilisateur extends Object {
+
+	private String pseudo ;
+	private Integer port; 
+	private InetAddress ip ; 
+	private String id ; 
+	
+	public Utilisateur(String pseudo,Integer port, InetAddress ip ){
+		this.setPseudo(pseudo) ;
+		this.setPort(port);
+		this.ip = ip ;
+		this.id = ip.getHostName() ;
+	}
+
+	public String getPseudo() {
+		return pseudo;
+	}
+
+	public void setPseudo(String pseudo) {
+		this.pseudo = pseudo;
+	}
+
+	public Integer getPort() {
+		return port;
+	}
+
+	public void setPort(Integer port) {
+		this.port = port;
+	}
+
+	public InetAddress getIp() {
+		return ip;
+	}
+	public String getId() {
+		return id;
+	}
+	
+	@Override
+	public String toString(){
+		String s = "";
+		s+="pseudo " + this.pseudo + " | ";
+		s+="port " + (this.port).toString() + " | ";
+		s+="ip " + (this.ip).toString() + " | ";
+		s+="id " + (this.id).toString() + " | ";
+		return s;
+	}
+	
+	public static Utilisateur stringToUtilisateur(String s) {
+		String name = "";
+		Integer port = 0;
+		String ip = "" ;
+		String id = "";
+		String mots[] = s.split(" ");
+		name=mots[1];
+		port=Integer.parseInt(mots[4]);
+		ip=mots[7];
+		id=mots[10];
+		Utilisateur user = null;
+		try {
+			user = new Utilisateur(name,port,InetAddress.getByName(ip.split("/")[1]));
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		}
+		return user;
+	}
+
+	
+	public Boolean equals(Utilisateur u) {
+		return this.getId().equals( u.getId() ) ;
+	}
+	
+}