modification du password possible

cryptide_project/server/api/controllers/AuthController.js

@@ -122,36 +122,59 @@ class AuthController {
         }
     }
 
+    static async validatePassword(req, res){
+        const db = new DatabaseService();
+        try{
+            await db.connect();
+
+            const user = await db.getUserByPseudo(req.body.pseudo);
+            if(!user){
+                res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
+                return;
+            }
+
+            const password = req.body.password;
+            const validPassword = await bcrypt.compare(password, user.password);
+            if(!validPassword){
+                res.status(400).json({ error: 'Le mot de passe est incorrect.' });
+                return;
+            }
+
+            res.status(200).json({ message: 'Mot de passe correct.' });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la vérification du mot de passe.' });
+        }
+        finally{
+            db.disconnect();
+        }
+    }
+
+    static async updatePassword(req, res){
+        const db = new DatabaseService();
+        try{
+            await db.connect();
+
+            const user = await db.getUserByPseudo(req.body.pseudo);
+            if(!user){
+                res.status(400).json({ error: 'Le pseudo n\'existe pas.' });
+                return;
+            }
+
+            const hashedPassword = await bcrypt.hash(req.body.newPassword, 10);
 
-    static async UpdateMDP(req, res){
+            await db.updatePassword(user.idUser, hashedPassword);
-        console.log("UpdateMDP");
+
-        // const db = new DatabaseService();
+            res.status(200).json({ message: 'Mot de passe mis à jour.' });
-
+        }
-        // try{
+        catch(error){
-        //     await db.connect();
+            console.error(error);
-
+            res.status(500).json({ error: 'Erreur lors de la mise à jour du mot de passe.' });
-        //     const user = await db.getUserByPseudo(req.body.pseudo);
+        }
-        //     console.log("utilisateur" + user.idUser + " pseudo" + user.pseudo)
+        finally{
-        //     if (!user) {
+            db.disconnect();
-        //         res.status(200).json({ error: "true", message: 'User not found' });
+        }
-        //         return;
-        //     }
-
-        //     await db.updatePseudo(user.idUser, req.body.newPseudo); //* update
-
-        //     const updatedUser = await db.getUserByPseudo(req.body.newPseudo);
-        //     console.log("updaetdutilisateur" + updatedUser.idUser + " pseudo" + updatedUser.pseudo)
-        //     req.session.user.pseudo = updatedUser.pseudo;
-        //     console.log("req.session.user.pseudo" + req.session.user.pseudo)
-        //     res.status(200).json({ user: req.session.user }); //verif rep
-        // }
-        // catch(error){
-        //     console.error(error);
-        //     res.status(500).json({ error: 'Erreur lors de la modification du pseudo de l\'utilisateur.' });
-        // }
-        // finally{
-        //     await db.disconnect();
-        // }
     }
 }
 

cryptide_project/server/api/routes/AuthRoutes.js

@@ -8,8 +8,8 @@ router.post('/auth/signup', AuthController.signUp);
 router.post('/auth/signin', AuthController.signIn);
 router.delete('/auth/logout', AuthController.logout)
 router.delete('/auth/delAccount', AuthController.delAccount)
-
+router.post('/auth/validatePassword', AuthController.validatePassword);
-router.put('/session/updateMDP', AuthController.UpdateMDP);
+router.put('/auth/updatePassword', AuthController.updatePassword);
 
 // Routes pour les sessions
 router.get('/session', SessionController.getUserInformation);

cryptide_project/server/api/services/DatabaseService.js

@@ -114,6 +114,19 @@ class DatabaseService {
         });
     }
 
+    async updatePassword(userId, newPassword){
+        return new Promise((resolve, reject) => {
+            this.client.run('UPDATE users SET password = ? WHERE idUser = ?', newPassword, userId, (err, result) => {
+                if(err){
+                    reject(err);
+                }
+                else{
+                    resolve(result);
+                }
+            });
+        });
+    }
+
     // -------------------------------------------------------------
     // ------------------- STATS MASTERMIND ------------------------
     // -------------------------------------------------------------

cryptide_project/src/Pages/Profile.tsx

@@ -79,24 +79,25 @@ const Profile = () => {
     };
 
     //* Vérification de l'ancien mot de passe :
