Aplicada funcion para finalizar tecnica RATA

tecnicas/controllers/__init__.py

@@ -23,6 +23,7 @@ from .views_controller.session_management.details_escala_controller import Detal
 from .views_controller.session_management.details_rata_controller import DetallesRATAController
 from .views_controller.session_management.monitor_controller import MonitorController
 from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController
+from .views_controller.session_management.monitor_rata_controller import MonitorRATAController
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.init_session_tester_controller import InitSessionTesterController

tecnicas/controllers/views_controller/session_management/monitor_controller.py

@@ -1,6 +1,59 @@
-from tecnicas.models import SesionSensorial
+from django.http import HttpRequest
+from django.shortcuts import render
+from tecnicas.models import SesionSensorial, Producto, EsAtributo, EsVocabulario
+from tecnicas.controllers import ParticipacionController, SesionController
+from tecnicas.utils import controller_error
 
 
 class MonitorController():
+    url_view: str
+    previus_view: str
+
     def __init__(self, session: SesionSensorial):
         self.sensorial_session = session
+
+    def setContext(self):
+        self.participations = ParticipacionController.getParticipationsInTechinique(
+            self.sensorial_session.tecnica)
+
+        self.context = {
+            "code_session": self.sensorial_session.codigo_sesion,
+            "session_name": self.sensorial_session.nombre_sesion,
+            "max_testers": self.sensorial_session.tecnica.limite_catadores,
+            "current_testers": len(self.participations),
+            "active_testers": len([part for part in self.participations if part.activo]),
+            "participations": self.participations,
+            "use_technique": self.sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+    def controlGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
+        self.setContext()
+
+        if error != "" or error:
+            self.context["error"] = error
+        if message != "" or message:
+            self.context["message"] = message
+
+        return render(request, self.url_view, self.context)
+
+    def getExpectedRatingsEscalasRapida(self):
+        num_products = Producto.objects.filter(
+            id_tecnica=self.sensorial_session.tecnica).count()
+        style_words = self.sensorial_session.tecnica.id_estilo
+        num_words: int
+
+        if style_words.nombre_estilo == "atributos":
+            num_words = EsAtributo.objects.get(
+                id_tecnica=self.sensorial_session.tecnica).palabras.count()
+        elif style_words.nombre_estilo == "vocabulario":
+            num_words = EsVocabulario.objects.get(
+                id_tecnica=self.sensorial_session.tecnica).id_vocabulario.palabras.count()
+
+        return num_products * num_words
+
+    def finishSession(self):
+        response = SesionController.finishRepetion(self.sensorial_session)
+        if isinstance(response, dict):
+            return controller_error(response["error"])
+        self.sensorial_session.refresh_from_db()
+        return self.sensorial_session

tecnicas/controllers/views_controller/session_management/monitor_escalas_controller.py

@@ -1,93 +1,49 @@
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, EsAtributo, EsVocabulario, Producto, Calificacion
-from tecnicas.controllers import ParticipacionController, SesionController
-from tecnicas.utils import controller_error
+from tecnicas.models import Dato, Participacion
+from tecnicas.controllers import SesionController
 from .monitor_controller import MonitorController
 
 
 class MonitorEscalasController(MonitorController):
-    url_view = "tecnicas/manage_sesions/monitor-sesion.html"
-
     def __init__(self, session: SesionController):
         super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-sesion.html"
+        self.previus_view = "cata_system:detalles_sesion"
 
-    def controlGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
-        self.setContext()
-
-        if error != "" or error:
-            self.context["error"] = error
-        if message != "" or message:
-            self.context["message"] = message
-
-        return render(request, self.url_view, self.context)
-
-    def controlPostResponseFinishSession(self, request: HttpRequest):
+    def controllPostFinishSession(self, request: HttpRequest):
         self.setContext()
-        (is_all_end, message) = self.checkAllParticipantsEnded()
+        (is_all_end, message) = self.checkAllFinish()
         if not is_all_end:
             self.context["error"] = message
-            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+            return render(request, self.url_view, self.context)
         response = self.finishSession()
         if isinstance(response, dict):
             self.context["error"] = response["error"]
-            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+            return render(request, self.url_view, self.context)
         self.context["message"] = message
-        return redirect(reverse("cata_system:detalles_sesion", kwargs={"session_code": self.sensorial_session.codigo_sesion}))
-
-    def setContext(self):
-        self.participations = ParticipacionController.getParticipationsInTechinique(
-            self.sensorial_session.tecnica)
+        return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
 
-        self.context = {
-            "code_session": self.sensorial_session.codigo_sesion,
-            "session_name": self.sensorial_session.nombre_sesion,
-            "max_testers": self.sensorial_session.tecnica.limite_catadores,
-            "current_testers": len(self.participations),
-            "active_testers": len([part for part in self.participations if part.activo]),
-            "participations": self.participations,
-            "use_technique": self.sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-    def getExpectedRatings(self):
-        num_products = Producto.objects.filter(
-            id_tecnica=self.sensorial_session.tecnica).count()
-        style_words = self.sensorial_session.tecnica.id_estilo
-        num_words: int
-
-        if style_words.nombre_estilo == "atributos":
-            num_words = EsAtributo.objects.get(
-                id_tecnica=self.sensorial_session.tecnica).palabras.count()
-        elif style_words.nombre_estilo == "vocabulario":
-            num_words = EsVocabulario.objects.get(
-                id_tecnica=self.sensorial_session.tecnica).id_vocabulario.palabras.count()
-
-        return num_products * num_words
-
-    def checkAllParticipantsEnded(self):
+    def checkAllFinish(self):
         technique = self.sensorial_session.tecnica
 
-        expected_ratings_repetition = self.getExpectedRatings()
+        expected_ratings_repetition = self.getExpectedRatingsEscalasRapida()
 
-        all_participations = ParticipacionController.getParticipationsInTechinique(
-            technique=technique)
+        all_participations = list(
+            Participacion.objects.filter(tecnica=technique))
 
         if len(all_participations) < technique.limite_catadores:
             return (False, "No se ha alcanzado el número máximo de Catadores")
 
         for particiapation in all_participations:
-            num_ratings_now = Calificacion.objects.filter(
-                id_tecnica=technique, id_catador=particiapation.catador, num_repeticion=technique.repeticion).count()
+            num_ratings_now = Dato.objects.filter(
+                id_calificacion__num_repeticion=technique.repeticion,
+                id_calificacion__id_catador=particiapation.catador,
+                id_calificacion__id_tecnica=technique
+            ).count()
 
             if num_ratings_now < expected_ratings_repetition:
                 return (False, "No todos los catadores han finalizado su evaluación")
 
         return (True, "Puedes finalizar la sesión")
-
-    def finishSession(self):
-        response = SesionController.finishRepetion(self.sensorial_session)
-        if isinstance(response, dict):
-            return controller_error(response["error"])
-        self.sensorial_session.refresh_from_db()
-        return self.sensorial_session

tecnicas/controllers/views_controller/session_management/monitor_rata_controller.py

@@ -0,0 +1,46 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Dato, Participacion
+from tecnicas.controllers import SesionController
+from .monitor_controller import MonitorController
+
+
+class MonitorRATAController(MonitorController):
+    def __init__(self, session: SesionController):
+        super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-sesion.html"
+        self.previus_view = "cata_system:detalles_sesion"
+
+    def controllPostFinishSession(self, request: HttpRequest):
+        self.setContext()
+        (is_all_end, message) = self.checkAllFinish()
+        if not is_all_end:
+            self.context["error"] = message
+            return render(request, self.url_view, self.context)
+        response = self.finishSession()
+        if isinstance(response, dict):
+            self.context["error"] = response["error"]
+            return render(request, self.url_view, self.context)
+        self.context["message"] = message
+        return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
+
+    def checkAllFinish(self):
+        technique = self.sensorial_session.tecnica
+
+        expected_ratings_repetition = self.getExpectedRatingsEscalasRapida()
+
+        all_participations = list(
+            Participacion.objects.filter(tecnica=technique))
+
+        for particiapation in all_participations:
+            num_ratings_now = Dato.objects.filter(
+                id_calificacion__num_repeticion=technique.repeticion,
+                id_calificacion__id_catador=particiapation.catador,
+                id_calificacion__id_tecnica=technique
+            ).count()
+
+            if num_ratings_now < expected_ratings_repetition:
+                return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")

tecnicas/views/sessions_management/session_monitor.py

@@ -8,7 +8,7 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from tecnicas.models import SesionSensorial
-from tecnicas.controllers import MonitorEscalasController
+from tecnicas.controllers import MonitorEscalasController, MonitorRATAController
 from tecnicas.utils import noValidTechnique
 
 
@@ -41,8 +41,19 @@ def sessionMonitor(req: HttpRequest, session_code: str):
         if use_techinique == "escalas":
             controll_view = MonitorEscalasController(sensorial_session)
             action = req.POST["action"]
+
+            if action == "finish_session":
+                response = controll_view.controllPostFinishSession(
+                    request=req)
+            else:
+                response = controll_view.controlGetResponse(
+                    request=req, error="No se ha definido la acción a realizar")
+        elif use_techinique == "rata":
+            controll_view = MonitorRATAController(sensorial_session)
+            action = req.POST["action"]
+
             if action == "finish_session":
-                response = controll_view.controlPostResponseFinishSession(
+                response = controll_view.controllPostFinishSession(
                     request=req)
             else:
                 response = controll_view.controlGetResponse(