Ingreso a sesion con cata

tecnicas/controllers/__init__.py

@@ -28,8 +28,10 @@ from .views_controller.session_management.monitor_rata_controller import Monitor
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.init_session_tester_controller import InitSessionTesterController
-from .views_controller.sessions_tester.convencional_scales_controller import ConvencionalScalesController
 from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
+from .views_controller.sessions_tester.test_scales_controller import TestScalesController
+from .views_controller.sessions_tester.test_rata_controller import TestRataController
+from .views_controller.sessions_tester.test_cata_controller import TestCataController
 
 from .views_controller.vocabulary_manage.create_vocabulary_controller import CreateVocabularyController
 from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController

tecnicas/controllers/views_controller/sessions_tester/general_test_controller.py

@@ -0,0 +1,14 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Catador
+
+
+class GenetalTestController():
+    previus_directory = "cata_system:catador_init_session"
+    context = {}
+    current_directory: str
+
+    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
+        self.tester = user_tester
+        self.session = sensorial_session

tecnicas/controllers/views_controller/sessions_tester/test_cata_controller.py

@@ -0,0 +1,55 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Producto, Participacion, Palabra, Calificacion
+from tecnicas.controllers import PalabrasController
+from .general_test_controller import GenetalTestController
+
+
+class TestCataController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/cata.html"
+
+    def controllGet(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        self.context["session"] = self.session
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        use_product: Producto = None
+        use_words: list[Palabra] = None
+
+        # Revisamos el producto que le falten calificaciones
+        for current_product in products_in_technique:
+            try:
+                rating = Calificacion.objects.get(
+                    num_repeticion=technique.repeticion,
+                    id_producto=current_product,
+                    id_tecnica=technique,
+                    id_catador=self.tester
+                )
+            except Calificacion.DoesNotExist:
+                # Si no hay calificacion mandamos el producto actual y todas la palabras
+                use_product = current_product
+                use_words = words
+                break
+
+        # Si no hay producto que falta por calificar finalizar sesion para el Catador
+        if not use_product:
+            updated_participation = ParticipacionController.finishSession(
+                self.participation)
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["product"] = use_product
+        self.context["words"] = use_words
+
+        return render(request, self.current_directory, self.context)

tecnicas/controllers/views_controller/sessions_tester/test_rata_controller.py

@@ -0,0 +1,81 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Participacion, Producto, Calificacion, Palabra
+from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
+from .general_test_controller import GenetalTestController
+
+
+class TestRataController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/convencional.html"
+
+    def controllGet(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        self.context["session"] = self.session
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        use_product: Producto = None
+        use_words: list[Palabra] = None
+
+        # Revisamos el producto que le falten calificaciones
+        for current_product in products_in_technique:
+            try:
+                rating = Calificacion.objects.get(
+                    num_repeticion=technique.repeticion,
+                    id_producto=current_product,
+                    id_tecnica=technique,
+                    id_catador=self.tester
+                )
+            except Calificacion.DoesNotExist:
+                # Si no hay calificacion mandamos el producto actual y todas la palabras
+                use_product = current_product
+                use_words = words
+                break
+
+            # Obtener los datos asociados para la calificacion para ver que palabras quedan por calificar
+            recoreded_data = rating.dato_calificacion.all()
+
+            if not recoreded_data:
+                # Si no hay datos entonces devolver el producto con todas las palabras
+                use_product = current_product
+                use_words = words
+                break
+            else:
+                words_to_use = PalabrasController.getWordsWithoutData(
+                    recoreded_data=recoreded_data, words=words)
+
+                # Si quedan palabras por calificar mandar las palabras con el producto
+                if not isinstance(words_to_use, dict) and words_to_use:
+                    use_product = current_product
+                    use_words = words_to_use
+                    break
+
+        # Si no hay producto que falta por calificar finalizar sesion para el Catador
+        if not use_product:
+            updated_participation = ParticipacionController.finishSession(
+                self.participation)
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["product"] = use_product
+        self.context["words"] = use_words
+
+        # Agregar informacion de la escala
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        self.context["scale"] = scale
+        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        self.context["tags"] = use_tags
+
+        return render(request, self.current_directory, self.context)

tecnicas/controllers/views_controller/sessions_tester/{convencional_scales_controller.py → test_scales_controller.py}

@@ -2,19 +2,16 @@ from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
 from tecnicas.models import SesionSensorial, Catador, Participacion, Producto, Calificacion, Palabra
-from tecnicas.controllers import PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+from tecnicas.controllers import PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController
+from .general_test_controller import GenetalTestController
 
 
-class ConvencionalScalesController:
-    context = {}
-    current_directory = "tecnicas/forms_tester/convencional.html"
-    previus_directory = "cata_system:catador_init_session"
+class TestScalesController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/convencional.html"
 
-    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
-        self.tester = user_tester
-        self.session = sensorial_session
-
-    def controllGetEscalas(self, request: HttpRequest):
+    def controllGet(self, request: HttpRequest):
         technique = self.session.tecnica
         self.participation = Participacion.objects.get(
             tecnica=technique, catador=request.user.user_catador)
@@ -82,77 +79,4 @@ class ConvencionalScalesController:
         ctx["type_scale"] = scale.id_tipo_escala.nombre_escala
         ctx["tags"] = EscalaController.getRelatedTagsInScale(scale=scale)
 
-        return render(request, self.current_directory, ctx)
-
-    def controllGetRATA(self, request: HttpRequest):
-        technique = self.session.tecnica
-        self.participation = Participacion.objects.get(
-            tecnica=technique, catador=request.user.user_catador)
-
-        self.context["session"] = self.session
-
-        products_in_technique = Producto.objects.filter(id_tecnica=technique)
-
-        words = PalabrasController.getWordsInTechnique(technique=technique)
-
-        use_product: Producto = None
-        use_words: list[Palabra] = None
-
-        # Revisamos el producto que le falten calificaciones
-        for current_product in products_in_technique:
-            try:
-                rating = Calificacion.objects.get(
-                    num_repeticion=technique.repeticion,
-                    id_producto=current_product,
-                    id_tecnica=technique,
-                    id_catador=self.tester
-                )
-                there_rating = True
-            except Calificacion.DoesNotExist:
-                there_rating = False
-
-            # Si no hay calificacion mandamos el producto actual y todas la palabras
-            if not there_rating:
-                use_product = current_product
-                use_words = words
-                break
-
-            # Obtener los datos asociados para la calificacion para ver que palabras quedan por calificar
-            recoreded_data = rating.dato_calificacion.all()
-
-            if not recoreded_data:
-                # Si no hay datos entonces devolver el producto con todas las palabras
-                use_product = current_product
-                use_words = words
-                break
-            else:
-                words_to_use = PalabrasController.getWordsWithoutData(
-                    recoreded_data=recoreded_data, words=words)
-
-                # Si quedan palabras por calificar mandar las palabras con el producto
-                if not isinstance(words_to_use, dict) and words_to_use:
-                    use_product = current_product
-                    use_words = words_to_use
-                    break
-
-        # Si no hay producto que falta por calificar finalizar sesion para el Catador
-        if not use_product:
-            updated_participation = ParticipacionController.finishSession(
-                self.participation)
-            params = {
-                "code_sesion": self.session.codigo_sesion
-            }
-            return redirect(reverse(self.previus_directory, kwargs=params))
-
-        self.context["product"] = use_product
-        self.context["words"] = use_words
-
-        # Agregar informacion de la escala
-        scale = EscalaController.getScaleByTechnique(technique=technique)
-        self.context["scale"] = scale
-        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
-
-        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
-        self.context["tags"] = use_tags
-
-        return render(request, self.current_directory, self.context)
+        return render(request, self.current_directory, ctx)

tecnicas/templates/tecnicas/forms_tester/cata.html

@@ -0,0 +1,121 @@
+{% extends 'tecnicas/layouts/base.html' %}
+
+{% load static %}
+
+{% block title %}Convencional{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black">
+        <header class="text-center flex-row w-full items-stretch flex justify-around flex-wrap gap-2">
+            <h1 class="rounded font-bold text-2xl bg-surface-ligt p-4 flex-1">
+                Sesión usando <br>técnica
+                <span class="uppercase">{{ session.tecnica.tipo_tecnica }}</span>
+            </h1>
+            <button class="cts-btn-general cts-btn-error btn-push" onclick="exit_sesion('form-actions')">
+                Salir de la sesión
+            </button>
+        </header>
+
+        <article class="hidden">
+            <form action="{% url 'cata_system:catador_init_session' code_sesion=session.codigo_sesion %}" method="post"
+                class="form-actions">
+                {% csrf_token %}
+                <input type="hidden" name="action" class="action-input">
+            </form>
+        </article>
+
+        <section class="hidden">
+            <input type="hidden" value="{{ session.tecnica.id }}" name="id-tecnica" class="ct-input-id-tech">
+        </section>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
+        <article class="rounded flex flex-col gap-4">
+            <section class="flex items-center justify-center bg-surface-ligt p-2 rounded-lg">
+                <p class="text-lg font-medium text-center">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+            <section class="flex items-center justify-center flex-wrap gap-4">
+                <div class="bg-surface-ligt p-2 rounded-lg flex-1">
+                    <p class="text-lg font-bold text-center">
+                        Producto:
+                    </p>
+                    <p class="text-2xl font-bold text-center ct-product-rating">
+                        <span class="code-product">{{ product }}</span>
+                        <span class="hidden id-product">{{ product.id }}</span>
+                    </p>
+                </div>
+                <div class="bg-surface-ligt p-2 rounded-lg flex-1">
+                    <p class="text-lg font-bold text-center">
+                        Repetición:
+                    </p>
+                    <p class="text-2xl font-bold text-center">
+                        {{ session.tecnica.repeticion }}
+                    </p>
+                </div>
+            </section>
+            <section class="flex flex-col bg-red-200 py-2 px-4 rounded-lg min-sm:hidden">
+                <p>
+                    El largo de estas escalas puede afectar la vista en dispositivos móviles. Para ver el resto de la
+                    escala puede deslizar con el dedo a la derecha o la izquierda sin tocar la escala.
+                </p>
+            </section>
+        </article>
+
+        <article class="words-check-container w-full max-w-3xl mx-auto p-6 bg-base-200 rounded-xl shadow-lg">
+            <form id="wordsForm" method="POST" class="flex flex-col gap-4">
+                {% csrf_token %}
+                {% for word in words %}
+                <label
+                    class="flex items-center justify-between bg-base-100 p-4 rounded-lg shadow-sm hover:shadow-md transition-all">
+                    <span class="text-lg font-medium">{{ word }}</span>
+                    <input type="checkbox" name="word_{{ word.id }}" class="checkbox checkbox-primary"
+                        data-word-id="{{ word.id }}" />
+                </label>
+                {% empty %}
+                <p class="text-center text-gray-500">No hay palabras disponibles.</p>
+                {% endfor %}
+
+                <button type="submit" class="btn btn-primary mt-6">
+                    Enviar calificaciones
+                </button>
+            </form>
+        </article>
+    </article>
+</article>
+
+<script>
+    document.addEventListener("DOMContentLoaded", () => {
+        const form = document.getElementById("wordsForm")
+
+        form.addEventListener("submit", (e) => {
+            e.preventDefault() // prevenimos envío por defecto
+            const checkboxes = form.querySelectorAll('input[type="checkbox"]')
+            const unchecked = Array.from(checkboxes).filter(cb => !cb.checked)
+
+            if (unchecked.length > 0) {
+                const confirmLeaveBlank = confirm(
+                    "Algunas palabras no han sido marcadas. ¿Deseas continuar dejando esas casillas en blanco?"
+                )
+
+                if (!confirmLeaveBlank) {
+                    return
+                }
+            }
+
+            form.submit()
+        })
+    });
+</script>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/actions-form.js' %}"></script>
+{% endblock %}

tecnicas/urls.py

@@ -110,6 +110,10 @@ urlpatterns = [
          views.convencionalScales,
          name="session_convencional"),
 
+    path("testers/init-session/<str:code_sesion>/cata",
+         views.cataTest,
+         name="session_cata"),
+
 
     # APIs
     path("presenter/api/nueva-etiqueta",

tecnicas/views/__init__.py

@@ -28,7 +28,9 @@ from .apis.api_words import wordsVocabulary
 from .apis.rating_word import reatingWord
 
 from .tester_forms.init_tester_form import initTesterForm
-from .tester_forms.convencional_scales import convencionalScales
 from .tester_forms.panel_main_tester import mainPanelTester
 from .tester_forms.login_session import loginSessionTester
 from .tester_forms.sessions_list_tester import sessionsListTester
+from .tester_forms.convencional_scales import convencionalScales
+from .tester_forms.cata_test import cataTest
+

tecnicas/views/sessions_management/session_details.py

@@ -35,14 +35,14 @@ def sessionDetails(req: HttpRequest, session_code: str):
                 },
                 name_view="cata_system:panel_sesiones"
             )
-
         return response
+    
     elif req.method == "POST":
         sensorial_session = SesionSensorial.objects.get(
             codigo_sesion=session_code)
         use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
 
-        if use_techinique == "escalas" or use_techinique == "rata":
+        if use_techinique == "escalas" or use_techinique == "rata" or use_techinique == "cata":
             controller_view = DetallesEscalasController(sensorial_session)
 
             if req.POST["action"] == "start_session":

tecnicas/views/sessions_management/session_monitor.py

@@ -18,7 +18,7 @@ def sessionMonitor(req: HttpRequest, session_code: str):
             codigo_sesion=session_code)
         use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
 
-        if use_techinique == "escalas" or use_techinique == "rata":
+        if use_techinique == "escalas" or use_techinique == "rata" or use_techinique == "cata":
             controll_view = MonitorEscalasController(sensorial_session)
             response = controll_view.controlGetResponse(request=req)
         else:

tecnicas/views/tester_forms/cata_test.py

@@ -0,0 +1,12 @@
+from django.http import HttpRequest
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import TestCataController
+from tecnicas.utils import noValidTechnique
+
+
+def cataTest(req: HttpRequest, code_sesion: str):
+    if req.method == "GET":
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestCataController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllGet(request=req)

tecnicas/views/tester_forms/convencional_scales.py

@@ -55,21 +55,26 @@
             - Cata segmento en el que se divide debe tener la etiqueda correspondiente por debajo
 '''
 from django.http import HttpRequest
-from tecnicas.controllers import SesionController, ConvencionalScalesController
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import TestRataController, TestScalesController
 from tecnicas.utils import noValidTechnique
 
 
 def convencionalScales(req: HttpRequest, code_sesion: str):
-    session = SesionController.getSessionByCode(code_sesion)
+    session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
     type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
 
     if req.method == "GET":
-        view_controller = ConvencionalScalesController(
-            sensorial_session=session, user_tester=req.user.user_catador)
         if type_technique == "escalas":
-            respose = view_controller.controllGetEscalas(request=req)
+            view_controller = TestScalesController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            respose = view_controller.controllGet(request=req)
+
         elif type_technique == "rata":
-            respose = view_controller.controllGetRATA(request=req)
+            view_controller = TestRataController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            respose = view_controller.controllGet(request=req)
+
         else:
             respose = noValidTechnique(
                 name_view='cata_system:catador_init_session',