-    const handleConfirmedAuth = () => {
+    const handleConfirmedAuth = async () => {
-
       // Vérification de l'ancien mot de passe
-      // if (oldPassword === user?.password) {
+      if(user){
-      if (oldPassword === 'coucou') { //! pour l'instant c'est 'coucou', mais il faudra mettre le vrai mdp.
+        try {
+          if (await AuthService.validatePassword(user?.pseudo, oldPassword)) {
             console.log('Ancien mot de passe correct.');
             setShowWrongPassword(false);
             setShowCorrectPassword(true);
             setDisableNextStep(false);
             setpercent(25);
           }
-      else{
+        } catch (error) {
-        console.log('Ancien mot de passe incorrect.');
+          console.error(error);
           setShowWrongPassword(true);
           setShowCorrectPassword(false);
           setDisableNextStep(true);
         }
       }
+    }
 
     const handleChangeStep = () => {
       setShowWrongPassword(false);
@@ -106,24 +107,25 @@ const Profile = () => {
     }
 
     //* Modification du mot de passe :
-    const handlePasswordChange = () => {
+    const handlePasswordChange = async () => {
       //Effectuer la modification du mot de passe
       // sinon, affichez une erreur
+      if(user){
         if (newPassword === confirmNewPassword) {
-      //   SessionService.UpdatePassword(user?.pseudo, newPassword);
+          await AuthService.updatePassword(user.pseudo, newPassword);
-      //   user.password = newPassword;
           console.log('Changement de mot de passe');
           setpercent(100);
           setTimeout(async () => {
             setShowPasswordModal(false);
-        }, 3000);
+          }, 1250);
         } else {
           //les mots de passe ne correspondent pas
           console.error("Les mots de passe ne correspondent pas.");
           setShowWrongPassword(true);
           setTimeout(async () => {
             setShowWrongPassword(false);
-        }, 1500);
+          }, 1250);
+        }
       }
     };
   

cryptide_project/src/services/AuthService.tsx

@@ -12,6 +12,30 @@ class AuthService{
         return VerificationService.validateSignInData(data);
     }
 
+    static async validatePassword(pseudo: any, password: any) {
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/auth/validatePassword', {
+                method: 'POST',
+                headers: {
+                'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ pseudo, password }),
+                credentials: 'include',
+            });
+        
+            if (response.ok) {
+                const result = await response.json();
+                return result;
+            } else {
+                const errorResponse = await response.json();
+                throw new Error(errorResponse.error);
+            }
+        } catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+
     static async signUp(data: any) {
         try {
             const response = await fetch(ADRESSE_DBSERVER + '/auth/signup', {
@@ -109,34 +133,28 @@ class AuthService{
     }
 
     
-    static async UpdateMDP(pseudo : string, newmdp : string) {
+    static async updatePassword(pseudo : string, newPassword : string) {
-        console.log("pseudo : " + pseudo + " mdp : " + newmdp)
+        try {
-        // try {
+            const response = await fetch(ADRESSE_DBSERVER + '/auth/updatePassword', {
-        //     const response = await fetch(ADRESSE_DBSERVER + '/session/updateMDP', {
+                method: 'PUT',
-        //         method: 'PUT',
+                headers: {
-        //         headers: {
+                    'Content-Type': 'application/json',
-        //             'Content-Type': 'application/json',
+                },
-        //         },
+                body: JSON.stringify({ pseudo, newPassword }),
-        //         body: JSON.stringify({
+                credentials: 'include',
-        //             pseudo,
+            });
-        //             newmdp
+        
-        //         }),
+            if (response.ok) {
-        //         credentials: 'include',
+                const result = await response.json();
-        //     });
+                return result;
-    
+            } else {
-        //     if (response.ok) {
+                const errorResponse = await response.json();
-        //         const result = await response.json();
+                throw new Error(errorResponse.error);
-        //         return result;
+            }
-        //     } else {
+        } catch (error) {
-        //         const errorResponse = await response.json();
+            console.error(error);
-        //         throw new Error(errorResponse.error);
+            throw error;
-        //     }
+        }
-        // } catch (error) {
-        //     console.error(error);
-        //     throw error;
-        // }
-
-        console.log("UpdateMDP in authserice")
     }
 
 }