Merge pull request #26 from CascoArcilla/HU9

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/details_escala_controller.py

@@ -14,7 +14,7 @@ Encabezados de como deben de aparecer los datos juntos
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion
+from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion, Escala
 from tecnicas.controllers import DatoController, PalabrasController, ParticipacionController
 from .details_controller import DetallesController
 from tecnicas.utils import defaultdict_to_dict, controller_error
@@ -44,16 +44,26 @@ class DetallesEscalasController(DetallesController):
         }
         self.context["sesion"] = self.session
 
+        technique = self.session.tecnica
+
+        # Datos de la escala usada
+        scale: Escala = technique.escala_tecnica
+
+        self.context["scale"] = {
+            "type": scale.id_tipo_escala.nombre_escala,
+            "size": scale.longitud
+        }
+
         # Recuperar la palabras de la tecnica
         self.words = PalabrasController.getWordsInTechnique(
-            self.session.tecnica)
+            technique)
         self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
         # Se recuperan las calificaciones
         ratings_for_repetition = []
 
         ratings = list(Calificacion.objects.filter(
-            id_tecnica=self.session.tecnica))
+            id_tecnica=technique))
 
         if not ratings:
             self.context["calificaciones"] = ratings_for_repetition
@@ -61,7 +71,7 @@ class DetallesEscalasController(DetallesController):
             return self.context
 
         data = DatoController.getWordValuesForConvecional(
-            ratings=ratings, technique=self.session.tecnica)
+            ratings=ratings, technique=technique)
 
         ratings_for_repetition = defaultdict(
             lambda: defaultdict(lambda: defaultdict(list)))
@@ -81,7 +91,7 @@ class DetallesEscalasController(DetallesController):
         self.context["existen_calificaciones"] = True
 
         # Se comprueba que ya no se pueda iniciar la repeticion
-        self.context["fin_repeticiones"] = self.session.tecnica.repeticion >= self.session.tecnica.repeticiones_max
+        self.context["fin_repeticiones"] = technique.repeticion >= technique.repeticiones_max
 
         return self.context
 

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/templates/tecnicas/components/table-convencional.html

@@ -1,10 +1,9 @@
 <section>
-    <h2 class="text-lg font-bold mb-3">Repetición {{ repeticion }}</h2>
-
     <div class="overflow-x-auto rounded-lg border border-surface-general">
         <table class="min-w-max w-full text-sm text-center border-collapse">
             <thead class="bg-surface-sweet text-black font-semibold">
                 <tr>
+                    <th class="py-2 px-3 border border-surface-general">Repetición</th>
                     <th class="py-2 px-3 border border-surface-general">Usuario</th>
                     <th class="py-2 px-3 border border-surface-general">Producto</th>
                     {% for palabra in palabras %}
@@ -13,26 +12,29 @@
                 </tr>
             </thead>
             <tbody class="bg-surface-ligt divide-y divide-gray-200">
-                {% for usuario, productos in catadores.items %}
-                {% for codigo, valores in productos.items %}
-                <tr>
-                    <td class="py-2 px-3 border border-surface-general">{{ usuario }}</td>
-                    <td class="py-2 px-3 border border-surface-general">{{ codigo }}</td>
-                    {% for palabra in palabras %}
-                    <td class="py-2 px-3 border border-surface-general">
-                        {% with match=None %}
-                        {% for valor in valores %}
-                        {% if valor.nombre_palabra == palabra %}
-                        {{ valor.dato_valor }}
-                        {% with match=True %}{% endwith %}
-                        {% endif %}
+                {% for repeticion, catadores in calificaciones.items %}
+                    {% for usuario, productos in catadores.items %}
+                        {% for codigo, valores in productos.items %}
+                        <tr>
+                            <td class="py-2 px-3 border border-surface-general">{{ repeticion }}</td>
+                            <td class="py-2 px-3 border border-surface-general">{{ usuario }}</td>
+                            <td class="py-2 px-3 border border-surface-general">{{ codigo }}</td>
+                            {% for palabra in palabras %}
+                            <td class="py-2 px-3 border border-surface-general">
+                                {% with match=False %}
+                                {% for valor in valores %}
+                                    {% if valor.nombre_palabra == palabra %}
+                                        {{ valor.dato_valor }}
+                                        {% with match=True %}{% endwith %}
+                                    {% endif %}
+                                {% endfor %}
+                                {% if match %}0{% endif %}
+                                {% endwith %}
+                            </td>
+                            {% endfor %}
+                        </tr>
                         {% endfor %}
-                        {% if not match %}0{% endif %}
-                        {% endwith %}
-                    </td>
                     {% endfor %}
-                </tr>
-                {% endfor %}
                 {% endfor %}
             </tbody>
         </table>

tecnicas/templates/tecnicas/manage_sesions/detalles-sesion.html

@@ -252,11 +252,15 @@
 
         {% if existen_calificaciones %}
         <article class="bg-surface-card p-4 max-sm:px-2 text-black rounded">
-            {% with url_component="../components/table-convencional.html" %}
-            {% for repeticion, catadores in calificaciones.items %}
-            {% include url_component with repeticion=repeticion catadores=catadores palabras=palabras %}
-            {% endfor %}
-            {% endwith %}
+            <section class="text-xl space-y-4 space-x-4 mb-4">
+                <p class="inline italic underline font-semibold">
+                    Tipo de escala: <span class="font-bold uppercase">{{ scale.type }}</span>
+                </p>
+                <p class="inline italic underline font-semibold">
+                    Máximo valor por dato: <span class="font-bold">{{ scale.size }}</span>
+                </p>
+            </section>
+            {% include "../components/table-convencional.html" with calificaciones=calificaciones palabras=palabras %}
         </article>
         {% else %}
         {% include "../components/error-message.html" with message='Sin calificaciones que mostrar aú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(