Merge pull request #13 from CascoArcilla/HU4

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -48,14 +48,9 @@ class CalificacionController():
         if not repetition:
             return {"error": "sin datos calficados aun"}
 
-        data_rating = {}
+        ratings = list(Calificacion.objects.filter(id_tecnica=technique))
 
-        for i in range(repetition):
-            response_data = Calificacion.objects.filter(
-                id_tecnica=technique, num_repeticion=i+1)
-            data_rating[f"repeticion_{i+1}"] = response_data
-
-        return data_rating
+        return ratings
 
     @staticmethod
     def getRatings(

tecnicas/controllers/models_controller/dato_controller.py

@@ -1,6 +1,7 @@
-from ...models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano
+from ...models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano, Tecnica
 from ...utils import controller_error, getId
 from django.core.exceptions import ValidationError
+from django.db.models import F
 
 
 class DatoController():
@@ -36,7 +37,7 @@ class DatoController():
 
     def setInstanceValue(self):
         technique = self.data.id_calificacion.id_tecnica
-        
+
         if technique.tipo_tecnica == "cata":
             self.value_data = ValorBooleano(
                 id_dato=self.data,
@@ -72,3 +73,25 @@ class DatoController():
             id_calificacion_id__in=ids_ratings))
 
         return recoreded_data
+
+    @staticmethod
+    def getWordValuesForConvecional(technique: Tecnica, ratings: list[Calificacion]):
+        model = ValorBooleano if technique.tipo_tecnica == "cata" else ValorDecimal
+
+        ids_ratings = [rat.id for rat in ratings]
+
+        result = (
+            model.objects
+            .filter(id_dato__id_calificacion_id__in=ids_ratings)
+            .values(
+                nombre_palabra=F("id_dato__id_palabra__nombre_palabra"),
+                repeticion=F("id_dato__id_calificacion__num_repeticion"),
+                producto_code=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+                usuarioCatador=F(
+                    "id_dato__id_calificacion__id_catador__usuarioCatador"),
+                dato_valor=F("valor")
+            )
+        )
+
+        return list(result)

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

@@ -1,24 +1,70 @@
-from ...models import SesionSensorial, Presentador, Tecnica
+'''
+
+Para Tecnicas Convencionales, CATA, RATA, Escala Hedonica
+Encabezados de como deben de aparecer los datos por repeticion
+
+| Repeticion: R
+| Codigo Producto | Catador | P1 | P2 | P3 | Pn |
+
+Encabezados de como deben de aparecer los datos juntos
+
+| Repeticion | Codigo Producto | Catador | P1 | P2 | P3 | Pn |
+
+'''
+
+from ...models import SesionSensorial, Presentador, Tecnica, Palabra
 from .. import CalificacionController, PalabrasController
 from ...utils import controller_error
+from collections import defaultdict
+from tecnicas.controllers import DatoController
+from tecnicas.utils import defaultdict_to_dict
 
 
 class DetallesSesionController():
-    @staticmethod
-    def getContextForView(session_code: str):
-        context = {}
+    def __init__(self, session_code: str):
+        self.session = SesionSensorial.objects.get(codigo_sesion=session_code)
+
+    def getContextForView(self):
+        self.context = {}
 
-        session = SesionSensorial.objects.get(codigo_sesion=session_code)
-        context["sesion"] = session
+        self.context["sesion"] = self.session
 
-        words = PalabrasController.getWordsInTechnique(session.tecnica)
-        context["palabras"] = words
+        self.words = PalabrasController.getWordsInTechnique(
+            self.session.tecnica)
+        self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
-        rating = CalificacionController.getRatingsByTechnique(
-            technique=session.tecnica)
-        context["calificaciones"] = rating
+    def getContextWithData(self):
+        ratings_for_repetition = []
 
