Update de preguntas generadas y elim tope y eliminacion de las mismas. Funcionalidad creacion y actualizacion automatica de ranking de usuarios (back)

gatewayservice/gateway-service.js

@@ -150,6 +150,19 @@ app.get('/getFullQuestion', async (req, res) => {
   }
 });
 
+app.get('/actRanking', async (req, res) => {
+  try {      
+      const rankingResponse = await axios.get(`${recordServiceUrl}/actRanking`);
+      res.json(rankingResponse.data);
+  } catch (error) {
+      if (error.response) {
+          res.status(error.response.status).json({ error: error.response.data.error });
+      } else {
+          res.status(500).json({ error: 'Error interno del servidor' });
+      }
+  }
+});
+
 
 ////////////////////////ranking
 app.post('/createUserRank', async (req, res) => {
@@ -197,10 +210,25 @@ app.post('/updateRanking', async (req, res) => {
   }
 });
 
+app.post('/updateAllRanking', async (req, res) => {
+  try {
+      // Reenviar la solicitud POST al servicio de ranking para actualizar el ranking de un usuario
+      const rankingResponse = await axios.post(`${rankingServiceUrl}/updateAllRanking`, req.body);
+      res.json(rankingResponse.data);
+  } catch (error) {
+      if (error.response) {
+          res.status(error.response.status).json({ error: error.response.data.error });
+      } else {
+          res.status(500).json({ error: 'Error interno del servidor' });
+      }
+  }
+});
+
+
 
 ///////////////para los question del juego
 // Ruta para agregar una pregunta de prueba
-app.post('/addQuestionTest', async (req, res) => {
+app.post('/addOrUpdateQuestionTest', async (req, res) => {
   try {
     const questionTestResponse = await axios.post(`${questiontestservice}/addQuestionTest`, req.body);
     res.json(questionTestResponse.data);

questions/generatedquestservice/generatedquest-service.js

@@ -28,30 +28,37 @@ const doesQuestionExist = async (questionBody) => {
   }
 };
 
-// Route to add a new generated question
-app.post('/addGeneratedQuestion', async (req, res) => {
+// Ruta para agregar una nueva pregunta o actualizar si ya existe
+app.post('/addOrUpdateQuestionTest', async (req, res) => {
   try {
-    const { generatedQuestionBody, correctAnswer } = req.body;
+    // Buscar si ya existe una pregunta con el mismo questionBody
+    const existingQuestion = await QuestionTest.findOne({ questionBody: req.body.questionBody });
 
-    const questionExists = await doesQuestionExist(generatedQuestionBody);
-    if (!questionExists) {
-      const newQuestion = new GeneratedQuestion({
-        generatedQuestionBody,
-        correctAnswer,
-      });
-
-      await newQuestion.save();
+    if (existingQuestion) {
+      // Si la pregunta ya existe, realizar una actualización
+      existingQuestion.correcta = req.body.correcta;
+      existingQuestion.incorrectas = req.body.incorrectas;
+      existingQuestion.numquest = req.body.numquest;
 
-      res.json(newQuestion);
+      await existingQuestion.save();
+      res.json(existingQuestion); // Devolver la pregunta actualizada
     } else {
-      res.status(204).end(); // No Content
+      // Si la pregunta no existe, crear una nueva pregunta
+      const newQuestion = new QuestionTest({
+        questionBody: req.body.questionBody,
+        correcta: req.body.correcta,
+        incorrectas: req.body.incorrectas,
+        numquest: req.body.numquest
+      });
+      await newQuestion.save();
+      res.json(newQuestion); // Devolver la nueva pregunta creada
     }
   } catch (error) {
-    console.error(error);
-    res.status(500).json({ error: 'Internal Server Error', details: error.message });
+    res.status(500).json({ error: 'Internal Server Error' });
   }
 });
 
+
 //obtencion de todas las preguntas generadas y su respuesta correcta 
 app.get('/getAllGeneratedQuestions', async (req, res) => {
   try {

questions/recordservice/record-service.js

@@ -59,6 +59,37 @@ app.get('/getRecords/:userId', async (req, res) => {
   }
 });
 
+// Nuevo endpoint paraactualizar el ranking de los usurias si surgiera algo 
+app.get('/actRanking', async (req, res) => {
+  try {
+    const allRecords = await Record.find();
+
+    const rankingData = {};
+
+    allRecords.forEach(record => {
+      const userId = record.userId;
+      if (!(userId in rankingData)) {
+        rankingData[userId] = {
+          username: userId,
+          preguntasCorrectas: 0,
+          preguntasFalladas: 0,
+          numPartidas: 0
+        };
+      }
+
+      rankingData[userId].preguntasCorrectas += record.correctQuestions;
+      rankingData[userId].preguntasFalladas += record.failedQuestions;
+      rankingData[userId].numPartidas += 1;
+    });
+
+    const rankingArray = Object.values(rankingData);
+
+    res.json(rankingArray);
+  } catch (error) {
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+});
+
 // Start the server
 const server = app.listen(port, () => {
   console.log(`Record Service listening at http://localhost:${port}`);

users/rankingservice/ranking-service.js

@@ -44,33 +44,39 @@ app.post('/updateRanking', async (req, res) => {
   });
 
 
-app.post('/createUserRank', async (req, res) => {
+  app.post('/createUserRank', async (req, res) => {
     try {
-        const { username } = req.body;
-
-
-        const existingUser = await UserRank.findOne({ username });
-        if (existingUser) {
-            throw new Error(`El usuario '${username}' ya tiene un ranking.`);
-        }
-
-        // Crear un nuevo ranking para el usuario
+      const { username } = req.body;
+
+      // Buscar si ya existe un ranking para el usuario
+      const existingUserRank = await UserRank.findOne({ username });
+
+      if (existingUserRank) {
+        // Si ya existe un ranking para el usuario, actualizar los valores a cero
+        existingUserRank.porcentajeAciertos = 0;
+        existingUserRank.preguntasCorrectas = 0;
+        existingUserRank.preguntasFalladas = 0;
+        existingUserRank.numPartidas = 0;
+
+        await existingUserRank.save();
+        res.json(existingUserRank);
+      } else {
+        // Si no existe un ranking para el usuario, crear uno nuevo
         const newUserRank = new UserRank({
-            username,
-            porcentajeAciertos: 0, 
-            preguntasCorrectas: 0, 
-            preguntasFalladas: 0, 
-            numPartidas: 0 
+          username,
+          porcentajeAciertos: 0,
+          preguntasCorrectas: 0,
+          preguntasFalladas: 0,
+          numPartidas: 0
         });
-
-
+
         await newUserRank.save();
-
         res.json(newUserRank);
+      }
     } catch (error) {
-        res.status(400).json({ error: error.message });
+      res.status(400).json({ error: error.message });
     }
-});
+  });
 
 app.get('/obtainRank', async (req, res) => {
   try {
@@ -83,6 +89,53 @@ app.get('/obtainRank', async (req, res) => {
 });
 
 
+app.post('/updateAllRanking', async (req, res) => {
+  try {
+    const rankingData = req.body;
+
+    // Iterar sobre los datos recibidos y actualizar los rankings correspondientes
+    for (const userData of rankingData) {
+      const username = userData.username;
+      const preguntasCorrectas = userData.preguntasCorrectas;
+      const preguntasFalladas = userData.preguntasFalladas;
+      const numPartidas = userData.numPartidas;
+
+      // Buscar al usuario en la base de datos
+      const existingUser = await UserRank.findOne({ username });
+
+      if (!existingUser) {
+        // Si el usuario no existe, crear un nuevo ranking para él
+        const newUserRank = new UserRank({
+          username,
+          porcentajeAciertos: 0,
+          preguntasCorrectas,
+          preguntasFalladas,
+          numPartidas // Al ser el primer registro, el número de partidas es 1
+        });
+
+        await newUserRank.save();
+      } else {
+        // Si el usuario ya existe, actualizar su ranking
+        existingUser.preguntasCorrectas += preguntasCorrectas;
+        existingUser.preguntasFalladas += preguntasFalladas;
+        existingUser.numPartidas += numPartidas;
+
+        const totalPreguntas = existingUser.preguntasCorrectas + existingUser.preguntasFalladas;
+        const porcentajeAciertos = (existingUser.preguntasCorrectas / totalPreguntas) * 100;
+        existingUser.porcentajeAciertos = porcentajeAciertos.toFixed(2);
+
+        await existingUser.save();
+      }
+    }
+
+    res.json({ message: 'Rankings actualizados correctamente.' });
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+
+
 const server = app.listen(port, () => {
   console.log(`User Service listening at http://localhost:${port}`);
 });

webapp/src/components/AddUser.js

@@ -14,6 +14,7 @@ const AddUser = () => {
   const addUser = async () => {
     try {
       await axios.post(`${apiEndpoint}/adduser`, { username, password });
+      //await axios.post(`${apiEndpoint}/createUserRank`, { username });
       setOpenSnackbar(true);
     } catch (error) {
       setError(error.response.data.error);

webapp/src/components/Game.js

@@ -70,6 +70,19 @@ const Game = ({ username }) => {
         correctQuestions: correctQuestions,
         failedQuestions: (totalQuestions - correctQuestions)
       });
+
+    } catch (error) {
+      setError(error.response.data.error);
+    }
+  };
+
+  const updateRanking = async () => {
+    try {
+      await axios.post(`${apiEndpoint}/updateRanking`, {
+        username: username,
+        preguntasCorrectas: correctQuestions,
+        preguntasFalladas: totalQuestions - correctQuestions
+      });
     } catch (error) {
       setError(error.response.data.error);
     }
@@ -99,6 +112,7 @@ const Game = ({ username }) => {
 
     if (newNumberClics > totalQuestions || timer > timeLimit) {
       addRecord();
+      updateRanking();
       setFinished(true);
     }
   };

webapp/src/components/Login.js

@@ -34,7 +34,17 @@ const Login = ({setLogged}) => {
 
       // Extraer datos de la respuesta
       const { createdAt: userCreatedAt } = response.data;
-
+
+    // Obtener todos los usuarios
+    const usersResponse = await axios.get(`${apiEndpoint}/getAllUsers`);
+    const users = usersResponse.data;
+
+    // Para cada usuario, crear su ranking
+    for (const user of users) {
+      await axios.post(`${apiEndpoint}/createUserRank`, { username: user.username });
+    }
+      const { data: updatedRankingData } = await axios.get(`${apiEndpoint}/actRanking`);//obtengo datos actualizados del ranking
+      await axios.post(`${apiEndpoint}/updateAllRanking`, updatedRankingData); //los actualizo
 
 
       setCreatedAt(userCreatedAt);

webapp/src/index.js

@@ -15,7 +15,7 @@ const obtenerPreguntaspartida = async (numquest) => {
     const { questionBody, correctAnswer, incorrectAnswers } = response.data;
 
     // Enviar la pregunta al servicio de preguntas de prueba
-    await axios.post(`${apiEndpoint}/addQuestionTest`, {
+    await axios.post(`${apiEndpoint}/addOrUpdateQuestionTest`, {
       questionBody,
       correcta: correctAnswer,
       incorrectas: incorrectAnswers,
@@ -31,30 +31,14 @@ const RootComponent = () => {
 
   useEffect(() => {
     const intervalId = setInterval(() => {
-      if (numquest <= 40) {
-        obtenerPreguntaspartida(numquest); // Pass current numquest value
-        setNumquest(prevNumquest => prevNumquest + 1); // Increment numquest
-      } else {
-        clearInterval(intervalId); // Detener la generación de preguntas después de 30 iteraciones
-      }
-    }, 2000); // Ejecutar cada 2 segundos
-
-    window.addEventListener('beforeunload', handleBeforeUnload);
-
+      obtenerPreguntaspartida(numquest); // Pass current numquest value
+      setNumquest(prevNumquest => prevNumquest + 1); // Increment numquest
+    }, 2000); // Execute every 2 seconds
+
     return () => {
-      clearInterval(intervalId); // Función de limpieza para detener el intervalo cuando se desmonta el componente
-      window.removeEventListener('beforeunload', handleBeforeUnload);
+      clearInterval(intervalId); // Cleanup function to stop interval when component unmounts
     };
-  }, [numquest]); // Volver a ejecutar el efecto cuando cambia numquest
-
-
-  const handleBeforeUnload = async () => {
-    try {
-      await axios.delete(`${apiEndpoint}/deleteAllQuestionTest`);
-    } catch (error) {
-      console.error("Error al ejecutar la limpieza al cerrar la página", error);
-    }
-  };
+  }, [numquest]); // Re-run effect when numquest changes
 
   return (
     <React.StrictMode>