Ajout fonction db, IUserService et update des stats après partie en multi ok

cryptide_project/src/Components/GraphContainer.tsx

@@ -41,12 +41,13 @@ let lastSocketId= ""
 let firstLap = true
 let cptHistory = 0
 let lastNodes: NodePerson[] = []
+let cptEndgame = 0
 
 
 const MyGraphComponent: React.FC<MyGraphComponentProps> = ({onNodeClick, handleShowTurnBar, handleTurnBarTextChange, playerTouched, setPlayerTouched, changecptTour, solo, addToHistory, showLast, setNetwork}) => {
 let cptTour: number = 0
 
-  const {isLoggedIn, user} = useAuth();
+  const {isLoggedIn, user, manager} = useAuth();
   const { indices, indice, person, personNetwork, setNodeIdData, players, askedPersons, setActualPlayerIndexData, room, actualPlayerIndex, turnPlayerIndex, setTurnPlayerIndexData, setWinnerData } = useGame();
   const params = new URLSearchParams(window.location.search);
 
@@ -449,53 +450,77 @@ let cptTour: number = 0
     })
 
     socket.on("end game", (winnerIndex) =>{
-      const currentPlayer = players[actualPlayerIndex];
+      if (cptEndgame % 2 == 0){
-      const winner = players[winnerIndex];
+        cptEndgame++;
-
+        const currentPlayer = players[actualPlayerIndex];
-      setNodeIdData(-1)
+        const winner = players[winnerIndex];
-      setActualPlayerIndexData(-1)
+  
-      setLastIndex(-1)
+        setNodeIdData(-1)
-      setPlayerTouched(-1)
+        setActualPlayerIndexData(-1)
-      setWinnerData(players[winnerIndex])
+        setLastIndex(-1)
-
+        setPlayerTouched(-1)
-      try{
+        setWinnerData(players[winnerIndex])
-        if(isLoggedIn){
+  
-          if(solo){
+        try{
+          if(isLoggedIn){
+            if(solo){
+              if(user && user.soloStats){
+                user.soloStats.nbGames = null ? user.soloStats.nbGames = 1 : user.soloStats.nbGames += 1;
+                if(cptTour < user.soloStats.bestScore || user.soloStats.bestScore == null){
+                  user.soloStats.bestScore = cptTour;
+                }
+                user.soloStats.avgNbTry = (user.soloStats.avgNbTry * (user.soloStats.nbGames - 1) + cptTour) / user.soloStats.nbGames;
 
-          }
+                manager.userService.updateSoloStats(user.pseudo, user.soloStats.nbGames, user.soloStats.bestScore, user.soloStats.avgNbTry);
-          else{
+              }
-            if(winner.id === currentPlayer.id){
+              else{
-                // TODO: Ajouter une victoire
+                console.error("User not found");
+              }
+            }
+            else{
+              if(user && user.onlineStats){
+                // console.log("nbGames: " + user.onlineStats.nbGames + " nbWins: " + user.onlineStats.nbWins);
+                if(winner.id === currentPlayer.id){
+                  // Ajouter une victoire
+                  user.onlineStats.nbWins = null ? user.onlineStats.nbWins = 1 : user.onlineStats.nbWins += 1;
+              }
+              // Update les stats
+              user.onlineStats.nbGames = null ? user.onlineStats.nbGames = 1 : user.onlineStats.nbGames += 1;
+              user.onlineStats.ratio = user.onlineStats.nbWins / user.onlineStats.nbGames;
               
+              manager.userService.updateOnlineStats(user.pseudo, user.onlineStats.nbGames, user.onlineStats.nbWins, user.onlineStats.ratio);
+              }
+              else{
+                console.error("User not found");
+              }
             }
-            // TODO: Update les stats
           }
         }
-      }
+        catch(e){
-      catch(e){
+          console.log(e);
-        console.log(e);
+        }
-      }
   
-      first = true
+        first = true
-      cptHistory = 0
+        cptHistory = 0
-      askedWrong=false
+        askedWrong=false
-      askedWrongBot=false
+        askedWrongBot=false
-
+  
-      
+        
-      socket.off("end game")
+        socket.off("end game")
-      socket.off("asked all")
+        socket.off("asked all")
-      socket.off("opacity activated")
+        socket.off("opacity activated")
-      socket.off("opacity deactivated")
+        socket.off("opacity deactivated")
-      socket.off("reset graph")
+        socket.off("reset graph")
-      socket.off("node checked")
+        socket.off("node checked")
-      socket.off("already asked")
+        socket.off("already asked")
-      socket.off("asked wrong")
+        socket.off("asked wrong")
-      socket.off("asked")
+        socket.off("asked")
-      socket.off("put correct background")
+        socket.off("put correct background")
-      socket.off("put grey background")
+        socket.off("put grey background")
-      socket.off("put imossible grey")
+        socket.off("put imossible grey")
-
+  
-      navigate("/endgame")
+        navigate("/endgame")
+      }
     })
 
 

cryptide_project/src/Pages/Play.tsx

@@ -8,8 +8,7 @@ import './Play.css';
 import { useTheme } from '../Style/ThemeContext';
 
 /* Component */
-import ButtonImgNav from "../Components/ButtonImgNav"
+import ButtonImgNav from "../Components/ButtonImgNav";
-import SessionService from "../services/SessionService";
 
 /* Img */
 import Person from '../res/img/Person.png';
@@ -21,9 +20,6 @@ import GameCreator from '../model/GameCreator';
 import { useGame } from '../Contexts/GameContext';
 import ScoreBoard from '../Components/ScoreBoard';
 
-/* Types */
-import User from '../model/User';
-
 function Play() {
     const theme=useTheme()
     const {user} = useAuth();

cryptide_project/src/model/DataManagers/DbUserService.ts

@@ -44,6 +44,31 @@ class DbUserService implements IUserService{
         }
     }
 
+    async updateSoloStats(pseudo: string, nbGames: number, bestScore: number, avgNbTry: number): Promise<void> {
+        try {
+            const result = await SessionService.updateSoloStats(pseudo, nbGames, bestScore, avgNbTry);
+            if (result) {
+                console.log("Stats solo updated");
+            } else {
+                console.log("Stats solo not updated");
+            }
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    async updateOnlineStats(pseudo: string, nbGames: number, bestScore: number, ratio: number): Promise<void> {
+        try {
+            const result = await SessionService.updateOnlineStats(pseudo, nbGames, bestScore, ratio);
+            if (result) {
+                console.log();
+            } else {
+                console.log("Stats online not updated");
+            }
+        } catch (error) {
+            console.error(error);
+        }
+    }
 }
 
 export default DbUserService

cryptide_project/src/model/DataManagers/IUserService.ts

@@ -1,8 +1,9 @@
 import User from "../User";
 
 interface IUserService{
-
     fetchUserInformation(): Promise<[User | null, boolean]>
+    updateSoloStats(pseudo: string, nbGames: number, bestScore: number, avgNbTry: number): Promise<void>
+    updateOnlineStats(pseudo: string, nbGames: number, bestScore: number, ratio: number): Promise<void>
 }
 
 

cryptide_project/src/server/controllers/SessionController.js

@@ -27,6 +27,83 @@ class SessionController {
             await db.disconnect();
         }
     }
+
+    static async updateSoloStats(req, res) {
+        const db = new DatabaseService();
+
+        try{
+            await db.connect();
+
+            const user = await db.getUserByPseudo(req.body.pseudo);
+
+            if (!user) {
+                res.status(200).json({ error: "true", message: 'User not found' });
+                return;
+            }
+
+            const soloStats = await db.getSoloStatsByUserId(user.idUser);
+
+            if (!soloStats) {
+                res.status(200).json({ error: "true", message: 'Solo stats not found' });
+                return;
+            }
+
+            await db.updateSoloStatsByUserId(user.idUser, req.body.nbGames, req.body.bestScore, req.body.avgNbTry);
+
+            const newSoloStats = await db.getSoloStatsByUserId(user.idUser);
+
+            req.session.user.soloStats = newSoloStats;
+
+            res.status(200).json({ user: req.session.user });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la mise à jour des statistiques solo.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
+
+    static async updateOnlineStats(req, res) {
+        const db = new DatabaseService();
+
+        console.log(req.body);
+
+        try{
+            await db.connect();
+
+            const user = await db.getUserByPseudo(req.body.pseudo);
+
+            if (!user) {
+                res.status(200).json({ error: "true", message: 'User not found' });
+                return;
+            }
+
+            const onlineStats = await db.getOnlineStatsByUserId(user.idUser);
+
+            if (!onlineStats) {
+                res.status(200).json({ error: "true", message: 'Online stats not found' });
+                return;
+            }
+
+            await db.updateOnlineStats(user.idUser, req.body.nbGames, req.body.nbWins, req.body.ratio);
+
+            const newOnlineStats = await db.getOnlineStatsByUserId(user.idUser);
+
+            console.log(req.session.user);
+            req.session.user.onlineStats = newOnlineStats;
+
+            res.status(200).json({ user: req.session.user });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la mise à jour des statistiques en ligne.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
 }
 
 module.exports = SessionController;

cryptide_project/src/server/routes/AuthRoutes.js

@@ -10,5 +10,7 @@ router.delete('/auth/logout', AuthController.logout)
 
 // Routes pour les sessions
 router.get('/session', SessionController.getUserInformation);
+router.put('/session/updateSoloStats', SessionController.updateSoloStats);
+router.put('/session/updateOnlineStats', SessionController.updateOnlineStats);
 
 module.exports = router;

cryptide_project/src/server/services/DatabaseService.js

@@ -50,6 +50,20 @@ class DatabaseService {
         });
     }
 
+    // Récupère l'utilisateur par son id
+    async getUserByID(id){
+        return new Promise((resolve, reject) => {
+            this.client.get('SELECT * FROM users WHERE idUser = ?', id, (err, result) => {
+                if(err){
+                    reject(err);
+                }
+                else{
+                    resolve(result);
+                }
+            });
+        });
+    }
+
     // Récupère stats solo de l'utilisateur
     async getSoloStatsByUserId(userId){
         return new Promise((resolve, reject) => {

cryptide_project/src/services/SessionService.tsx

@@ -21,6 +21,66 @@ class SessionService {
             throw error;
         }
     }
+
+    static async updateSoloStats(pseudo: string, nbGames: number, bestScore: number, avgNbTry: number){
+        try {
+            const response = await fetch('http://localhost:3003/session/updateSoloStats', {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                credentials: 'include',
+                body: JSON.stringify({
+                    pseudo,
+                    nbGames,
+                    bestScore,
+                    avgNbTry
+                }),
+            });
+    
+            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 updateOnlineStats(pseudo: string, nbGames: number, nbWins: number, ratio: number){
+        try {
+
+            console.log("updateOnlineStats : ", pseudo, nbGames, nbWins, ratio);
+            const response = await fetch('http://localhost:3003/session/updateOnlineStats', {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                credentials: 'include',
+                body: JSON.stringify({
+                    pseudo,
+                    nbGames,
+                    nbWins,
+                    ratio
+                }),
+            });
+    
+            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 SessionService;