Finalizar sesion comprobando evaluacionses concluidas

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -1,4 +1,4 @@
-from ...models import Participacion, Tecnica
+from ...models import Participacion, Tecnica, SesionSensorial
 from ...utils import controller_error
 
 
@@ -13,7 +13,7 @@ class ParticipacionController():
             return participation
         except Participacion.DoesNotExist:
             return controller_error("No se ha encontrado la participación")
-        
+
     @staticmethod
     def finishSession(id_participation: int):
         try:
@@ -24,7 +24,7 @@ class ParticipacionController():
             return participation
         except Participacion.DoesNotExist:
             return controller_error("No se ha encontrado la participación")
-        
+
     @staticmethod
     def outSession(id_participation: int):
         try:
@@ -34,9 +34,33 @@ class ParticipacionController():
             return participation
         except Participacion.DoesNotExist:
             return controller_error("No se ha encontrado la participación")
-        
+
+    @staticmethod
+    def outAllInSession(session: SesionSensorial | str):
+        try:
+            if isinstance(session, str):
+                use_session = SesionSensorial.objects.get(
+                    codigo_sesion=session)
+            else:
+                use_session = session
+
+            participations = Participacion.objects.filter(
+                tecnica=use_session.tecnica)
+
+            if not participations.exists():
+                message = "No se encontraron participaciones en la sesión"
+                return (False, message)
+
+            participations.update(finalizado=False)
+
+            message = "Participaciones actualizadas a finalizadas"
+            return (True, message)
+        except Exception as e:
+            print(f"Error al actualizar las participaciones: {str(e)}")
+            return (False, "Error al actualizar las participaciones")
+
     @staticmethod
-    def getParticipationsInTechinique(technique: Tecnica| int):
+    def getParticipationsInTechinique(technique: Tecnica | int):
         filters = {}
 
         if isinstance(technique, int):
@@ -44,5 +68,4 @@ class ParticipacionController():
         else:
             filters["tecnica"] = technique
 
-        participations = list(Participacion.objects.filter(**filters))
-        return participations
+        return list(Participacion.objects.filter(**filters))

tecnicas/controllers/models_controller/sesion_controller.py

@@ -1,7 +1,8 @@
 from django.db import DatabaseError
 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
-from ...models import Tecnica, Presentador, SesionSensorial
-from ...utils import controller_error
+from tecnicas.models import Tecnica, Presentador, SesionSensorial
+from tecnicas.utils import controller_error
+from ..models_controller.particiapacion_controller import ParticipacionController
 
 
 class SesionController():
@@ -91,7 +92,7 @@ class SesionController():
             return session
         except SesionSensorial.DoesNotExist:
             return controller_error("La sesión ya no existe")
-        
+
     @staticmethod
     def getSessionByCode(code: str):
         try:
@@ -111,3 +112,22 @@ class SesionController():
             return number_sessions/9
         except Presentador.DoesNotExist:
             return controller_error("presentador invalido")
+
+    @staticmethod
+    def finishRepetion(session: SesionSensorial | str):
+        if isinstance(session, str):
+            use_session = SesionSensorial.objects.get(codigo_sesion=session)
+        else:
+            use_session = session
+
+        (is_update_participations,
+         message) = ParticipacionController.outAllInSession(use_session)
+
+        if not is_update_participations:
+            return controller_error(message)
+
+        use_session.activo = False
+
+        use_session.save()
+
+        return session

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -1,6 +1,6 @@
-from ...models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
+from tecnicas.models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
 from django.db import DatabaseError
-from ...utils import controller_error
+from tecnicas.utils import controller_error
 
 
 class TecnicaController():

tecnicas/controllers/views_controller/main_tester_form_controller.py

@@ -1,4 +1,4 @@
-from ...models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
+from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
 from ...utils import controller_error, shuffleArray
 from django.db import transaction
 
@@ -45,15 +45,12 @@ class MainTesterFormController():
             return controller_error("Catador sin orden")
 
     def isEndedSession(self, id_participation: int, repetition: int):
-        if not self.order or not id_participation:
-            return controller_error("Se requieren datos para comprobar la finalización")
-
         try:
             participation = Participacion.objects.get(id=id_participation)
 
             # ////////////////////////////////////////////////////////////// #
             #
-            # Si numero_calificaciones_esperadas = productos * palabras
+            # Si numero_calificaciones_esperadas = num_productos * num_palabras
             # Es igual a numero_calificaciones_actuales en la repetcion R
             # Ha terminado la repeticion
             #

tecnicas/controllers/views_controller/monitor_sesion_controller.py

@@ -1,5 +1,5 @@
-from tecnicas.models import SesionSensorial
-from tecnicas.controllers import ParticipacionController
+from tecnicas.models import SesionSensorial, EsAtributo, EsVocabulario, Producto, Calificacion
+from tecnicas.controllers import ParticipacionController, SesionController
 from tecnicas.utils import controller_error
 
 
@@ -7,6 +7,10 @@ class MonitorSesionController():
     def __init__(self, session_code: str):
         self.code_session = session_code
 
+    def defineSession(self):
+        self.session = SesionSensorial.objects.get(
+            codigo_sesion=self.code_session)
+
     def monitorView(self):
         try:
             self.sensorial_session = SesionSensorial.objects.select_related(
@@ -30,3 +34,49 @@ class MonitorSesionController():
         }
 
         return context
