Cette fois les 3/4 de la documentation

Business/Manager.cs

@@ -9,22 +9,26 @@ using System.Threading.Tasks;
 
 namespace Business
 {
+
+    /// <summary>
+    ///  Class Manager qui gère les requins, les requins ajoutés, les requins modifiés et les fun facts
+    /// </summary>
     public class Manager
     {
-        public ObservableCollection<Requin> Requins { get; private set; }
+        public ObservableCollection<Requin> Requins { get; private set; }   //ObservableCollection<Requin> les requins qui ont déjà été validés
-        public ObservableCollection<Requin> RequinsEdit { get; private set; }
+        public ObservableCollection<Requin> RequinsEdit { get; private set; }   //ObservableCollection<Requin> les requins qui ont été modifiés par des utilisateurs et qui n'ont pas encore été validés
-        public ObservableCollection<Requin> RequinsAdd { get; private set; }
+        public ObservableCollection<Requin> RequinsAdd { get; private set; }   //ObservableCollection<Requin> les requins qui ont été ajoutés par des utilisateurs et qui n'ont pas encore été validés
-        public Requin SelectedRequin { get; set; }
+        public Requin SelectedRequin { get; set; }  //Requin actuellement utilisé dans l'application
 
 
-        public List<String> FunFacts { get; private set; } = new List<String>();
+        public List<String> FunFacts { get; private set; } = new List<String>();    //List<string> la liste des fun facts
 
 
         /// <summary>
         ///  DéPENDANCE
         /// </summary>
     
-        public IPersistanceManager Pers { get; set; }
+        public IPersistanceManager Pers { get; set; }   //IPersistanceManager ce qui permet de gérer la persistance de l'applcation
 
         /// <summary>
         /// constructeur avec INJECTION DE LA DéPENDANCE
@@ -37,6 +41,10 @@ namespace Business
             RequinsAdd = new ObservableCollection<Requin>();
             Pers = pers;
         }
+
+        /// <summary>
+        /// Méthode LoadRequins de la classe Manager qui permet de remplir les listes de requins grâce à l'IPersistanceManager
+        /// </summary>
         public void LoadRequins()
         {
 
@@ -59,6 +67,10 @@ namespace Business
             }
         }
 
+
+        /// <summary>
+        /// Méthode SaveRequins de la classe Manager qui permet de sauvegarder les listes de requins grâce à l'IPersistanceManager
+        /// </summary>
         public void SaveRequins()
         {
             List<Requin> req = new List<Requin>();
@@ -71,6 +83,12 @@ namespace Business
             Pers.SaveRequins(req, add, edit);
         }
 
+
+        /// <summary>
+        /// Méthode AjouterRequin de la classe Manager qui permet d'ajouter un requin dans la liste des requins
+        /// </summary>
+        /// <param name="req">Requin qui va être ajouté dans la liste</param>
+        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
         public bool AjouterRequin(Requin req)
         {
             Requin test = Requins.SingleOrDefault(r => r.Equals(req));
@@ -82,6 +100,11 @@ namespace Business
             return true;
         }
 
+        /// <summary>
+        /// Méthode SupprimerRequin de la classe Manager qui permet de supprimer un requin de la liste des requins
+        /// </summary>
+        /// <param name="req">Requin qui va être supprimé dans la liste</param>
+        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
         public bool SupprimerRequin(Requin req)
         {
             Requin test = Requins.SingleOrDefault(r => r.Equals(req));
@@ -93,11 +116,24 @@ namespace Business
             return true;
         }
 
+
+        /// <summary>
+        /// Méthode GetRequin de la classe Manager qui permet de récupérer un requin de la liste des requins
+        /// </summary>
+        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
+        /// <returns>Requin trouvé</returns>
         public Requin GetRequin(Requin req)
         {
             return Requins.SingleOrDefault(r => r.Equals(req));
         }
 
+
+        /// <summary>
+        /// Méthode ModifieRequin de la classe Manager qui permet de modifier un ancien requin de la liste des requins à partir d'un nouveau
+        /// </summary>
+        /// <param name="oldR">Requin l'ancien requin dans la liste des requins</param>
+        /// <param name="newR">Requin le nouveau requin</param>
+        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
         public bool ModifieRequin(Requin oldR, Requin newR)
         {
             if (!oldR.Equals(newR))
@@ -109,6 +145,12 @@ namespace Business
             return true;
         }
 
+
+        /// <summary>
+        /// Méthode AjouterRequinEdit de la classe Manager qui permet d'ajouter un requin dans la liste des requins modifiés
+        /// </summary>
+        /// <param name="req">Requin qui va être ajouté dans la liste</param>
+        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
         public bool AjouterRequinEdit(Requin req)
         {
             Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
@@ -121,6 +163,11 @@ namespace Business
             return true;
         }
 
+        /// <summary>
+        /// Méthode SupprimerRequinEdit de la classe Manager qui permet de supprimer un requin de la liste des requins modifiés
+        /// </summary>
+        /// <param name="req">Requin qui va être supprimé dans la liste</param>
+        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
         public bool SupprimerRequinEdit(Requin req)
         {
             Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
@@ -133,6 +180,11 @@ namespace Business
         }
 
 
+        /// <summary>
+        /// Méthode AjouterRequinAdd de la classe Manager qui permet d'ajouter un requin dans la liste des requins ajoutés
+        /// </summary>
+        /// <param name="req">Requin qui va être ajouté dans la liste</param>
+        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
         public bool AjouterRequinAdd(Requin req)
         {
             Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
@@ -145,6 +197,12 @@ namespace Business
             return true;
         }
 
+
+        /// <summary>
+        /// Méthode SupprimerRequinAdd de la classe Manager qui permet de supprimer un requin de la liste des requins ajoutés
+        /// </summary>
+        /// <param name="req">Requin qui va être supprimé dans la liste</param>
+        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
         public bool SupprimerRequinAdd(Requin req)
         {
             Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
@@ -156,21 +214,41 @@ namespace Business
             return true;
         }
 
+
+        /// <summary>
+        /// Méthode GetRequinEdit de la classe Manager qui permet de récupérer un requin de la liste des requins modifiés
+        /// </summary>
+        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
+        /// <returns>Requin trouvé</returns>
         public Requin GetRequinEdit(Requin req)
         {
             return RequinsEdit.SingleOrDefault(r => r.Equals(req));
         }
 
+
+        /// <summary>
+        /// Méthode GetRequinAdd de la classe Manager qui permet de récupérer un requin de la liste des requins ajoutés
+        /// </summary>
+        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
+        /// <returns>Requin trouvé</returns>
         public Requin GetRequinAdd(Requin req)
         {
             return RequinsAdd.SingleOrDefault(r => r.Equals(req));
         }
 
