utilisation de jus de cerveau avec baptiste pour la deconnexion ⚡ ⚡ (il va falloir changer la logique de maj de pseudo)

cryptide_project/src/Pages/Profile.tsx

@@ -3,8 +3,9 @@ import ProfilePDP from '../Components/ProfilePDP';
 
 import SessionService from '../services/SessionService';
 import { PlayerProps } from '../types/Player';
-import { update } from 'lodash';
+import { delay, update } from 'lodash';
 import { socket } from '../SocketConfig';
+import AuthService from '../services/AuthService';
 
 /* Style */
 import './Profile.css'
@@ -23,13 +24,19 @@ import Button from 'react-bootstrap/Button';
 import Alert from 'react-bootstrap/Alert';
 import Modal from 'react-bootstrap/Modal';
 import Form from 'react-bootstrap/Form';
+import { useNavigate } from 'react-router-dom';
 
 //@ts-ignore
 const Profile = () => {
   
-  
+  const navigate = useNavigate();
   //let player;
-  const {user} = useAuth()
+  const {user, logout} = useAuth()
+  
+  // let pseudoNotNull;
+  // if(user?.pseudo != null){
+  //   pseudoNotNull = user.pseudo;
+  // }
 
   const [editingUsername, setEditingUsername] = useState(false);
   const [newUsername, setNewUsername] = useState(user?.pseudo);
@@ -62,9 +69,11 @@ const Profile = () => {
     setShowDeleteModal(false);
   };
 
-  // Confirmation avec la phrase :
+  //* Confirmation avec la phrase :
   const [confirmationPhrase, setConfirmationPhrase] = useState('');
 
+  const [showWrong, setShowWrong] = useState(false);
+
   //@ts-ignore
   const handleConfirmationPhraseChange = (e) => {
     setConfirmationPhrase(e.target.value);
@@ -74,9 +83,27 @@ const Profile = () => {
     // Verification de la phrase
     if (confirmationPhrase.toLowerCase() === 'supprimer mon compte') {
       console.log('Compte supprimé !');
+      console.log(user);
+
+      if(user!= null){
+        const pseudo = user.pseudo;
+        AuthService.delAccount(pseudo);
+        AuthService.logout();
+        logout();
+      }
+      else{
+        console.error("l'utilisateur ne peut pas être null")
+      }
       handleCloseDeleteModal();
+
+      navigate("/play")
+
     } else {
       console.error('Phrase de confirmation incorrecte.');
+      setShowWrong(true);
+      setTimeout(async () => {
+        setShowWrong(false);
+      }, 3000);
     }
   };
 
@@ -140,6 +167,12 @@ const Profile = () => {
                   value={confirmationPhrase}
                   onChange={handleConfirmationPhraseChange}
                 />
+                {
+                  showWrong && 
+                  <Alert key='infomodel' variant='danger' style={{width:'100%'}}>
+                    La phrase de confirmation est incorrecte.
+                  </Alert>
+                }
               </Modal.Body>
               <Modal.Footer>
                 <Button variant='secondary' onClick={handleCloseDeleteModal}>

cryptide_project/src/server/controllers/AuthController.js

@@ -5,7 +5,7 @@ const bcrypt = require('bcrypt');
 const sqlite3 = require('sqlite3');
 
 class AuthController {
-  static async signUp(req, res) {
+    static async signUp(req, res) {
     const databaseService = new DatabaseService();
     const pseudo = req.body.pseudo;
     try {
@@ -88,18 +88,41 @@ class AuthController {
     }
   }
 
-  static async logout(req, res) {
+    static async logout(req, res) {
     // Détruire la session pour déconnecter l'utilisateur
-    req.session.destroy((err) => {
-        if (err) {
-            console.error(err);
-            res.status(500).json({ error: 'Erreur lors de la déconnexion.' });
-        } else {
-            res.status(200).json({ message: 'Déconnexion réussie' });
-        }
-    });
-  }
+        req.session.destroy((err) => {
+            if (err) {
+                console.error(err);
+                res.status(500).json({ error: 'Erreur lors de la déconnexion.' });
+            } else {
+                res.status(200).json({ message: 'Déconnexion réussie' });
+            }
+        });
+    }
+
+    static async delAccount(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;
+            }
+            await db.deleteSoloStat(user.idUser);
+            await db.deleteOnlineStat(user.idUser);
+            await db.deleteUser(user.idUser);
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la supression du compte.' });
+        }
+        finally{
+            db.disconnect();
+        }
+    }
 }
 
 module.exports = AuthController;

cryptide_project/src/server/routes/AuthRoutes.js

@@ -7,6 +7,7 @@ const SessionController = require('../controllers/SessionController');
 router.post('/auth/signup', AuthController.signUp);
 router.post('/auth/signin', AuthController.signIn);
 router.delete('/auth/logout', AuthController.logout)
+router.delete('/auth/delAccount', AuthController.delAccount)
 
 // Routes pour les sessions
 router.get('/session', SessionController.getUserInformation);

cryptide_project/src/server/services/DatabaseService.js

@@ -1,5 +1,6 @@
 const sqlite3 = require('sqlite3');
 const path = require('path');
+const { rejects } = require('assert');
 
 class DatabaseService {
     constructor(){
@@ -132,6 +133,45 @@ class DatabaseService {
             });
         });
     }
+
+    async deleteUser(userId){
+        return new Promise((resolve, reject) => {
+            this.client.run('DELETE FROM users WHERE idUser=?', userId, (err, result) => {
+                if(err){
+                    reject(err);
+                }
+                else{
+                    resolve(result);
+                }
+            });
+        });
+    }
+
+    async deleteSoloStat(userId){
+        return new Promise((resolve, reject) => {
+            this.client.run('DELETE FROM solo_stats WHERE idUser=?', userId, (err, result) => {
+                if(err){
+                    reject(err);
+                }
+                else{
+                    resolve(result);
+                }
+            });
+        });
+    }
+
+    async deleteOnlineStat(userId){
+        return new Promise((resolve, reject) => {
+            this.client.run('DELETE FROM online_stats WHERE idUser=?', userId, (err, result) => {
+                if(err){
+                    reject(err);
+                }
+                else{
+                    resolve(result);
+                }
+            });
+        });
+    }
 }
 
 module.exports = DatabaseService;

cryptide_project/src/services/AuthService.tsx

@@ -1,5 +1,6 @@
 import VerificationService from './VerificationService';
 import {ADRESSE_DBSERVER} from "../AdressConfig"
+import User from '../model/User';
 
 
 class AuthService{
@@ -83,6 +84,30 @@ class AuthService{
             throw error;
         }
     }
+
+    static async delAccount(pseudo: string){
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/auth/delAccount', {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ pseudo }),
+                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;
+        }
+    }
 }
 
 export default AuthService;