Monitoero con PF y controlador para terminar sesion

tecnicas/controllers/__init__.py

@@ -23,9 +23,11 @@ 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.details_cata_controller import DetallesCATAController
 from .views_controller.session_management.details_pf_controller import DetallesPFController
+
 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.session_management.monitor_pf_controller import MonitorPFController
 
 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_pf_controller.py

@@ -1,4 +1,8 @@
-from tecnicas.models import SesionSensorial
+from django.http import HttpRequest
+from django.shortcuts import redirect
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Presentador, Participacion
+from tecnicas.controllers import ParticipacionController
 from .details_controller import DetallesController
 
 
@@ -28,6 +32,36 @@ class DetallesPFController(DetallesController):
 
         return self.context
 
+    def startRepetition(self, presenter: Presentador, request: HttpRequest):
+        creator = presenter
+        technique = self.session.tecnica
+
+        if creator.user.username != self.session.creadoPor.user.username:
+            return self.getResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición o fase", request=request)
+        elif self.session.activo:
+            return self.getResponse(error="La sesión ya está activada", request=request)
+
+        there_participacions = Participacion.objects.filter(
+            tecnica=technique).exists()
+
+        if there_participacions:
+            (is_update_participations,
+             message) = ParticipacionController.outAllInSession(self.session)
+            if not is_update_participations:
+                return self.getResponse(error=message, request=request)
+
+        self.session.activo = True
+        technique.repeticion = technique.repeticion + 1
+
+        technique.save()
+        self.session.save()
+
+        parameters = {
+            "session_code": self.session.codigo_sesion
+        }
+        return redirect(
+            reverse(self.url_next, kwargs=parameters))
+
     def getStatus(self, rep: int, activate: bool):
         status = ""
 

tecnicas/controllers/views_controller/session_management/monitor_escalas_controller.py

@@ -1,6 +1,3 @@
-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

tecnicas/controllers/views_controller/session_management/monitor_pf_controller.py

@@ -0,0 +1,75 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Dato, Participacion, Catador, ListaPalabras, Producto
+from tecnicas.controllers import SesionController
+from .monitor_controller import MonitorController
+
+
+class MonitorPFController(MonitorController):
+    def __init__(self, session: SesionController):
+        super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-session-pf.html"
+        self.previus_view = "cata_system:detalles_sesion"
+
+    def checkAllFinish(self):
+        rep = self.sensorial_session.tecnica.repeticion
+
+        finish_data = ()
+
+        if rep == 1 or rep == 2:
+            finish_data = self.checkFinishFirstPhase()
+        elif rep >= 3:
+            finish_data = self.checkFinishRepetition()
+
+        return finish_data
+
+    def checkFinishFirstPhase(self):
+        num_paricipations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica).count()
+        if num_paricipations < self.sensorial_session.tecnica.limite_catadores:
+            return (False, "No se ha alcanzado el número máximo de catadores")
+
+        unfinished_participations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica, finalizado=False).count()
+        if not unfinished_participations or len(unfinished_participations) > 0:
+            return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")
+
+    def checkFinishRepetition(self) -> tuple[bool, str]:
+        technique = self.sensorial_session.tecnica
+
+        # Revisar numero de catadores sea alcanzado
+        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")
+
+        # Revisar que cada catador haya terminado de calificar sus palabras
+        for particiapation in all_participations:
+            expected_ratings_repetition = self.getExpectedRatings(
+                tester=particiapation.catador)
+
+            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 getExpectedRatings(self, tester: Catador):
+        num_words = ListaPalabras.objects.get(
+            tecnica=self.sensorial_session.tecnica,
+            catador=tester,
+            es_final=True
+        ).palabras.all().count()
+
+        num_products = Producto.objects.filter(
+            id_tecnica=self.sensorial_session.tecnica).count()
+
+        return num_products * num_words

tecnicas/controllers/views_controller/session_management/monitor_rata_controller.py

@@ -1,6 +1,3 @@
-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

tecnicas/migrations/0022_alter_sesionsensorial_codigo_sesion.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.1 on 2025-11-12 20:16
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0021_rename_nomre_vocabulario_vocabulario_nombre_vocabulario_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+    ]