-        public List<Requin> rechercherRequins(ObservableCollection<Requin> lRech, Nullable<Zone> zone, String motif)
+
+        /// <summary>
+        /// Méthode RechercherRequins qui permet de rechercher des requins dans une ObservableCollection<Requin> en fonction de leurs zones et d'un motif
+        /// </summary>
+        /// <param name="lRech">ObservableCollection<Requin> dans laquelle on fait la recherche</param>
+        /// <param name="motif">string sur lequel on fait la recherche</param>
+        /// <param name="zone">Zone? sur laquelle on fait la recherche</param>
+        /// <returns>List<Requin> contenant tous les requins trouvés en fonction du motif et de la zone</returns>
+        public List<Requin> RechercherRequins(ObservableCollection<Requin> lRech, Nullable<Zone> zone, string motif)
         {
             List<Requin> nvReq = new List<Requin>();
             int test = 0;
-            if (!String.IsNullOrWhiteSpace(motif))
+            if (!string.IsNullOrWhiteSpace(motif))
             {
                 foreach (Requin req in lRech)
                 {
@@ -201,6 +279,10 @@ namespace Business
             return nvReq;
         }
 
+        /// <summary>
+        /// Méthode vérifierRequin qui permet de vérifiersi les strings que l'on donnerait au constructeur de requin son vides
+        /// </summary>
+        /// <returns>Booléen : true si il n'y en a pas de vide, false sinon</returns>
         public bool verifierRequin(String nom, String nomSci, String description, String photo, String video, String photoCarte)
         {
             if (String.IsNullOrWhiteSpace(nom) || String.IsNullOrWhiteSpace(nomSci) || String.IsNullOrWhiteSpace(description) || String.IsNullOrWhiteSpace(photo)
@@ -212,6 +294,9 @@ namespace Business
         }
 
 
+        /// <summary>
+        /// Méthode LoadFunFacts de la classe Manager qui permet de charger la liste de fun facts grâce à l'IPersistanceManager
+        /// </summary>
         public void LoadFunFacts()
         {
             FunFacts.Clear();
@@ -222,7 +307,9 @@ namespace Business
             }
         }
 
-
+        /// <summary>
+        /// Méthode LoadFunFacts de la classe Manager qui permet de sauvegarder la liste de fun facts grâce à l'IPersistanceManager
+        /// </summary>
         public void SaveFunFacts()
         {
             Pers.SaveFunFacts(FunFacts);

Business/ManagerUsers.cs

@@ -32,6 +32,10 @@ namespace Business
             Pers = pers;
         }
 
+
+        /// <summary>
+        /// Méthode LoadUsers de la classe ManagerUser qui permet de charger les liste d'Utilisateurs et d'Experts grâce à l'IPersistanceManager
+        /// </summary>
         public void LoadUsers()
         {
 
@@ -50,13 +54,20 @@ namespace Business
 
         }
 
-
+        /// <summary>
+        /// Méthode SaveUsers de la classe ManagerUser qui permet de sauvegarder les listes d'Utilisateurs et d'Experts grâce à l'IPersistanceManager
+        /// </summary>
         public void SaveUsers()
         {
             Pers.SaveUsers(Utilisateurs, Experts);
         }
 
 
+        /// <summary>
+        /// Méthode AjouterUtilisateur de la classe ManagerUser qui permet d'ajouter un Utilisateur dans la liste d'Utilisateurs
+        /// </summary>
+        /// <param name="user">Utilisateur qui va être ajouté dans la liste</param>
+        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
         public bool AjouterUtilisateur(Utilisateur user)
         {
             if (Utilisateurs.Contains(user))
@@ -68,6 +79,11 @@ namespace Business
             return true;
         }
 
+        /// <summary>
+        /// Méthode SupprmierUtilisateur de la classe ManagerUser qui permet de supprimer un Utilisateur de la liste des Utilisateurs 
+        /// </summary>
+        /// <param name="user">Utilisateur qui va être supprimé dans la liste</param>
+        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
         public bool SupprimerUtilisateur(Utilisateur user)
         {
             if (!Utilisateurs.Contains(user))
@@ -79,6 +95,11 @@ namespace Business
         }
 
 
+        /// <summary>
+        /// Méthode AjouterExpert de la classe ManagerUser qui permet d'ajouter un Expert dans la liste d'Experts
+        /// </summary>
+        /// <param name="expert">Expert qui va être ajouté dans la liste</param>
+        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
         public bool AjouterExpert(Expert expert)
         {
             if (Experts.Contains(expert))
@@ -90,6 +111,11 @@ namespace Business
             return true;
         }
 
+        /// <summary>
+        /// Méthode SupprmierExpertr de la classe ManagerUser qui permet de supprimer un Expert de la liste des Experts 
+        /// </summary>
+        /// <param name="expert">Expert qui va être supprimé dans la liste</param>
+        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
         public bool SupprimerExpert(Expert expert)
         {
             if (!Experts.Contains(expert))
@@ -100,11 +126,24 @@ namespace Business
             return true;
         }
 
-        public Personne GetUtilisateur(Personne user)
+
+        /// <summary>
+        /// Méthode GetPersonne de la classe ManagerUser qui permet de récupérer une personne dans la liste de personne (Expert et Utilisateur)
+        /// </summary>
+        /// <param name="pers">Personne que l'on cherche dans dans la liste</param>
+        /// <returns>Personne trouvée</returns>
+        public Personne GetPersonne(Personne pers)
         {
-            return Utilisateurs.SingleOrDefault(r => r.Equals(user));
+            return Utilisateurs.SingleOrDefault(r => r.Equals(pers));
         }
 
+
+        /// <summary>
+        /// Méthode ModifieUtilisateur de la classe ManagerUser qui permet de modifier un ancien Utilisateur de la liste des Utilisateurs à partir d'un nouveau
+        /// </summary>
+        /// <param name="oldU">Utilisateur l'ancien Utilisateur dans la liste des utilisateurs</param>
+        /// <param name="newU">Utilisateur le nouvel requin</param>
+        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
         public bool ModifieUtilisateur(Utilisateur oldU, Utilisateur newU)
         {
             if (!oldU.Equals(newU))
@@ -117,6 +156,12 @@ namespace Business
         }
 
 
+        /// <summary>
+        /// Méthode ModifieExpert de la classe ManagerUser qui permet de modifier un ancien Expert de la liste des Experts à partir d'un nouveau
+        /// </summary>
+        /// <param name="oldE">Expert l'ancien Expert dans la liste des experts</param>
+        /// <param name="newE">Expert le nouveau Expert</param>
+        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
         public bool ModifieExpert(Expert oldE, Expert newE)
         {
             if (!oldE.Equals(newE))

Modèle/Carte.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Modèle
-{
-    public class Carte
-    {
-        public string Nom { get; private set; }
-        public string Url { get; private set; }
-        public List<Zone> LaZone { get; private set; }
-
-    }
-    
-}

Modèle/Conservation.cs

@@ -7,6 +7,10 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+    /// <summary>
+    ///  Type énuméré qui contient tous les status de conservation des espèces animales.
+    /// </summary>
+
     [DataContract]
     public enum Conservation
     {

Modèle/Expert.cs

@@ -8,31 +8,64 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+
+    /// <summary>
+    ///  Class Expert qui implémente l'interface Personne
+    ///  Un expert peut ajouter et modifier des requins mais il peut aussi valider ou refuser les ajouts ou les modifications des utilisateurs
+    /// </summary>
+
+
     [DataContract]
     public class Expert : Personne
     {
         [DataMember]
-        public DateTime DateD { get; private set; }
+        public DateTime DateD { get; private set; }  //DateTime qui permet de connaitre la date de création x'un compte expert
         [DataMember]
-        public string Surnom { get; private set; }
+        public string Surnom { get; private set; }  //String le surnom d'un expert
 
+
+        /// <summary>
+        ///  Constructeur sans DateTime
+        /// </summary>
+        /// <param name="email">String email de l'Expert (son identifiant pour se connecter</param>
+        /// <param name="mdp"> String le mot de passe de l'Expert</param>
+        /// <param name="surnom">String surnom de l'Expert</param>
         public Expert(string email, string mdp, string surnom) : base(email, mdp)
         {
             Surnom = surnom;
             DateD = DateTime.Now;
         }
 
+        /// <summary>
+        ///  Constructeur avec DateTime
+        /// </summary>
+        /// <param name="email">String email de l'Expert (son identifiant pour se connecter</param>
+        /// <param name="mdp"> String le mot de passe de l'Expert</param>
+        /// <param name="surnom">String surnom de l'Expert</param>
+        /// <param name="date">Date de création du compte Expert</param>
         public Expert(string email, string mdp, string surnom, DateTime date) : base(email, mdp)
         {
             Surnom = surnom;
             DateD = date;
         }
 
+
+
+        /// <summary>
+        ///  Méthode ToString de la classe Expert
+        /// </summary>
         public override string ToString()
         {
-            return Email + " " + MotDePasse + " " + Surnom + " " + DateD;
+            return Email + " "  + " " + Surnom + " " + DateD;
         }
 
+        /// <summary>
+        ///  Méthode de test lors de la création de la class Expert qui permettait de valider ou de refuser des requins ajoutés par les utilisateurs
+        /// </summary>
+        /// <param name="lBdPasFinie">List<Requin> qui est la list contenant tout les requins ajoutés par des Utilisateurs</param>
+        /// <param name="lBdFinie">List<Requin> qui est la list contenant tout les requins validés par les experts</param>
+        /// <returns>Int : Le nombre changement validé</returns>
+
         public int ValiderSubmit(List<Requin> lBdFinie, List<Requin> lBdPasFinie)
         {
             int i=0;
@@ -64,6 +97,12 @@ namespace Modèle
         }
 
 
+        /// <summary>
+        /// Méthode de test lors de la création de la class Expert qui permettait de valider ou de refuser des requins édités par les utilisateurs
+        /// </summary>
+        /// <param name="lBdPasFinie">List<Requin> qui est la list contenant tout les requins ajoutés par des Utilisateurs</param>
+        /// <param name="lBdFinie">List<Requin> qui est la list contenant tout les requins validés par les experts</param>
+        /// <returns>Int : Le nombre changement validé</returns>
         public int ValiderUnChangement(List<Requin> lBdFinie, List<Requin> lBdPasfinie)
         {
             int i = 0;
@@ -95,17 +134,32 @@ namespace Modèle
             return i;
         }
 
-
+        /// <summary>
+        /// Méthode Equals de la Class Expert qui permet de savoir si deux experts sont égaux, regarde en fonction des emails
+        /// </summary>
+        /// <param name="e">Expert</param>
+        /// <returns>Booléen : true si elles sont égales, false si elles sont différentes</returns>
         public bool Equals(Expert e)
         {
             return Email == e.Email;
         }
 
+
+        /// <summary>
+        /// Méthode qui permet d'ajouter un Requin dans une ObservableCollection de Requin
+        /// </summary>
+        /// <param name="req">Requin qui va être ajouté dans l'observable collection</param>
+        /// <param name="requins">ObservableCollection<Requin> l'ObservableCollection dans laquelle on ajoute le Requin</param>
         public override void AjouterRequin(Requin req, ObservableCollection<Requin> requins) 
         {
             requins.Add(req);
         }
 
+
+        /// <summary>
+        /// Méthode qui permet de changer le mot de passe de l'Expert
+        /// </summary>
+        /// <param name="nvMdp">String nouveau mot de passe de l'Expert</param>
         public override void ChangerMotDePasse(string nvMdp)
         {
             MotDePasse = nvMdp;

Modèle/Personne.cs

@@ -8,24 +8,48 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+
+    /// <summary>
+    /// Interface Personne qui est la base des utilisateurs de l'application
+    /// </summary>
+
     [DataContract]
     public abstract class Personne
     {
         [DataMember]
-        public string Email { get; protected set; }
+        public string Email { get; protected set; }     //String email d'une Personne
         [DataMember]
-        public string MotDePasse { get; protected set; }
+        public string MotDePasse { get; protected set; }    //String mot de passe d'une Personne
 
+
+        /// <summary>
+        /// Constructeur d'une personne
+        /// </summary>
+        /// <param name="email">String l'email de la personne qui va être créée</param>
+        /// <param name="mdp">String le mot de passe de la personne</param>
         public Personne(string email, string mdp)
         {
             Email = email;
             MotDePasse = mdp;
         }
 
+        /// <summary>
+        /// Création de la méthode abstraite ToString
+        /// </summary>
         public abstract override string ToString();
 
+        /// <summary>
+        /// Création de la méthode abstraite AjouterRequin qui permet d'ajouter un Requin dans une ObservableCollection de Requin
+        /// </summary>
+        /// <param name="req">Requin le requin a ajouter</param>
+        /// <param name="requins">ObservableCollection la où on ajoute le requin</param>
         public abstract void AjouterRequin(Requin req, ObservableCollection<Requin> requins);
 
+
+        /// <summary>
+        /// Création de la méthode abstraite ChangerMotDePasse qui permet de changer le mot de passe d'un personne
+        /// </summary>
+        /// <param name="nvMdp">String le nouveau mot de passe d'un Personne</param>
         public abstract void ChangerMotDePasse(string nvMdp);
     }
 }

Modèle/Position.cs

@@ -6,19 +6,32 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+
+    /// <summary>
+    /// Classe Position qui permet de connaitre la surface de répartition d'un requin
+    /// Cependant nous n'avons pas eu le temps d'implémenter cette classe dans les requins
+    /// </summary>
     public class Position
     {
-        public float LattitudeDeb { get; set; }
+        public float LattitudeDeb { get; set; }     //Int lattitude la plus faible
-        public float LattitudeFin { get; set; }
+        public float LattitudeFin { get; set; }     //Int lattitude la plus haute
-        public float LongitudeDeb { get; set; }
+        public float LongitudeDeb { get; set; }     //Int longitude la plus faible
-        public float LongitudeFin { get; set; }
+        public float LongitudeFin { get; set; }     //Int longitude la plus haute
 
 
+        /// <summary>
+        /// Méthode Equals qui permet de savoir si une position est égale à une autre
+        /// </summary>
+        /// <param name="p">Position</param>
+        /// <returns>Booléen : true si elles sont égales, false si elles sont différentes</returns>
         public bool Equals(Position p)
         {
             return p.LattitudeDeb == LattitudeDeb && p.LattitudeFin == LattitudeFin && p.LongitudeDeb == LongitudeDeb && p.LongitudeFin == LongitudeFin;
         }
 
+        /// <summary>
+        /// Constructeur d'une Position
+        /// </summary>
 
         public Position(int lDeb, int lFin, int longDeb, int longFin)
         {

Modèle/Requin.cs

@@ -7,29 +7,45 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+
+    /// <summary>
+    /// Classe Requin qui impléemente la méthode IEquatable<Requin>
+    /// </summary>
     [DataContract]
     public class Requin : IEquatable<Requin>
     {
         [DataMember]
-        public string Nom { get; private set; }
+        public string Nom { get; private set; } //string le nom du requin
         [DataMember]
-        public string NomSci { get; private set; }
+        public string NomSci { get; private set; }  //string le nom scientifique du requin
         [DataMember]
-        public string Description { get; private set; }
+        public string Description { get; private set; } //string la description du requin
         [DataMember]
-        public string Photo { get; private set; }
+        public string Photo { get; private set; }   //string l'URL de la photo du requin
         [DataMember]
-        public string Video { get; private set; }
+        public string Video { get; private set; }   //string le chemin de la vidéo du requin
         [DataMember]
-        public string PhotoCarte { get; private set; }
+        public string PhotoCarte { get; private set; }  //string l'URL de la photo de la carte de répartition du requin
         [DataMember]
-        public Conservation StatutCons { get; private set; }
+        public Conservation StatutCons { get; private set; }    //Conservation le statut de conservation du requin
         [DataMember]
-        public string FunFact { get; private set; }
+        public string FunFact { get; private set; } //string fun fact sur les requins
         [DataMember]
-        public List<Zone> Repartition { get; private set; }
+        public List<Zone> Repartition { get; private set; } //List<Zone> la répartition du requin sur la planète
 
 
+        /// <summary>
+        /// Constructeur du requin avec fun fact
+        /// </summary>
+        /// <param name="nom">string le nom du requin</param>
+        /// <param name="nomSci">string le nom scientifique du requin</param>
+        /// <param name="description">string la description du requin</param>
+        /// <param name="photo">string l'URL de la photo du requin</param>
+        /// <param name="video">string le chemin de la vidéo du requin</param>
+        /// <param name="photoCarte">string l'URL de la photo de la carte de répartition du requin</param>
+        /// <param name="statutCons">Conservation le statut de conservation du requin</param>
+        /// <param name="repartition">List<Zone> la répartition du requin sur la planète</param>
+        /// <param name="funFact">string fun fact sur les requins</param>
         public Requin(string nom, string nomSci, string description, string photo, string video, string photoCarte, Conservation statutCons, List<Zone> repartition, string funFact) {
             Nom = nom;
             NomSci = nomSci;
@@ -42,6 +58,18 @@ namespace Modèle
             FunFact = funFact;
         }
 
+        /// <summary>
+        /// Constructeur du requin sans fun fact qui génère donc une fun fact aléatoire depuis une liste de fun fact
+        /// </summary>
+        /// <param name="nom">string le nom du requin</param>
+        /// <param name="nomSci">string le nom scientifique du requin</param>
+        /// <param name="description">string la description du requin</param>
+        /// <param name="photo">string l'URL de la photo du requin</param>
+        /// <param name="video">string le chemin de la vidéo du requin</param>
+        /// <param name="photoCarte">string l'URL de la photo de la carte de répartition du requin</param>
+        /// <param name="statutCons">Conservation le statut de conservation du requin</param>
+        /// <param name="repartition">List<Zone> la répartition du requin sur la planète</param>
+        /// <param name="funFacts">List<string> list de fun facts</param>
         public Requin(string nom, string nomSci, string description, string photo, string video, string photoCarte, Conservation statutCons, List<Zone> repartition, List<string> funFacts)
         {
             Random rnd = new Random();
@@ -57,18 +85,28 @@ namespace Modèle
             FunFact = funFacts[num];
         }
 
+
+        /// <summary>
+        /// Méthode ToString de la classe Requin
+        /// </summary>
         public override string ToString()
         {
             return Nom + " " + NomSci + " " + Description + " " + StatutCons + " " + FunFact + " " + Photo;
         }
 
 
-
+        /// <summary>
+        /// Méthode Equals de la classe Requin qui permet de savoir si deux requins sont égaux, regarde l'égalité en fonction des noms et des nom scientifiques
+        /// </summary>
         public bool Equals(Requin r)
         {
             return r.Nom == Nom && r.NomSci == NomSci;
         }
 
+
+        /// <summary>
+        /// Méthode ToString de la classe Requin qui permet l'implémentation de la méthode IEquatable<Requin>
+        /// </summary>
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(obj, null)) return false;
@@ -77,6 +115,10 @@ namespace Modèle
             return Equals(obj as Requin);
         }
 
+
+        /// <summary>
+        /// Méthode GetHashCode de la classe Requin qui permet de récupérer le hash code d'un requin avec son nom et son nom scientifique
+        /// </summary>
         public override int GetHashCode()
         {
             return Nom.GetHashCode() ^ NomSci.GetHashCode();

Modèle/UCrequinType.cs

@@ -6,6 +6,9 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+    /// <summary>
+    /// Type énuméré qui permet de savoir si un UserControlRequin et de type normal, édité ou ajouté
+    /// </summary>
     public enum UCrequinType
     {
         normal,

Modèle/Utilisateur.cs

@@ -8,38 +8,69 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+
+    /// <summary>
+    /// Classe Utilisateur qui implémente l'interface Personne
+    /// </summary>
     [DataContract]
     public class Utilisateur : Personne
     {
         [DataMember]
-        public int NbSubmit { get; private set; }
+        public int NbSubmit { get; private set; }   //int qui permet de savoir le nombre d'ajouts et de modifications qu'à fait un utilisateur
+
+        /// <summary>
+        /// Constructeur d'utilisateur sans nombre de submits
+        /// </summary>
+        /// <param name="mail">string l'email de l'utilisateur</param>
+        /// <param name="mdp">string mot de passe de l'utilisateur</param>
         public Utilisateur(string mail, string mdp): base(mail, mdp)
         {
             NbSubmit = 0;
         }
+        /// <summary>
+        /// Constructeur d'utilisateur avec nombre de submits
+        /// </summary>
+        /// <param name="mail">string l'email de l'utilisateur</param>
+        /// <param name="mdp">string mot de passe de l'utilisateur</param>
+        /// <param name="nbSubmit">int le nombre de submits de l'utilisateur</param>
         public Utilisateur(string mail, string mdp, int nbSubmit): base(mail, mdp) 
         {
             NbSubmit = nbSubmit;
         }
 
+        /// <summary>
+        /// Méthode ToString de la classe Utilisateur
+        /// </summary>
         public override string ToString()
         {
-            return Email + " " + MotDePasse + " " + NbSubmit;
+            return Email + " " + NbSubmit;
         }
 
-
+        /// <summary>
+        /// Méthode Equals de la classe Utilisateur qui regarde en fonction des emails
+        /// </summary>
+        /// <param name="u">Utilisateur</param>
+        /// <returns>Booléen : true si ils sont égaux, false si ils sont différents</returns>
         public bool Equals(Utilisateur u)
         {
             return Email == u.Email;
         }
 
-
+        /// <summary>
+        /// Méthode qui permet d'ajouter un Requin dans une ObservableCollection de Requin et d'augmenter le nombre de submits de 1
+        /// </summary>
+        /// <param name="req">Requin qui va être ajouté dans l'observable collection</param>
+        /// <param name="requins">ObservableCollection<Requin> l'ObservableCollection dans laquelle on ajoute le Requin</param>
         public override void AjouterRequin(Requin req, ObservableCollection<Requin> requins)
         {
             requins.Add(req);
             NbSubmit++;
         }
 
+        /// <summary>
+        /// Méthode qui permet de changer le mot de passe de l'Utilisateur
+        /// </summary>
+        /// <param name="nvMdp">String nouveau mot de passe de l'Utilisateur</param>
         public override void ChangerMotDePasse(string nvMdp)
         {
             MotDePasse = nvMdp;

Modèle/Zone.cs

@@ -7,6 +7,9 @@ using System.Threading.Tasks;
 
 namespace Modèle
 {
+    /// <summary>
+    ///  Type énuméré qui contient les océans où il y a des requins
+    /// </summary>
     [DataContract]
     public enum Zone
     {

WpfApp1/AddAShark.xaml.cs

@@ -18,6 +18,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour AddAShark.xaml
+    /// Page qui permet à un utilisateur d'ajouter un requin
     /// </summary>
     public partial class AddAShark : Window
     {
@@ -29,11 +30,11 @@ namespace WpfApp1
 
         }
 
-        public Manager Mgr => (Application.Current as App).LeManager;
+        public Manager Mgr => (Application.Current as App).LeManager; //Manager lié à celui de l'app
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
 
-        private List<Conservation> consList = new List<Conservation>
+        private List<Conservation> consList = new List<Conservation>    //List<Conservation> contenant toutes les conservations
         {
             Conservation.EX,
             Conservation.EW,
@@ -46,14 +47,24 @@ namespace WpfApp1
             Conservation.NE
         };
 
-
+        /// <summary>
+        /// Evénement ExitClick qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
 
+        /// <summary>
+        /// Evénement SubmitClick qui permet d'ajouter un requin depuis la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void submit_Click(object sender, RoutedEventArgs e)
         {
+            //Récupération de toutes les valeurs rentrées par l'utilisateur
             Conservation cons = new Conservation();
             List<Zone> lesZones = new List<Zone>();
             string nom = name.LeContenu.Text;
@@ -63,14 +74,15 @@ namespace WpfApp1
             string video = lienVid.LeContenu.Text;
             string map = lienMap.LeContenu.Text;
             string fun = funny.LeContenu.Text;
+            int testCons = 0;
 
-
+            //Récupération du statut de conservation rentré par l'utilisateur
             foreach (Control control in this.radioButtons.Children)
             {
                 if (control is RadioButton)
                 {
                     RadioButton radio = control as RadioButton;
-                    if (radio.IsChecked == true)
+                    if (radio.IsChecked == true)    //Obligation de regardé si c'est ==true car IsChecked return un Nullable
                     {
                         if (radio.Content is string radString)
                         {
@@ -79,7 +91,8 @@ namespace WpfApp1
                                 if (radString == conserv.ToString())
                                 {
                                     cons = conserv;
-                                    goto loopEnd;
+                                    testCons = 1;   //Permet de savoir que la conservation a bien été rentrée
+                                    goto loopEnd;   //Permet de sortir de toutes les boucles quand on a trouvé la conservation
                                 }
                             }
                         }
@@ -89,13 +102,13 @@ namespace WpfApp1
             loopEnd:
 
 
-            if (!video.Contains("Videos/"))
+            if (!video.Contains("Videos/")) //test si la vidéo vient bien du répetoire Vidéos (Nous n'avons pas eu le temps d'ajouter la fonctionalités pour les vidéos depuis internet)
             {
                 MessageBox.Show("Les vidéos doivent venir obligatoirement du répertoire Videos");
                 return;
             }
 
-
+            //Test pour voir quels zones sont cochées
             if (Arct.IsChecked == true)
             {
                 lesZones.Add(Zone.ARCTIQUE);
@@ -113,15 +126,33 @@ namespace WpfApp1
                 lesZones.Add(Zone.PACIFIQUE);
             }
 
-            if (lesZones.Count() == 0 || string.IsNullOrWhiteSpace(nom) || string.IsNullOrWhiteSpace(sciNam) || string.IsNullOrWhiteSpace(descri)
+            //Test pour voir si toutes les informations ont été rentrées
-                || string.IsNullOrWhiteSpace(photo) || string.IsNullOrWhiteSpace(video) || string.IsNullOrWhiteSpace(map) || string.IsNullOrWhiteSpace(fun))
+            if (lesZones.Count() == 0 || Mgr.verifierRequin(nom, sciNam, descri, photo, video, map) == false || testCons==0)
             {
                 MessageBox.Show("Veuillez remplir toutes les informations");
                 return;
             }
             else
+            {
+                // Test pour voir si la fun fact est vide
+                if (string.IsNullOrWhiteSpace(fun))
+                {
+                    //Si elle est vide alors on crée le requin avec la liste de fun facts
+                    Requin requin = new Requin(nom, sciNam, descri, photo, video, map, cons, lesZones, Mgr.FunFacts);
+                    //Test pour savoir si l'utilisateur est un Expert ou un Utilisateur
+                    if (MgrUser.SelectedUser is Utilisateur user)
+                    {
+                        user.AjouterRequin(requin, Mgr.RequinsAdd); //Ajout dans la liste d'ajout
+                    }
+                    else if (MgrUser.SelectedUser is Expert exp)
+                    {
+                        exp.AjouterRequin(requin, Mgr.Requins); //Ajout directement dans la liste de requin validé
+                    }
+                }
+                else
                 {
                     Requin requin = new Requin(nom, sciNam, descri, photo, video, map, cons, lesZones, fun);
+                    //Pareil que la boucle du dessus
                     if (MgrUser.SelectedUser is Utilisateur user)
                     {
                         user.AjouterRequin(requin, Mgr.RequinsAdd);
@@ -130,6 +161,8 @@ namespace WpfApp1
                     {
                         exp.AjouterRequin(requin, Mgr.Requins);
                     }
+                }
+                
                 Close();
                 
             }

WpfApp1/ChangerMotDePasse.xaml.cs

@@ -17,6 +17,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour ChangerMotDePasse.xaml
+    /// Page qui permet à un utilisateur de changer son mot de passe
     /// </summary>
     public partial class ChangerMotDePasse : Window
     {
@@ -25,14 +26,21 @@ namespace WpfApp1
             InitializeComponent();
         }
 
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
+
+        /// <summary>
+        /// Evénement qui permet de valider le changement du mot de passe
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void valider_Click(object sender, RoutedEventArgs e)
         {
             if (verifierConf())
             {
                 if (verifierAncienMdp())
                 {
+                    //Change le mot de passe de l'utilisateur
                     MgrUser.SelectedUser.ChangerMotDePasse(nvMdp.Password);
                     Close();
                 }
@@ -47,16 +55,30 @@ namespace WpfApp1
             }
         }
 
+        /// <summary>
+        /// Méthode qui vérifie que le mot de passe et le même que celui de la confirmation
+        /// </summary>
+        /// <returns>Booléen : true si ils sont égaux, false sinon</returns>
         private bool verifierConf()
         {
             return nvMdp.Password == confMdp.Password;
         }
 
+        /// <summary>
+        /// Méthode qui vérifie que l'ancien mot de passe et bien le mot de passe actuel de l'utilisateur
+        /// </summary>
+        /// <returns>Booléen : true si ils sont égaux, false sinon</returns>
         private bool verifierAncienMdp()
         {
             return ancienMdp.Password == MgrUser.SelectedUser.MotDePasse;
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();

WpfApp1/CreerCompte.xaml.cs

@@ -18,6 +18,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour CreerCompte.xaml
+    /// Page qui permet à un utilisateur de créer un compte
     /// </summary>
     public partial class CreerCompte : Window
     {
@@ -26,13 +27,24 @@ namespace WpfApp1
             InitializeComponent();
         }
 
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
+
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
 
+        /// <summary>
+        /// Evénement qui permet d'ouvrir la page de connection
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Connection_Click(object sender, RoutedEventArgs e)
         {
             var connectWindow = new SeConnecter();
@@ -40,22 +52,32 @@ namespace WpfApp1
             connectWindow.ShowDialog();
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de créer un compte utilisateur
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void inscription_Click(object sender, RoutedEventArgs e)
         {
+            //Récupère les informations rentrées par l'utilisateur
             string mail = email.LeContenu.Text;
             string password = mdp.Password;
             string conf = reMdp.Password;
+            //TEst si les mots de passe sont identiques
             if (password != conf)
             {
                 MessageBox.Show("Les mots de passe doivent être identiques");
             }
-            if (string.IsNullOrWhiteSpace(mail) && string.IsNullOrWhiteSpace(password))
+            //Test si toutes les informations ont été rentrées
+            else if (string.IsNullOrWhiteSpace(mail) && string.IsNullOrWhiteSpace(password))
             {
                 MessageBox.Show("Veuillez remplir toutes les cases");
             }
             else
             {
                 Utilisateur user = new Utilisateur(mail, password);
+                //Test si l'utilisateur a bien été créé et ajout"
                 if (MgrUser.AjouterUtilisateur(user))
                 {
                     MgrUser.SelectedUser = user;

WpfApp1/DescriptionAdd.xaml

@@ -5,7 +5,7 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:WpfApp1"
         mc:Ignorable="d"
-        Title="Description" Height="450" Width="800">
+        Title="Description" Height="550" Width="800">
     <DockPanel>
         <Grid DockPanel.Dock="Top">
             <Image Source="Images\Logo_entier.png" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="0,10,0,10" Height="40" Stretch="Uniform" StretchDirection="Both"></Image>

WpfApp1/DescriptionAdd.xaml.cs

@@ -19,6 +19,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour Description.xaml
+    /// Page qui affiche la description d'un requin de la liste des requins ajoutéss
     /// </summary>
     public partial class DescriptionAdd : Window
     {
@@ -28,13 +29,13 @@ namespace WpfApp1
         }
 
 
-        public Manager Mgr => (Application.Current as App).LeManager;
+        public Manager Mgr => (Application.Current as App).LeManager;   //Manager lié à celui de l'app
 
 
 
 
         private Requin _requin;
-        public Requin requin
+        public Requin requin    //requin sur lequel se base l'affichage de la page
         {
             get { return _requin; }
             set
@@ -44,6 +45,11 @@ namespace WpfApp1
             }
         }
 
+        /// <summary>
+        /// Méthode qui permet de transformer un url venant d'internet en BitmapImage
+        /// </summary>
+        /// <param name="url"></param>
+        /// <returns>BitmapImage la nouvel BitmapImage créée à partir de du string</returns>
         private BitmapImage urlEnBitmap(string url)
         {
             var path = @url;
@@ -54,9 +60,15 @@ namespace WpfApp1
             return bitmap;
         }
 
+
+        /// <summary>
+        /// Méthode qui met à jour toutes les informations sur la page grace au requin
+        /// </summary>
+        /// <param name="requin"></param>
         public void uptadeUi(Requin requin)
         {
-            string url = "Images/" + requin.StatutCons.ToString() + ".png";
+            string url = "Images/" + requin.StatutCons.ToString() + ".png"; //Transforme la conservation en chemin pour l'image liée à cette conservation
+            //Met à jour tous texteBlocks
             nameReq.Text = requin.Nom;
             sciName.Text = requin.NomSci;
             desc.Text = requin.Description;
@@ -64,19 +76,21 @@ namespace WpfApp1
             funFact.Text = requin.FunFact;
             consPic.Source = new BitmapImage(new Uri(url, UriKind.RelativeOrAbsolute));
 
-
+            //Vérifie si la photo vient d'internet ou du dossier
-            if (requin.Photo.Contains("Images/"))   //Vérifie si la photo vient d'internet ou du dossier
+            if (requin.Photo.Contains("Images/"))
             {
+                //Si elle vient d'internet alors on la transforme directement en BitmapImage
                 photo.Source = new BitmapImage(new Uri(requin.Photo, UriKind.RelativeOrAbsolute));
             }
             else
             {
+                //Sinon appelle la fonction urlEnBitmap
                 BitmapImage bitmap = new BitmapImage();
                 bitmap = urlEnBitmap(requin.Photo);
                 photo.Source = bitmap;
             }
 
-
+            //Pareil que les tests du dessus
             if (requin.PhotoCarte.Contains("Images/"))
             {
                 cartePic.Source = new BitmapImage(new Uri(requin.PhotoCarte, UriKind.RelativeOrAbsolute));
@@ -89,11 +103,21 @@ namespace WpfApp1
             }
         }
 
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
 
+        /// <summary>
+        /// Evénement qui permet d'ajouter le requin dans la Liste des requins validé
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void valider_Click(object sender, RoutedEventArgs e)
         {
             Mgr.AjouterRequin(requin);
@@ -101,6 +125,12 @@ namespace WpfApp1
             Close();
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de refuser le requin et donc de le supprimer de la liste des requins ajoutés
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void refuser_Click(object sender, RoutedEventArgs e)
         {
             Mgr.SupprimerRequinAdd(requin);

WpfApp1/DescriptionEdit.xaml.cs

@@ -18,6 +18,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour DescriptionEdit.xaml
+    /// Page qui affiche la description d'un requins de la liste des requins modifiés avec la description du requin de base
     /// </summary>
     public partial class DescriptionEdit : Window
     {
@@ -26,9 +27,9 @@ namespace WpfApp1
             InitializeComponent();
         }
 
-        public Manager Mgr => (Application.Current as App).LeManager;
+        public Manager Mgr => (Application.Current as App).LeManager;   //Manager lié à celui de l'app
 
-        private Requin _requin;
+        private Requin _requin; //requin sur lequel se base l'affichage de la partie droite de la page
         public Requin requin
         {
             get { return _requin; }
@@ -40,7 +41,7 @@ namespace WpfApp1
         }
 
 
-        private Requin _requinOld;
+        private Requin _requinOld;  //requin sur lequel se base l'affichage de la partie gauche de la page
 
         public Requin requinOld
         {
@@ -51,7 +52,11 @@ namespace WpfApp1
                 uptadeUiOld(_requinOld);
             }
         }
-
+        /// <summary>
+        /// Méthode qui permet de transformer un url venant d'internet en BitmapImage
+        /// </summary>
+        /// <param name="url"></param>
+        /// <returns>BitmapImage la nouvel BitmapImage créée à partir de du string</returns>
         private BitmapImage urlEnBitmap(string url)
         {
             var path = @url;
@@ -62,28 +67,35 @@ namespace WpfApp1
             return bitmap;
         }
 
-
+        /// <summary>
-        public void uptadeUi(Requin requin)
+        /// Méthode qui met à jour toutes les informations de la partie droite grace au requin
+        /// </summary>
+        /// <param name="requin"></param>
+        private void uptadeUi(Requin requin)
         {
-            string url = "Images/" + requin.StatutCons.ToString() + ".png";
+            string url = "Images/" + requin.StatutCons.ToString() + ".png"; //Transforme la conservation en chemin pour l'image liée à cette conservation
+            //Met à jour tous texteBlocks
             nameReq.Text = requin.Nom;
             sciName.Text = requin.NomSci;
             desc.Text = requin.Description;
             vid.Source = new Uri(requin.Video, UriKind.RelativeOrAbsolute);
             funFact.Text = requin.FunFact;
             consPic.Source = new BitmapImage(new Uri(url, UriKind.RelativeOrAbsolute));
+
             if (requin.Photo.Contains("Images/"))   //Vérifie si la photo vient d'internet ou du dossier
             {
+                //Si elle vient d'internet alors on la transforme directement en BitmapImage
                 photo.Source = new BitmapImage(new Uri(requin.Photo, UriKind.RelativeOrAbsolute));
             }
             else
             {
+                //Sinon appelle la fonction urlEnBitmap
                 BitmapImage bitmap = new BitmapImage();
                 bitmap = urlEnBitmap(requin.Photo);
                 photo.Source = bitmap;
             }
 
-
+            //Pareil que les tests du dessus
             if (requin.PhotoCarte.Contains("Images/"))
             {
                 cartePic.Source = new BitmapImage(new Uri(requin.PhotoCarte, UriKind.RelativeOrAbsolute));
@@ -97,7 +109,11 @@ namespace WpfApp1
         }
 
 
-        public void uptadeUiOld(Requin oldRequin)
+        /// <summary>
+        /// Fait la même chose que updateUi mais pour l'ancien requin donc la partie gauche
+        /// </summary>
+        /// <param name="oldRequin"></param>
+        private void uptadeUiOld(Requin oldRequin)
         {
             string url = "Images/" + oldRequin.StatutCons.ToString() + ".png";
             nameReqOld.Text = oldRequin.Nom;
@@ -130,6 +146,12 @@ namespace WpfApp1
             }
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de modifier l'ancien requin en le remplaçant par le nouveau et donc l'enlève de la liste des requins modifiés et le rajoute dans la lsite des requins validés
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void remplacer_Click(object sender, RoutedEventArgs e)
         {
             Mgr.ModifieRequin(requinOld, requin);
@@ -137,12 +159,24 @@ namespace WpfApp1
             Close();
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de refuser la modification et donc supprime le requin de la liste des requins modifiés
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void garder_Click(object sender, RoutedEventArgs e)
         {
             Mgr.SupprimerRequinEdit(requin);
             Close();
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();

WpfApp1/InfoUtilisateur.xaml.cs

@@ -18,6 +18,7 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour InfoUtilisateur.xaml
+    /// Page qui permet à un utilisateur de voir ses informations
     /// </summary>
     public partial class InfoUtilisateur : Window
     {
@@ -27,10 +28,10 @@ namespace WpfApp1
             InitializeComponent();
         }
 
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
         private Personne _pers;
-        public Personne pers
+        public Personne pers    //L'utilisateur qui permettra de mettre les informations de la page à jour
         {
             get { return _pers; }
             set
@@ -40,7 +41,10 @@ namespace WpfApp1
             }
         }
 
-
+        /// <summary>
+        /// Méthode qui permet de mettre à jour les informations de la page
+        /// </summary>
+        /// <param name="pers"></param>
         private void UpdateUi(Personne pers)
         {
             mdp.Text = "";
@@ -60,17 +64,35 @@ namespace WpfApp1
             }
         }
 
+
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
 
+
+        /// <summary>
+        /// Evénement qui permet à l'utilisateur de se déconnecter
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void deco_Click(object sender, RoutedEventArgs e)
         {
             Close();
             MgrUser.SelectedUser = null;
         }
 
+
+        /// <summary>
+        /// Evénement qui permet d'ouvrir la page ChangerMotDePasse
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void changer_Click(object sender, RoutedEventArgs e)
         {
             var changerWindow = new ChangerMotDePasse();

WpfApp1/MainWindow.xaml.cs

@@ -20,19 +20,19 @@ namespace WpfApp1
 {
     /// <summary>
     /// Interaction logic for MainWindow.xaml
+    /// Page principal de CShark 
     /// </summary>
-    /// 
 
 
 
     public partial class MainWindow : Window
     {
-        public Manager Mgr => (Application.Current as App).LeManager;
+        public Manager Mgr => (Application.Current as App).LeManager;   //Manager lié à celui de l'app
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
-        Nullable<Zone> zonePage{ get; set; }
+        Nullable<Zone> zonePage{ get; set; }    //Zone qui permet de connaitre la zone de la comboBox
 
-        public bool aChanger = false;
+        public bool aChanger = false;   //Booléen qui permet de savoir si l'utilisateur a déjà changer la zone de la listBox
 
         public MainWindow()
         {
@@ -47,17 +47,30 @@ namespace WpfApp1
 
         }
 
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'ObservableCollection change pour  mettre à jour l'affichage
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Requins_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
             chargerUC();
         }
 
+
+        /// <summary>
+        /// Evénement qui est déclenché lorsque la sélection de la comboBox a été changée pour mettre à jour l'affichage
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Region_SelectionChanged(object sender, SelectionChangedEventArgs e)
         {
             ChangeRegion();
         }
 
-
+        /// <summary>
+        /// Méthode qui permet de changer zonePage et l'affichage de la page
+        /// </summary>
         private void ChangeRegion()
         {
             if (Region.SelectedIndex == 0)
@@ -91,7 +104,10 @@ namespace WpfApp1
             }
         }
 
-
+        /// <summary>
+        /// Méthode qui permet de changer la sélection de la comboBox, zonePage et l'affichage de la page
+        /// </summary>
+        /// <param name="z"></param>
         public void ChangeRegionAvecMap(Nullable<Zone> z)
         {
             if (z == null)
@@ -118,26 +134,41 @@ namespace WpfApp1
             ChangerAffichage(z);
         }
 
-
+        /// <summary>
+        /// Méthode qui permet de changer le content control en userControlDescription
+        /// </summary>
+        /// <param name="req"></param>
         public void ContentControlSwapDes(Requin req)
         {
             contentControl.Content = new userControlDescription { requin = req };
         }
 
 
-
+        /// <summary>
+        /// Méthode qui permet de changer le content control en userControlAcceuil
+        /// </summary>
         public void ContentControlSwapAcc()
         {
 
-            contentControl.Content = new userControlAcceuil();
+            contentControl.Content = new userControlAcceuil { zone = zonePage };
         }
 
 
+        /// <summary>
+        /// Méthode qui permet de changer le content control en userControlEdit
+        /// </summary>
+        /// <param name="req"></param>
         public void ContentControlSwapEdit(Requin req)
         {
             contentControl.Content = new UserControlEdit { requin = req };
         }
 
+
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'utilisateur qui sur la barre de Recherche et permet d'effacer le text "Rechercher" lorsque l'utilisateur qui sur la barre de Recherche
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void TextBox_IsKeyboardFocusedChanged(object sender, DependencyPropertyChangedEventArgs e)
         {
             if (Rechercher.Text == "Rechercher")
@@ -146,7 +177,11 @@ namespace WpfApp1
             }
         }
 
-        public void chargerUC()
+
+        /// <summary>
+        /// Méthode qui permet de charger les userControlRequin dans la listBox
+        /// </summary>
+        private void chargerUC()
         {
             viderListBox();
             foreach (Requin req in Mgr.Requins)
@@ -155,6 +190,11 @@ namespace WpfApp1
             }
         }
 
+
+        /// <summary>
+        /// Méthode qui permet de changer l'affichage de la page en fonction d'une zone donnée
+        /// </summary>
+        /// <param name="zone"></param>
         private void ChangerAffichage(Nullable<Zone> zone)
         {
             int test = 0;
@@ -174,27 +214,31 @@ namespace WpfApp1
                 }
                 if (test > 0)
                 {
+                    //Ajoute un userControlRequin si le requin a bien une zone en commun avec la zone donnée en paramètre
                     laListe.Items.Add(new UserControlRequin { requin = req });
                 }
                 test = 0;
             }
+            //Change le content control en userControlAcceuil
             contentControl.Content = new userControlAcceuil { zone = zone };
         }
 
-        public void viderListBox()
+        /// <summary>
-        {
+        /// Méthode qui permet de vider la listBox
-            if (laListe != null)
+        /// </summary>
-            {
+        private void viderListBox()
-                while (laListe.Items.Count > 0)
         {
-                    laListe.Items.RemoveAt(0);
+            laListe.Items.Clear();
-                }
         }
-        }
-
 
 
    
+        /// <summary>
+        /// Evénement qui est déclenché quand l'utilisateur écrit une lettre dans la barre de rechercher
+        /// Permet de d'ajouter des userControlRequin dans la listBox en fonction du motif rentré par l'utilisateur
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Rechercher_KeyUp(object sender, KeyEventArgs e)
         {
             viderListBox();
@@ -202,7 +246,7 @@ namespace WpfApp1
             string rech = Rechercher.Text;
             if (!string.IsNullOrWhiteSpace(rech))
             {
-                nvReq = Mgr.rechercherRequins(Mgr.Requins, zonePage, rech);
+                nvReq = Mgr.RechercherRequins(Mgr.Requins, zonePage, rech);
                 foreach(Requin req in nvReq)
                 {
                     laListe.Items.Add(new UserControlRequin { requin = req });

WpfApp1/SeConnecter.xaml.cs

@@ -18,11 +18,12 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour SeConnecter.xaml
+    /// Page qui permet à l'utilisateur de se connecter
     /// </summary>
     public partial class SeConnecter : Window
     {
 
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;     //Manager lié à celui de l'app
         public SeConnecter()
         {
             InitializeComponent();
@@ -30,11 +31,21 @@ namespace WpfApp1
             DataContext = MgrUser;
         }
 
+        /// <summary>
+        /// Evénement qui permet de quitter la page
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void exit_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
 
+        /// <summary>
+        /// Evénement qui permet d'ouvrir la page CreerCompte et de fermer celle la
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Inscription_Click(object sender, RoutedEventArgs e)
         {
             var inscrireWindow = new CreerCompte();
@@ -42,29 +53,40 @@ namespace WpfApp1
             inscrireWindow.ShowDialog();
         }
 
+
+
+        /// <summary>
+        /// Evénement qui permet à l'utilisateur de ce connecter quand il a rentré son email et son mot de passe
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void connect_Click(object sender, RoutedEventArgs e)
         {
+            //Récupère les informations rentrées par l'utilisateur
             string email = mail.LeContenu.Text;
             string password = mdp.Password;
+            //Regarde si elles ne sont pas vides
             if (string.IsNullOrWhiteSpace(email) || string.IsNullOrWhiteSpace(password))
             {
                 MessageBox.Show("Veuillez remplir toutes les cases");
                 return;
             }
+            //Cherche dans la liste d'Utilisateur si un Utilisateur à cette email et ce mot de passe
             foreach(Personne p in MgrUser.Utilisateurs)
             {
                 if (p.Email==email && password == p.MotDePasse)
                 {
-                    MgrUser.SelectedUser = p;
+                    MgrUser.SelectedUser = p;   //Le selectedUser de ManagerUser devient maintenant l'Utilisateur connecté
                     Close();
                     return;
                 }
             }
+            //Fais de même pour la liste d'Expert
             foreach(Personne p in MgrUser.Experts)
             {
                 if (p.Email==email && p.MotDePasse == password)
                 {
-                    MgrUser.SelectedUser = p;
+                    MgrUser.SelectedUser = p;   //Le selectedUser de ManagerUser devient maintenant l'Expert connecté
                     Close();
                     return;
                 }

WpfApp1/UserControlEdit.xaml.cs

@@ -142,6 +142,7 @@ namespace WpfApp1
                                 if (radString == conserv.ToString())
                                 {
                                     cons = conserv;
+                                    test++;
                                     goto loopEnd ;
                                 }
                             }
@@ -160,33 +161,29 @@ namespace WpfApp1
 
             if (Arct.IsChecked == true)
             {
-                test++;
                 lesZones.Add(Zone.ARCTIQUE);
             }
             if (Atla.IsChecked == true)
             {
-                test++;
                 lesZones.Add(Zone.ATLANTIQUE);
             }
             if (Indi.IsChecked == true)
             {
-                test++;
                 lesZones.Add(Zone.INDIEN);
             }
             if (Paci.IsChecked == true)
             {
-                test++;
                 lesZones.Add(Zone.PACIFIQUE);
             }
 
-            if (test == 0 || lesZones==null || Mgr.verifierRequin(nom, sciNam, descri, photo, video, map)==false)
+            if (test == 0 || lesZones.Count()==0 || Mgr.verifierRequin(nom, sciNam, descri, photo, video, map)==false)
             {
                 MessageBox.Show("Veuillez remplir tout les champs obligatoires");
             }
 
             else if (string.IsNullOrWhiteSpace(fun))
             {
-                Requin req = new Requin(nom, sciNam, descri, photo, video, map, cons, lesZones, fun);
+                Requin req = new Requin(nom, sciNam, descri, photo, video, map, cons, lesZones, Mgr.FunFacts);
                 if (MgrUser.SelectedUser is Utilisateur user)
                 {
                     user.AjouterRequin(req, Mgr.RequinsEdit);
@@ -195,6 +192,7 @@ namespace WpfApp1
                 {
                     Mgr.ModifieRequin(Mgr.Requins.SingleOrDefault(r => r.Equals(req)), req);
                 }
+                ((MainWindow)System.Windows.Application.Current.MainWindow).ContentControlSwapDes(requin);
             }
             else
             {
@@ -207,8 +205,9 @@ namespace WpfApp1
                 {
                     Mgr.ModifieRequin(Mgr.Requins.SingleOrDefault(r => r.Equals(req)), req);
                 }
-            }
                 ((MainWindow)System.Windows.Application.Current.MainWindow).ContentControlSwapDes(requin);
             }
+            
+        }
     }
 }

WpfApp1/WpfApp1.csproj

@@ -34,6 +34,9 @@
     <None Remove="Images\User.png" />
     <None Remove="Images\VU.png" />
     <None Remove="Images\White_shark.png" />
+    <None Remove="Videos\GrandRequinBlanc.mp4" />
+    <None Remove="Videos\Le requin Renard.mp4" />
+    <None Remove="Videos\Le requin-bouledogue.mp4" />
     <None Remove="Videos\requin_Asley.mp4" />
     <None Remove="Videos\shrekin.mp4" />
     <None Remove="Videos\Vid-dormeur-mexicain.mp4" />
@@ -99,6 +102,15 @@
     <Content Include="Images\White_shark.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Videos\GrandRequinBlanc.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Videos\Le requin Renard.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Videos\Le requin-bouledogue.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Videos\requin_Asley.mp4">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>

WpfApp1/userControlAcceuil.xaml

@@ -35,7 +35,24 @@
                     <RowDefinition/>
                 </Grid.RowDefinitions>
                 <Image Source="Images\cartemaismieuxman.png" x:Name="laCarte" Grid.ColumnSpan="5" Grid.RowSpan="4"/>
-                <TextBlock MouseDown="Arctique_MouseDown" Grid.ColumnSpan="5"/>
+                <Grid Grid.ColumnSpan="5">
+                    <Grid.RowDefinitions>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                    </Grid.ColumnDefinitions>
+                    <TextBlock MouseDown="Arctique_MouseDown" Grid.ColumnSpan="5" Grid.Row="0"/>
+                    <TextBlock MouseDown="Pacifique_MouseDown" Grid.Row="1" Grid.Column="0"/>
+                    <TextBlock MouseDown="Pacifique_MouseDown" Grid.Row="1" Grid.Column="4"/>
+                    <TextBlock MouseDown="Atlantique_MouseDown" Grid.Row="1" Grid.Column="1"/>
+                </Grid>
+                
                 <TextBlock MouseDown="Pacifique_MouseDown" Grid.RowSpan="3" Grid.Row="1"/>
                 <TextBlock MouseDown="Pacifique_MouseDown" Grid.Row="1" Grid.Column="5" Grid.RowSpan="3"/>
                 <TextBlock MouseDown="Indien_MouseDown" Grid.Row="2" Grid.Column="3" Grid.RowSpan="2"/>

WpfApp1/userControlAcceuil.xaml.cs

@@ -19,19 +19,21 @@ namespace WpfApp1
 {
     /// <summary>
     /// Logique d'interaction pour userControlAcceuil.xaml
+    /// UserControl qui permet d'afficher la carte du monde et le bandeau de l'application
     /// </summary>
     public partial class userControlAcceuil : UserControl
     {
-        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers;
+        public ManagerUsers MgrUser => (Application.Current as App).LeManagerUsers; //Manager lié à celui de l'app
 
         public userControlAcceuil()
         {
             InitializeComponent();
         }
 
+
         public string Carte
         {
-            set
+            set //set qui permet de modifier directement la source de l'image
             {
                 laCarte.Source = new BitmapImage(new Uri(value, UriKind.Relative));
             }
@@ -39,7 +41,7 @@ namespace WpfApp1
 
 
         private Nullable<Zone> _zone;
-        public Nullable<Zone> zone
+        public Nullable<Zone> zone  //Zone qui permet d'appeler la méthode choixCarte quand elle est modifiée
         {
             get { return _zone; }
             set
@@ -53,20 +55,27 @@ namespace WpfApp1
 
 
 
-
+        /// <summary>
+        /// Evénement qui permet d'ouvrir la page AddAShark
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void add_Click(object sender, RoutedEventArgs e)
         {
+            //Test pour voir si l'utilisateur est connecté
             if (MgrUser.SelectedUser == null)
             {
                 MessageBox.Show("Vous avez besoin d'être connecté pour accéder à cette fonctionnalité");
                 var seConnecter = new SeConnecter();
                 seConnecter.ShowDialog();
             }
+            //Test pour voir si c'est un Utilisateur
             else if (MgrUser.SelectedUser is Utilisateur)
             {
                 var addSharkWindow = new AddAShark();
                 addSharkWindow.ShowDialog();
             }
+            //Test pour voir si c'est un Expert pour ouvrir la page ValiderSubmit au lieu de AddAShark
             else if (MgrUser.SelectedUser is Expert)
             {
                 var validerSumbit = new ValiderSubmit();
@@ -76,15 +85,23 @@ namespace WpfApp1
 
         }
 
+        /// <summary>
+        /// Evénement qui permet d'ouvrir soit la page CreerCompte soit InfoUtilisateur
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Inscription_Click(object sender, RoutedEventArgs e)
         {
+            //Test pour voir si l'utilisateur est connecté
             if (MgrUser.SelectedUser == null)
             {
+                //Si il ne l'est pas ouvre la page CreerCompte
                 var inscrireWindow = new CreerCompte();
                 inscrireWindow.ShowDialog();
             }
             else
             {
+                //Si il l'est ouvre la page InfoUtilisateur
                 var infoUser = new InfoUtilisateur{ pers = MgrUser.SelectedUser };
                 infoUser.ShowDialog();
             }
@@ -92,24 +109,52 @@ namespace WpfApp1
 
         
        
-
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'utilisateur appouye sur une partie de la carte correspondant à l'océan Arctique
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Arctique_MouseDown(object sender, MouseButtonEventArgs e)
         {
+            //Appelle la fonction ChangeRegionAvecMap de la main window
             ((MainWindow)System.Windows.Application.Current.MainWindow).ChangeRegionAvecMap(Zone.ARCTIQUE);
         }
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'utilisateur appouye sur une partie de la carte correspondant à l'océan Atlantique
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Atlantique_MouseDown(object sender, MouseButtonEventArgs e)
         {
+            //Appelle la fonction ChangeRegionAvecMap de la main window
             ((MainWindow)System.Windows.Application.Current.MainWindow).ChangeRegionAvecMap(Zone.ATLANTIQUE);
         }
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'utilisateur appouye sur une partie de la carte correspondant à l'océan Indien
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Indien_MouseDown(object sender, MouseButtonEventArgs e)
         {
+            //Appelle la fonction ChangeRegionAvecMap de la main window
             ((MainWindow)System.Windows.Application.Current.MainWindow).ChangeRegionAvecMap(Zone.INDIEN);
         }
+        /// <summary>
+        /// Evénement qui est déclenché lorsque l'utilisateur appouye sur une partie de la carte correspondant à l'océan Pacifique
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private void Pacifique_MouseDown(object sender, MouseButtonEventArgs e)
         {
+            //Appelle la fonction ChangeRegionAvecMap de la main window
             ((MainWindow)System.Windows.Application.Current.MainWindow).ChangeRegionAvecMap(Zone.PACIFIQUE);
         }
 
+
+        /// <summary>
+        /// Méthode qui permet de changer la source de la carte en fonction de la zone donnée en paramètre
+        /// </summary>
+        /// <param name="zone"></param>
         private void choixCarte(Nullable<Zone> zone)
         {
             if (zone == null)