-        return context
+        ratings = CalificacionController.getRatingsByTechnique(
+            technique=self.session.tecnica)
+
+        if isinstance(ratings, dict) or not ratings:
+            self.context["calificaciones"] = ratings_for_repetition
+            self.context["existen_calificaciones"] = False
+            return self.context
+
+        data = DatoController.getWordValuesForConvecional(
+            ratings=ratings, technique=self.session.tecnica)
+
+        ratings_for_repetition = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(list)))
+
+        for item in data:
+            user = item["usuarioCatador"]
+            rep = item["repeticion"]
+            prod = item["producto_code"]
+
+            ratings_for_repetition[rep][user][prod].append({
+                "nombre_palabra": item["nombre_palabra"],
+                "dato_valor": item["dato_valor"]
+            })
+
+        self.context["calificaciones"] = defaultdict_to_dict(
+            ratings_for_repetition)
+        self.context["existen_calificaciones"] = True
+
+        return self.context
 
     @staticmethod
     def startRepetition(session_code: str, username: str):
@@ -45,5 +91,5 @@ class DetallesSesionController():
 
         technique.save()
         session.save()
-    
+
         return session

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/models/dato.py

@@ -3,6 +3,12 @@ from django.db import models
 from .palabra import Palabra
 from .calificacion import Calificacion
 
+
 class Dato(models.Model):
-    id_palabra = models.ForeignKey(Palabra, on_delete=models.CASCADE, related_name="dato_palabra")
-    id_calificacion = models.ForeignKey(Calificacion, on_delete=models.CASCADE, related_name="dato_calificacion")
+    id_palabra = models.ForeignKey(
+        Palabra, on_delete=models.CASCADE, related_name="dato_palabra")
+    id_calificacion = models.ForeignKey(
+        Calificacion, on_delete=models.CASCADE, related_name="dato_calificacion")
+
+    def __str__(self):
+        return f"{self.id_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.usuarioCatador}"

tecnicas/models/dato_valor.py

@@ -2,16 +2,20 @@ from django.db import models
 
 from .dato import Dato
 
+
 class ValorDecimal(models.Model):
-    id_dato = models.OneToOneField(Dato, on_delete=models.CASCADE, related_name="dato_decimal")
+    id_dato = models.OneToOneField(
+        Dato, on_delete=models.CASCADE, related_name="dato_decimal")
     valor = models.FloatField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"
+
 
 class ValorBooleano(models.Model):
-    id_dato = models.OneToOneField(Dato, on_delete=models.CASCADE, related_name="dato_boolean")
+    id_dato = models.OneToOneField(
+        Dato, on_delete=models.CASCADE, related_name="dato_boolean")
     valor = models.BooleanField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"

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

@@ -0,0 +1,47 @@
+<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">Usuario</th>
+                    <th class="py-2 px-3 border border-surface-general">Producto</th>
+                    {% for palabra in palabras %}
+                    <th class="py-2 px-3 border border-surface-general uppercase">{{ palabra }}</th>
+                    {% endfor %}
+                </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 %}
+                        {{ palabra }} <br>
+                        {{ valor.dato_valor }}
+                        {% with match=True %}{% endwith %}
+                        {% endif %}
+                        {% endfor %}
+                        {% if not match %}0{% endif %}
+                        {% endwith %}
+                    </td>
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+
+    <div class="flex justify-end mt-3">
+        <button class="cts-btn-general cts-btn-primary btn-push">
+            Descargar CSV
+        </button>
+    </div>
+</section>

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

@@ -6,20 +6,17 @@
 {% block content %}
 <article class="cts-container-main">
     <article class="cts-wrap-content">
-        <header class="text-center flex-row w-full flex justify-around items-center flex-wrap gap-10">
+        <header class="text-center flex-row max-sm:flex-col w-full flex justify-around items-center flex-wrap gap-10">
             <h1 class="text-black rounded-xl font-bold text-2xl bg-surface-card shadow-lg p-4 flex-1">
                 Detalles de la sesión
             </h1>
-            <a href="{% url 'cata_system:index' %}" class="w-fit">
-                <button
-                    class="cts-btn-general cts-btn-error btn-push">
-                    Volver a las Sesiones
-                </button>
-            </a>
+            <button class="cts-btn-general cts-btn-error btn-push" onclick="window.history.back()">
+                Volver a las Sesiones
+            </button>
         </header>
 
         {% if error %}
-        <article class="bg-red-600 p-4 text-white rounded-xl ct-notification-error">
+        <article class=" bg-red-600 p-4 text-white rounded-xl ct-notification-error">
             <p class="block font-sans text-white text-xl antialiased font-bold uppercase tracking-wider text-center">
                 {{ error }}
             </p>