tecnicas/migrations/0023_alter_sesionsensorial_codigo_sesion_listapalabras.py

@@ -0,0 +1,30 @@
+# Generated by Django 5.2.1 on 2025-11-12 20:24
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0022_alter_sesionsensorial_codigo_sesion'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.CreateModel(
+            name='ListaPalabras',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('es_final', models.BooleanField(default=False)),
+                ('catador', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='catador_lista', to='tecnicas.catador')),
+                ('palabras', models.ManyToManyField(related_name='lista_palabras', to='tecnicas.palabra')),
+                ('tecnica', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tecnica_lista', to='tecnicas.tecnica')),
+            ],
+        ),
+    ]

tecnicas/models/__init__.py

@@ -27,4 +27,6 @@ from .dato_valor import ValorBooleano
 from .orden import Orden
 from .orden import Posicion
 
-from .participacion import Participacion
+from .participacion import Participacion
+
+from .lista_palabras import ListaPalabras

tecnicas/models/lista_palabras.py

@@ -0,0 +1,15 @@
+from django.db import models
+from tecnicas.models import Tecnica, Catador, Palabra
+
+
+class ListaPalabras(models.Model):
+    tecnica = models.ForeignKey(
+        Tecnica, on_delete=models.CASCADE, related_name="tecnica_lista")
+    catador = models.ForeignKey(
+        Catador, on_delete=models.CASCADE, related_name="catador_lista")
+    es_final = models.BooleanField(default=False)
+    palabras = models.ManyToManyField(
+        Palabra, related_name="lista_palabras")
+
+    def __str__(self):
+        return f"{self.tecnica.codigo_sesion} - {self.catador.user.username}"

tecnicas/templates/tecnicas/manage_sesions/monitor-session-pf.html

