diff --git a/app.js b/app.js
index 2da02f2..89199dd 100644
--- a/app.js
+++ b/app.js
@@ -5,19 +5,17 @@ const cookieParser = require('cookie-parser');
 const app = express();
 const mongoose = require('mongoose');
 const cors = require('cors')
-const User = require('./models/user');
-const Groupe = require('./models/groupe');
+const User = require('./models/user'); // model "User" de la DB
+const Groupe = require('./models/groupe'); // model "Groupe" de la DB
 const jwt = require('jsonwebtoken');
 
 // routage pour le chemin /signup et /signin
 const connexionRoutes = require('./routes/user');
-//const appRoutes = require()
 
 // fonction pour vérifier si la personne est connecté
 const authController = require('./controllers/auth');
 const user = require('./models/user');
 
-
 // initialisation body parser pour récupérer donné au format json
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: false }))
@@ -29,11 +27,11 @@ app.use(cookieParser());
 app.use(
     cors({
         origin: 'http://localhost:3000',
-        credentials: true
+        credentials: true // laisser passer les cookie entre différent url
     })
 );
 
-//connection DB
+//connection à mongoDB
 mongoose.connect('mongodb+srv://ichat:LjfNhCj0YwwryZiF@cluster0.uzln9.mongodb.net/<dbname>?retryWrites=true&w=majority', {
         useCreateIndex: true,
         useNewUrlParser: true,
@@ -46,10 +44,6 @@ mongoose.connect('mongodb+srv://ichat:LjfNhCj0YwwryZiF@cluster0.uzln9.mongodb.ne
 // routeur réunissant /authentification/signin et /authentification/signup
 app.use('/authentification', connexionRoutes);
 
-// test
-app.post('/test', (req, res, next) => {
-    console.log(req.body)
-})
 
 // vérification si la personne possède les cookie de conneion, avec middelware analysant ceci
 app.post('/auth', authController.withAuth, (req, res, next) => {
@@ -58,195 +52,208 @@ app.post('/auth', authController.withAuth, (req, res, next) => {
 
 
 
-// test d'ajout d'amis dans la base de donné pour un utilisateur précis
-const secret = "clef-secret";
+// récupere le nombre de message envooyé entre deux personnes
+const secret = "clef-secret"; // clef de JsonWebToken
 app.use('/app/statByUser', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, async function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
             try {
+                // récupère les donné du groupe voulue
                 const GroupeDocs = await Groupe.find({ "membres._id": decoded.userId })
                 const statistique = []
+                    // boucle qui récupère chaque groupe où est présent le user
                 for (let i = 0; i < GroupeDocs.length; i++) {
-                    let nbr_message = GroupeDocs[i].message.length
-                    let friend_id = GroupeDocs[i].membres.filter(friend => friend._id != decoded.userId)
-                    const pseudoFriend = await User.find({ _id: friend_id[0]._id })
-                    let friendName = pseudoFriend[0].pseudo
-                    statistique.push({ friend_name: friendName, nbr_message: nbr_message })
+                    let nbr_message = GroupeDocs[i].message.length // récupère le nopmbre de message dans le groupe
+                    let friend_id = GroupeDocs[i].membres.filter(friend => friend._id != decoded.userId) // récupère l'id de l'ami qui est dans le groupe avec le user
+                    const pseudoFriend = await User.find({ _id: friend_id[0]._id }) // cherche l'id de l'ami dans la DB
+                    let friendName = pseudoFriend[0].pseudo // prend le pseudo de l'ami
+                    statistique.push({ friend_name: friendName, nbr_message: nbr_message }) // stocke dans une Array le nom de l'ami et le nombre de message
                 }
-                res.status(200).json(statistique)
+                res.status(200).json(statistique) // retourne l'array "statistique"
             } catch (err) {
-                res.status(401).json({ err })
+                res.status(401).json({ err }) // renvois une erreur
             }
         }
     })
 });
+
+// change le pseudo d'une personne
 app.use('/app/changeName', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, async function(err, decoded) {
         if (err) {
             console.log("here")
             res.status(401).send({ error: "invalide token" });
         } else {
             try {
-                let doc = await User.findOneAndUpdate({ _id: decoded.userId }, { pseudo: req.body.newName });
+                let doc = await User.findOneAndUpdate({ _id: decoded.userId }, { pseudo: req.body.newName }); // cherche le user qu'il faut changer de nom
                 console.log(doc.pseudo)
-                res.status(200).send({ message: 'OK' })
+                res.status(200).send({ message: 'OK' }) // renvois le message 'OK' si la modification à bien été effectué
             } catch (err) {
-                res.status(401).json({ err })
+                res.status(401).json({ err }) // renvois une erreur en cas d'échec
             }
         }
     });
 })
+
+// récupère la liste d'ami d'un utilisateur
 app.use('/app/friendlist', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, async function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
             try {
-                const UserDocs = await User.findOne({ _id: decoded.userId })
+                const UserDocs = await User.findOne({ _id: decoded.userId }) // cherche l'utilisateur dans la DB
                 let data = []
-                for (let i = 0; i < UserDocs.friends.length; i++) {
-                    let friendid = UserDocs.friends[i]._id
-                    const GetFriendName = await User.find({ _id: friendid })
-                    data.push({ id: friendid, pseudo: GetFriendName[0].pseudo })
+                for (let i = 0; i < UserDocs.friends.length; i++) { // boucle qui fait le tour de chaque ami
+                    let friendid = UserDocs.friends[i]._id // récupère l'ID de l'ami [i]
+                    const GetFriendName = await User.find({ _id: friendid }) // cherche dans la DB l'ami grace à son ID
+                    data.push({ id: friendid, pseudo: GetFriendName[0].pseudo }) // ajoute l'ID de l'ami et son pseudo dans une Array
                 }
-                res.status(200).send({ data: data, firstFriend: UserDocs.friends[0]._id, pseudo: UserDocs.pseudo })
+                res.status(200).send({ data: data, firstFriend: UserDocs.friends[0]._id, pseudo: UserDocs.pseudo }) // retourne le la liste d'ami, l'id du première ami et le pseudo de l'utilisateur
             } catch (err) {
-                res.status(401).json({ err })
+                res.status(401).json({ err }) // retourne une erreur
             }
         }
     });
 });
 