@@ -111,7 +108,7 @@
             </section>
 
             <section>
-                <p class="font-medium">
+                <p class="font-bold">
                     Rep. Max:
                 </p>
                 <p class="font-sans text-lg max-sm:text-base font-normal">
@@ -137,7 +134,7 @@
             {% for palabra in palabras %}
             <section>
                 <p class="block text-black text-xl antialiased font-medium">
-                    {{ palabra.nombre_palabra }}
+                    {{ palabra }}
                 </p>
             </section>
             {% endfor %}
@@ -182,16 +179,16 @@
             Datos obtenidos
         </p>
 
-        {% if calificaciones.error %}
-        <article class="bg-surface-card p-4 text-white rounded-xl">
-            <p class="block font-sans text-xl antialiased font-normal uppercase tracking-wider text-center">
-                {{ calificaciones.error }}
-            </p>
+        {% if existen_calificaciones %}
+        <article class="bg-surface-card p-4 max-sm:px-2 text-black rounded">
+            {% for repeticion, catadores in calificaciones.items %}
+            {% include "../components/table-convencional.html" with repeticion=repeticion catadores=catadores palabras=palabras %}
+            {% endfor %}
         </article>
         {% else %}
-        <article class="bg-surface-card p-4 text-white rounded-xl">
-        </article>
+        {% include "../components/error-message.html" with message='Sin calificaciones que mostrar aún' %}
         {% endif %}
+
         <form action="" method="post" class="form-action-session hidden">
             {% csrf_token %}
         </form>

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/templates/tecnicas/manage_sesions/sesiones-panel.html

@@ -22,7 +22,7 @@
         <section class="grid grid-cols-3 max-lg:grid-cols-2 max-sm:grid-cols-1 w-full gap-4 justify-center">
             {% for sesion in sessions %}
             <div class="card bg-surface-card shadow-lg text-black sm:max-w-80 w-full flex justify-center items-center">
-                <div class="card-body flex flex-col justify-between">
+                <div class="card-body flex flex-col justify-between w-full">
                     <div class="flex flex-col gap-1 [&>*]:first:text-xl [&>*]:first:font-bold [&>*]:first:border-b">
                         {% if sesion.nombre_sesion %}
                         <h2>{{ sesion.nombre_sesion }}</h2>

tecnicas/utils/__init__.py

@@ -2,4 +2,5 @@ from .code_generate import generarCodigo
 from .code_generate import generarCodigos
 from .personal_errors import general_error, controller_error
 from .shuffle_arrays import shuffleArray
-from .general_controllers import getId
+from .general_controllers import getId
+from .to_dict import defaultdict_to_dict

tecnicas/utils/to_dict.py

@@ -0,0 +1,9 @@
+from collections import defaultdict
+
+
+def defaultdict_to_dict(d):
+    if isinstance(d, defaultdict):
+        d = {k: defaultdict_to_dict(v) for k, v in d.items()}
+    elif isinstance(d, dict):
+        d = {k: defaultdict_to_dict(v) for k, v in d.items()}
+    return d

tecnicas/views/sessions_management/session_details.py

@@ -5,19 +5,21 @@ from ...controllers import DetallesSesionController
 
 
 def sessionDetails(req: HttpRequest, session_code: str):
-    context = DetallesSesionController.getContextForView(session_code)
+    controller_view = DetallesSesionController(session_code)
+    context = controller_view.getContextForView()
 
     if req.method == "GET":
+        context = controller_view.getContextWithData()
         return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
     elif req.method == "POST":
         if req.POST["action"] == "start_session":
             response = DetallesSesionController.startRepetition(
                 session_code=session_code, username=req.POST["username"])
             if isinstance(response, dict):
+                context = controller_view.getContextWithData()
                 context["error"] = response["error"]
                 return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
-            context["message"] = "La sesión ha iniciado"
-            return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
+            return redirect(reverse("cata_system:monitor_sesion"))
         elif req.POST.get("action") == "delete_session":
             pass
         elif req.POST.get("action") == "monitor_session":

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",
       },