@@ -0,0 +1,126 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Monitoreo{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content">
+        <header class="text-center">
+            <h1 class="text-3xl font-bold text-black">Sesión sensorial en curso</h1>
+        </header>
+
+        <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>
+            <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>
+                <a href="{% url 'cata_system:detalles_sesion' session_code=code_session %}" class="w-full">
+                    <button class="uppercase cts-btn-general-compress cts-btn-error py-2 px-6 btn-push w-full">
+                        Regresar
+                    </button>
+                </a>
+            </div>
+        </section>
+
+        <form action="" method="post" class="hidden action-form">
+            <input type="hidden" name="action">
+            {% csrf_token %}
+        </form>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+
+        {% 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 cts-btn-general-compress cts-btn-tertiary py-2 px-6 btn-push"
+                    onclick="reloadPage()">
+                    Actualizar lista
+                </button>
+                <h2 id="catadores-titulo" class="text-2xl text-center font-bold rounded-lg text-gray-700 py-2 px-3">
+                    Catadores activos
+                </h2>
+            </article>
+
+            <article
+                class="flex flex-col justify-center gap-3 bg-surface-card border border-gray-300 rounded-md p-3 mb-4 text-lg max-sm:text-sm text-gray-700 shadow-lg">
+                <div class="flex justify-center items-center">
+                    <h2 class="text-xl font-semibold">Participantes</h2>
+                </div>
+                <section class="flex flex-wrap justify-around items-center">
+                    <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">
+                        <span class="font-semibold">Máximo:</span>
+                        <span>{{ max_testers }}</span>
+                    </div>
+                    <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">
+                        <span class="font-semibold">
+                            Actuales:
+                        </span>
+                        <span>{{ current_testers }}</span>
+                    </div>
+                    <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">
+                        <span class="font-semibold">Activos:</span>
+                        <span class="text-green-600 font-semibold">{{ active_testers }}</span>
+                    </div>
+                </section>
+            </article>
+
+            <article class="max-sm:overflow-x-auto shadow-lg">
+                <div class="min-w-[400px] sm:min-w-0">
+                    <div
+                        class="grid grid-cols-4 bg-surface-sweet text-center font-semibold text-black text-sm rounded-t-lg max-sm:w-full [&_>*]:px-2">
+                        <div class="py-2 border-r border-gray-400">Usuario</div>
+                        <div class="py-2 border-r border-gray-400">Nombre</div>
+                        <div class="py-2 border-r border-gray-400">Estado</div>
+                        <div class="py-2">Finalizado</div>
+                    </div>
+
+                    <ul class="divide-y divide-gray-400 max-sm:w-full text-black">
+                        {% for parti in participations %}
+                        <li class="grid grid-cols-4 text-center bg-surface-card py-2 [&_>*]:px-2">
+                            <p class="border-r border-gray-400">{{ parti.catador.user.username }}</p>
+                            <p class="border-r border-gray-400">
+                                {{ parti.catador.user.first_name }}
+                                {{ parti.catador.user.last_name}}
+                            </p>
+
+                            {% if parti.activo %}
+                            <p class="border-r border-gray-400 text-green-600 font-semibold">Activo</p>
+                            {% else %}
+                            <p class="border-r border-gray-400 text-red-500 font-semibold">No activo</p>
+                            {% endif %}
+
+                            {% if parti.finalizado %}
+                            <p class="text-green-600 font-semibold">Si</p>
+                            {% else %}
+                            <p class="text-red-500 font-semibold">No</p>
+                            {% endif %}
+                        </li>
+                        {% endfor %}
+                    </ul>
+                </div>
+            </article>
+        </section>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script>
+    function reloadPage () {
+        location.reload()
+    }
+</script>
+<script src="{% static 'js/finish-session.js' %}"></script>
+{% endblock %}

tecnicas/views/sessions_management/session_details.py

@@ -55,16 +55,21 @@ def sessionDetails(req: HttpRequest, session_code: str):
             if req.POST["action"] == "start_session":
                 response = controller_view.startRepetition(
                     presenter=req.user.user_presentador, request=req)
+
             elif req.POST.get("action") == "delete_session":
                 controller_view.deleteSesorialSession()
                 response = redirect(
                     reverse("cata_system:panel_sesiones", kwargs={"page": 1}))
+
             else:
                 response = controller_view.getResponse(
                     error="No se reconoce la acción a realizar")
+
         elif use_techinique == "perfil flash":
-            response = JsonResponse(
-                {"message": "Estoy trabajando en la funcionalidad que eligio"})
+            controller_view = DetallesPFController(session=sensorial_session)
+            response = controller_view.startRepetition(
+                presenter=req.user.user_presentador, request=req)
+
         else:
             response = noValidTechnique()
 

tecnicas/views/sessions_management/session_monitor.py

@@ -3,12 +3,11 @@ Para finalizar la sesion se debe realizar lo siguiente
 # Obtener todas las participaciones
 
 '''
-
 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, MonitorRATAController
+from tecnicas.controllers import MonitorEscalasController, MonitorRATAController, MonitorPFController
 from tecnicas.utils import noValidTechnique
 
 
@@ -21,6 +20,11 @@ def sessionMonitor(req: HttpRequest, session_code: str):
         if use_techinique == "escalas" or use_techinique == "rata" or use_techinique == "cata":
             controll_view = MonitorEscalasController(sensorial_session)
             response = controll_view.controllGetResponse(request=req)
+
+        elif use_techinique == "perfil flash":
+            controll_view = MonitorPFController(sensorial_session)
+            response = controll_view.controllGetResponse(request=req)
+
         else:
             response = noValidTechnique(
                 params={
@@ -47,6 +51,7 @@ def sessionMonitor(req: HttpRequest, session_code: str):
             else:
                 response = controll_view.controlGetResponse(
                     request=req, error="No se ha definido la acción a realizar")
+
         elif use_techinique == "rata" or use_techinique == "cata":
             controll_view = MonitorRATAController(sensorial_session)
             action = req.POST["action"]
@@ -57,6 +62,18 @@ def sessionMonitor(req: HttpRequest, session_code: str):
             else:
                 response = controll_view.controlGetResponse(
                     request=req, error="No se ha definido la acción a realizar")
+
+        elif use_techinique == "perfil flash":
+            controll_view = MonitorPFController(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")
+
         else:
             response = noValidTechnique(
                 params={