+
+    def getExpectedRatings(self):
+        num_products = Producto.objects.filter(
+            id_tecnica=self.session.tecnica).count()
+
+        style_words = self.session.tecnica.id_estilo
+
+        num_words: int
+
+        if style_words.nombre_estilo == "atributos":
+            num_words = EsAtributo.objects.get(
+                id_tecnica=self.session.tecnica).palabras.count()
+        elif style_words.nombre_estilo == "vocabulario":
+            num_words = EsVocabulario.objects.get(
+                id_tecnica=self.session.tecnica).id_vocabulario.palabras.count()
+
+        return num_products * num_words
+
+    def checkAllParticipantsEnded(self):
+        self.defineSession()
+
+        technique = self.session.tecnica
+
+        expected_ratings_repetition = self.getExpectedRatings()
+
+        all_participations = ParticipacionController.getParticipationsInTechinique(
+            technique=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()
+
+            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.session)
+        if isinstance(response, dict):
+            return controller_error(response["error"])
+        self.defineSession()
+        return self.session

tecnicas/static/js/finish-session.js

@@ -0,0 +1,5 @@
+function finishSession() {
+  const form = document.querySelector(".action-form");
+  form.querySelector("input").value = "finish_session";
+  form.submit();
+}

tecnicas/templates/tecnicas/components/error-message.html

@@ -0,0 +1,5 @@
+<article class="bg-surface-ligt border-b-2 border-ct-success p-4 text-black rounded cts-message shadow-lg">
+    <p class="font-sans text-xl text-center">
+        {{ message }}
+    </p>
+</article>

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

@@ -1,4 +1,5 @@
 {% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
 
 {% block title %}Monitoreo{% endblock %}
 
@@ -17,22 +18,36 @@
         </article>
         {% endif %}
 
-        <section class="flex flex-col sm:flex-row justify-between items-center gap-10 mb-6">
+        <section class="flex flex-col sm:flex-row justify-between items-center gap-10">
             <p class="text-xl text-center bg-surface-card p-4 text-black rounded-lg shadow-lg">
                 Código de sesión:<br>
                 <span class="font-mono text-2xl font-bold">{{ code_session }}</span>
             </p>
-            <button
-                class="uppercase text-lg max-sm:text-base tracking-wider p-4 rounded-xl bg-ct-error text-white font-bold border-red-800 btn-push">
-                Finalizar sesión
-            </button>
+            <div class="flex flex-col gap-2">
+                <button class="uppercase cts-btn-general-compress cts-btn-secondary py-2 px-6 btn-push"
+                    onclick="finishSession()">
+                    Finalizar sesión
+                </button>
+                <button class="uppercase cts-btn-general-compress cts-btn-error py-2 px-6 btn-push"
+                    onclick="window.history.back()">
+                    Regresar
+                </button>
+            </div>
         </section>
 
+        <form action="" method="post" class="hidden action-form">
+            <input type="hidden" name="action">
+            {% csrf_token %}
+        </form>
+
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
         <section aria-labelledby="catadores-titulo">
             <article
                 class="flex max-sm:flex-col justify-around bg-surface-card border border-gray-300 rounded-md p-3 mb-4 items-center shadow-lg">
-                <button
-                    class="uppercase text-lg max-sm:text-base tracking-wider p-2 px-3 transition-all rounded-xl bg-btn-secondary font-bold btn-push border-pink-800"
+                <button class="uppercase cts-btn-general-compress cts-btn-tertiary py-2 px-6 btn-push"
                     onclick="reloadPage()">
                     Actualizar lista
                 </button>
@@ -108,4 +123,5 @@
         location.reload()
     }
 </script>
+<script src="{% static 'js/finish-session.js' %}"></script>
 {% endblock %}

tecnicas/views/sessions_management/session_monitor.py

@@ -1,17 +1,44 @@
+'''
+Para finalizar la sesion se debe realizar lo siguiente
+# Obtener todas las participaciones
+
+'''
+
 from django.http import HttpRequest, JsonResponse
-from django.shortcuts import render
+from django.shortcuts import render, redirect
+from django.urls import reverse
 from tecnicas.controllers import MonitorSesionController
+from tecnicas.utils import general_error
 
 
 def sessionMonitor(req: HttpRequest, session_code: str):
-    if req.method == "GET":
-        controll_view = MonitorSesionController(session_code)
+    controll_view = MonitorSesionController(session_code)
+    context = controll_view.monitorView()
 
-        context = controll_view.monitorView()
+    if req.method == "GET":
         if "error" in context:
             return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
-        
+
         context["code_session"] = session_code
         return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
+    elif req.method == "POST":
+        action = req.POST["action"]
+        if action == "finish_session":
+            return actionFinishSession(context=context, session_code=session_code, controll_view=controll_view, req=req)
+        else:
+            return general_error("No se ha especificado la acción")
     else:
         return JsonResponse({"error": "Método no permitido"})
+
+
+def actionFinishSession(context: dict, session_code: str, controll_view: MonitorSesionController, req: HttpRequest):
+    context["code_session"] = session_code
+    (is_all_end, message) = controll_view.checkAllParticipantsEnded()
+    context["message"] = message
+    if not is_all_end:
+        return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
+    response = controll_view.finishSession()
+    if isinstance(response, dict):
+        context["message"] = response["error"]
+        return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
+    return redirect(reverse("cata_system:detalles_sesion", kwargs={"session_code": session_code}))

theme/static_src/tailwind.config.js

@@ -16,7 +16,7 @@ module.exports = {
         "surface-alter-card": "#91C4C3",
         "btn-primary": "#4CAF50",
         "btn-secondary": "#E45A92",
-        "btn-tertiary": "#CCECC0",
+        "btn-tertiary": "#88EE88",
         "ct-success": "#2E7D32",
         "ct-error": "#E62727",
       },