Ajout de toutes les composantes pour avoir l'ensemble des stats daily et weekly

cryptide_project/server/api/controllers/ScoreboardController.js

@@ -48,6 +48,44 @@ class SessionController {
         }
     }
 
+    static async getDailyMediumEnigma(req, res){
+        const db = new DatabaseService();
+
+        try{
+            await db.connect();
+
+            const dailyMediumEnigmaStats = await db.getDailyEnigmaStats(ENIGME_MOYEN);
+
+            res.status(200).json({ tab : dailyMediumEnigmaStats });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la récupération des stats dailyMediumEnigma.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
+
+    static async getDailyHardEnigma(req, res){
+        const db = new DatabaseService();
+
+        try{
+            await db.connect();
+
+            const dailyHardEnigmaStats = await db.getDailyEnigmaStats(ENIGME_DIFFICILE);
+
+            res.status(200).json({ tab : dailyHardEnigmaStats });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la récupération des stats dailyHardEnigma.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
+
     static async getDailyOnline(req, res){
         const db = new DatabaseService();
 
@@ -109,6 +147,44 @@ class SessionController {
         }
     }
 
+    static async getWeeklyMediumEnigma(req, res){
+        const db = new DatabaseService();
+
+        try{
+            await db.connect();
+
+            const weeklyMediumEnigmaStats = await db.getWeeklyEnigmaStats(ENIGME_MOYEN);
+
+            res.status(200).json({ tab : weeklyMediumEnigmaStats });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la récupération des stats weeklyMediumEnigma.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
+
+    static async getWeeklyHardEnigma(req, res){
+        const db = new DatabaseService();
+
+        try{
+            await db.connect();
+
+            const weeklyHardEnigmaStats = await db.getWeeklyEnigmaStats(ENIGME_DIFFICILE);
+
+            res.status(200).json({ tab : weeklyHardEnigmaStats });
+        }
+        catch(error){
+            console.error(error);
+            res.status(500).json({ error: 'Erreur lors de la récupération des stats weeklyHardEnigma.' });
+        }
+        finally{
+            await db.disconnect();
+        }
+    }
+
     static async getWeeklyOnline(req, res){
         const db = new DatabaseService();
 

cryptide_project/server/api/routes/AuthRoutes.js

@@ -24,11 +24,15 @@ router.put('/session/updatePseudo', SessionController.UpdatePseudo);
 // Routes pour le daily scoreboard
 router.get('/scoreboard/getDailyMastermind', ScoreboardController.getDailyMastermind);
 router.get('/scoreboard/getDailyEasyEnigma', ScoreboardController.getDailyEasyEnigma);
+router.get('/scoreboard/getDailyMediumEnigma', ScoreboardController.getDailyMediumEnigma);
+router.get('/scoreboard/getDailyHardEnigma', ScoreboardController.getDailyHardEnigma);
 router.get('/scoreboard/getDailyOnline', ScoreboardController.getDailyOnline);
 
 // Routes pour le weekly scoreboard
 router.get('/scoreboard/getWeeklyMastermind', ScoreboardController.getWeeklyMastermind);
 router.get('/scoreboard/getWeeklyEasyEnigma', ScoreboardController.getWeeklyEasyEnigma);
+router.get('/scoreboard/getWeeklyMediumEnigma', ScoreboardController.getWeeklyMediumEnigma);
+router.get('/scoreboard/getWeeklyHardEnigma', ScoreboardController.getWeeklyHardEnigma);
 router.get('/scoreboard/getWeeklyOnline', ScoreboardController.getWeeklyOnline);
 
 

cryptide_project/src/Components/ScoreBoard.tsx

@@ -53,14 +53,16 @@ const ScoreBoard: React.FC<{ Player: User }> = ({ Player }) => {
         async function fetchDailyStats() {
             try {
                 const resultMM = await ScoreboardService.getDailyMastermindStats();
-                const resultOL = await ScoreboardService.getDailyOnlineStats();
                 const resultEF = await ScoreboardService.getDailyEasyEnigmaStats();
+                const resultEM = await ScoreboardService.getDailyMediumEnigmaStats();
+                const resultED = await ScoreboardService.getDailyHardEnigmaStats();
+                const resultOL = await ScoreboardService.getDailyOnlineStats(); 
                 
-                console.log(resultEF);
-
                 setDailyMastermindStats(resultMM);
-                setDailyOnlineStats(resultOL);
                 setDailyEasyEnigmaStats(resultEF);
+                setDailyMediumEnigmaStats(resultEM);
+                setDailyHardEnigmaStats(resultED);
+                setDailyOnlineStats(resultOL);
             } catch (error) {
                 console.error(error);
             }
@@ -69,14 +71,16 @@ const ScoreBoard: React.FC<{ Player: User }> = ({ Player }) => {
         async function fetchWeeklyStats() {
             try{
                 const resultMM = await ScoreboardService.getWeeklyMastermindStats();
-                const resultOL = await ScoreboardService.getWeeklyOnlineStats();
                 const resultEF = await ScoreboardService.getWeeklyEasyEnigmaStats();
-
-                console.log(resultEF);
+                const resultEM = await ScoreboardService.getWeeklyMediumEnigmaStats();
+                const resultED = await ScoreboardService.getWeeklyHardEnigmaStats();
+                const resultOL = await ScoreboardService.getWeeklyOnlineStats();
 
                 setWeeklyMastermindStats(resultMM);
-                setWeeklyOnlineStats(resultOL);
                 setWeeklyEasyEnigmaStats(resultEF);
+                setWeeklyMediumEnigmaStats(resultEM);
+                setWeeklyHardEnigmaStats(resultED);
+                setWeeklyOnlineStats(resultOL);
             } catch (error) {
                 console.error(error);
             }

cryptide_project/src/services/ScoreboardService.tsx

@@ -52,6 +52,52 @@ class ScoreboardService {
         }
     }
 
+    static async getDailyMediumEnigmaStats() {
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getDailyMediumEnigma', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                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 getDailyHardEnigmaStats() {
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getDailyHardEnigma', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                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 getDailyOnlineStats() {
         try {
             const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getDailyOnline', {
@@ -125,6 +171,52 @@ class ScoreboardService {
         }
     }
 
+    static async getWeeklyMediumEnigmaStats() {
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getWeeklyMediumEnigma', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                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 getWeeklyHardEnigmaStats() {
+        try {
+            const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getWeeklyHardEnigma', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                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 getWeeklyOnlineStats() {
         try {
             const response = await fetch(ADRESSE_DBSERVER + '/scoreboard/getWeeklyOnline', {