+// récupère le nom d'un ami
 app.use('/app/getFriendName', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
             //console.log("decoded id : ", decoded)
             // si les cookie sont validé, passé à la prochaine fonction grâce à "next()"
-            User.findOne({ _id: req.body.name }, function(err, docs) {
+            User.findOne({ _id: req.body.name }, function(err, docs) { // cherche un ami grâce à son id
                 if (err) {
                     res.status(401).send({ error })
                 } else {
-                    res.json(docs.pseudo)
+                    res.json(docs.pseudo) // renvois le pseudo de l'ami rechercher
                 }
             });
         }
     });
 })
 
-
-
+// cherche le groupe dans la DB celon l'id du User et de son ami
 app.use('/app/getgroupeid', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
-            //console.log("decoded id : ", decoded)
-            // si les cookie sont validé, passé à la prochaine fonction grâce à "next()"
-            Groupe.find({ $and: [{ "membres._id": decoded.userId }, { "membres._id": req.body.friendID }] }, function(err, docs) {
+            Groupe.find({ $and: [{ "membres._id": decoded.userId }, { "membres._id": req.body.friendID }] }, function(err, docs) { // cherche groupe possédant l'id de l'utilisateur et l'id de l'ami
                 if (err) {
                     console.log("problem is here")
                     res.status(401).send({ error })
                 } else {
                     //console.log("le groupe : ", docs)
-                    res.json(docs)
+                    res.json(docs) // renvois le groupe trouvé
                 }
             })
         }
     });
 })
+
+// récupere la liste des messages dans un groupe
 app.use('/app/getgroupechatlist', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
-            //console.log("decoded id : ", decoded)
-            // si les cookie sont validé, passé à la prochaine fonction grâce à "next()"
-            Groupe.find({ $and: [{ "membres._id": decoded.userId }, { "membres._id": req.body.friendID }] }, function(err, docs) {
+            Groupe.find({ $and: [{ "membres._id": decoded.userId }, { "membres._id": req.body.friendID }] }, function(err, docs) { // cherche un groupe ou les membres sont composé de l'utilisateur et l'id de son ami
                 if (err) {
                     console.log("problem is here")
                     res.status(401).send({ error })
                 } else {
-                    //console.log("le groupe : ", docs)
-                    res.json(docs)
+                    res.json(docs) // renvois la collection du groupe
                 }
             })
         }
     });
 })
 
+
+// cherche le nom d'une personne grâce à son id
 app.use('/app/getname', authController.withAuth, (req, res, next) => {
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     jwt.verify(token, secret, function(err, decoded) {
         if (err) {
             res.status(401).send({ error: "invalide token" });
         } else {
-            //console.log("decoded id : ", decoded)
-            // si les cookie sont validé, passé à la prochaine fonction grâce à "next()"
-            User.find({ _id: decoded.userId }, function(err, docs) {
+            User.find({ _id: decoded.userId }, function(err, docs) { // cherche un User avec un ID donné
                 if (err) {
                     console.log(err)
                 } else if (docs == null) {
-                    res.status(400).send({ error: "introuvable" });
+                    res.status(400).send({ error: "introuvable" }); // renvois une erreur comme quoi la personne recherché est introuvable
                 } else {
-                    res.json(docs.pseudo)
+                    res.json(docs.pseudo) // renvois le pseudo de la personne cherché
                 }
             })
         }
     });
 })
+
+// ajout d'un amis
 app.post('/app/newfriend', authController.withAuth, (req, res, next) => {
-    console.log("demande d'amis à " + req.body.new_friend)
+    console.log("demande d'ami à " + req.body.new_friend);
+    // récupère le cookie "token"
     const token =
         req.body.token ||
         req.query.token ||
         req.headers['x-access-token'] ||
         req.cookies.token;
-
+    // si il y a des cookies, vérifier s'ils sont encore valide avec la fonction du package JSONwebtoken
     User.findOne({ pseudo: req.body.new_friend }, function(err, docs) {
         if (err) {
             console.log(err)
@@ -254,20 +261,20 @@ app.post('/app/newfriend', authController.withAuth, (req, res, next) => {
             res.status(400).send({ error: "introuvable" });
         } else {
             //console.log("user findone", docs)
-            const friendID = docs._id
+            const friendID = docs._id // récupère l'ID de l'amis
             jwt.verify(token, secret, function(err, decoded) {
                 if (err) {
                     res.status(401).send({ error: "invalide token" });
                 } else {
-                    User.findOne({ _id: decoded.userId, "friends._id": friendID }, function(err, docs) {
+                    User.findOne({ _id: decoded.userId, "friends._id": friendID }, function(err, docs) { // cherche l'utilisateur avec son ID et voir s'il a déja en amis la personne recherché
                         if (err) {
                             console.log(err)
-                        } else if (docs == null) {
+                        } else if (docs == null) { // Si pas d'utilisateur trouvé, alors la personne recherché n'est pas encore son amis
                             const userID = decoded.userId
-                            User.updateOne({
+                            User.updateOne({ // modifie la collection de l'utilisateur 
                                 _id: decoded.userId
                             }, {
-                                $push: {
+                                $push: { // ajout du nouvel amis avec son id et son prénom
                                     friends: {
                                         _id: friendID,
                                         _pseudo: req.body.new_friend
@@ -277,16 +284,15 @@ app.post('/app/newfriend', authController.withAuth, (req, res, next) => {
                                 if (err) {
                                     console.log(err)
                                 } else {
-                                    //console.log("docs1 update : ", docs)
-                                    User.findOne({ _id: userID }, function(err, docs) {
+                                    User.findOne({ _id: userID }, function(err, docs) { // cherche l'utilisateur dans la DB 
                                         if (err) {
                                             console.log(err)
                                         } else {
-                                            const userPseudo = docs.pseudo
-                                            User.updateOne({
+                                            const userPseudo = docs.pseudo // récupère le pseudo de l'utilisateur
+                                            User.updateOne({ // modifie la collection de l'ami
                                                 _id: friendID,
                                             }, {
-                                                $push: {
+                                                $push: { // ajoute l'utilisateur en amis
                                                     friends: {
                                                         _id: userID,
                                                         _pseudo: userPseudo
@@ -301,25 +307,26 @@ app.post('/app/newfriend', authController.withAuth, (req, res, next) => {
                                             })
                                         }
                                     })
-                                    res.status(200).send({ message: "demande d'amis envoyé" })
+                                    res.status(200).send({ message: "demande d'amis envoyé" }) // renvois que la demande d'avis a été envoyé
+                                        // création d'un nouveau groupe composé de l'utilisateur et de son amis ajouté
                                     const groupe = new Groupe({
                                         membres: [
                                             { _id: friendID },
                                             { _id: userID }
                                         ]
                                     })
-                                    groupe.save()
+                                    groupe.save() // enregistre le nouveau groupe
                                         .then(() => {
                                             console.log("groupe créer")
-                                            res.status(200)
+                                            res.status(200) // renvois un status 200 (succes) pour montrer qu'il n'y a pas d'erreur
                                         })
                                         // renvois éventuelles érreurs
-                                        .catch(error => res.status(401));
+                                        .catch(error => res.status(401)); // renvois une erreur en cas d'échec d'enregistrement
                                 }
                             })
                         } else {
-                            res.status(402).send({ error: "utilisateur déja amis" })
-                            console.log("c est deja ton amis zbi")
+                            res.status(402).send({ error: "utilisateur déja ami" }) // si trouvé la collection de l'utilisateur avers la personne rechercher déja son ami
+                            console.log("c est deja ton amis")
                         }
                     })
                 }
diff --git a/controllers/user.js b/controllers/user.js
index fc71dca..e9e25c8 100644
--- a/controllers/user.js
+++ b/controllers/user.js
@@ -1,12 +1,14 @@
+// import les models de la base de donnée
 const User = require('../models/user');
-const Groupe = require('../models/groupe')
+const Groupe = require('../models/groupe');
+// importation des packages
 const bcrypt = require('bcrypt');
 const jwt = require('jsonwebtoken');
 
 
 exports.signup = (req, res, next) => {
-    console.log(req.body)
-        // récupérer les données suivantes
+    console.log(req.body);
+    // récupérer les données suivantes
     let email = req.body.email;
     let pseudo = req.body.pseudo;
     let mdp = req.body.mdp;
@@ -21,13 +23,14 @@ exports.signup = (req, res, next) => {
                 _pseudo: "Equipe iChat"
             }
         });
-
+        // ajout utilisateur dans la base de donnée
         user.save()
             // crétion de la session qui exprire dans 1h
             .then(() => {
                 const token = jwt.sign({ userId: user._id }, secret, {
                     expiresIn: '1h'
                 });
+                // ajout du première ami "Equipe iChat"
                 User.updateOne({ _id: "6076e163d47a913b0c2b0b0f" }, {
                     $push: {
                         friends: {
@@ -39,6 +42,7 @@ exports.signup = (req, res, next) => {
                     if (err) {
                         console.log(err)
                     } else {
+                        // création du groupe avec "Equipe iChat et le nouveau utilisateur pour y stocker les messages et les membres"
                         const groupe = new Groupe({
                             membres: [
                                 { _id: user._id },
@@ -48,8 +52,8 @@ exports.signup = (req, res, next) => {
                                 { text: "Bienvenue dans iChat, vous pouvez désormais ajoutez des amis dans la section dédiée et vous partagez vos plus belles histoires !", author: "Equipe iChat" }
                             ]
                         })
-                        groupe.save()
-                        return res.cookie('token', token, { httpOnly: true }).status(200).json({ message: 'utilisateur créer' });
+                        groupe.save() // enregistre le groupe dans la DB
+                        return res.cookie('token', token, { httpOnly: true }).status(200).json({ message: 'utilisateur créer' }); // renvois des cookies de sesssion
                     }
                 })
 
@@ -63,8 +67,8 @@ const secret = "clef-secret"
 
 
 exports.signin = (req, res, next) => {
-    console.log(req.body)
-        // cherche un utilisateur avec l'email voulue
+    console.log(req.body);
+    // cherche un utilisateur avec l'email voulue
     User.findOne({ email: req.body.email }, function(err, user) {
         if (err) {
             console.error(err);
@@ -80,7 +84,7 @@ exports.signin = (req, res, next) => {
                 });
             console.log('here')
         } else {
-            // si utilisateur trouvé, comparé les deux mot de passe
+            // si utilisateur trouvé, comparer les deux mot de passe
             bcrypt.compare(req.body.mdp, user.mdp, function(err, result) {
                 if (err) {
                     console.error(err);
diff --git a/package.json b/package.json
index 2a1fbce..76940ce 100644
--- a/package.json
+++ b/package.json
@@ -55,4 +55,4 @@
             "last 1 safari version"
         ]
     }
-}
+}
\ No newline at end of file