Merge pull request #33 from CascoArcilla/HU9

tecnicas/controllers/__init__.py

@@ -28,11 +28,14 @@ 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
 
-from .views_controller.api_rating_controller import ApiRatingController
+from .api_controller.rating_sacales_controller import RatingScalesController
+from .api_controller.rating_cata_controller import RatingCataController
 from .views_controller.tester_list_controller import TesterListController

tecnicas/controllers/api_controller/rating_cata_controller.py

@@ -0,0 +1,78 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction
+from tecnicas.models import Calificacion, Dato, ValorBooleano, Participacion, Palabra
+
+
+class RatingCataController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def saveRatingWords(request: HttpRequest, data_words: list[dict], data_prodct: dict):
+        try:
+            with transaction.atomic():
+                participation = Participacion.objects.get(
+                    id=request.session["id_participation"])
+                if not participation:
+                    raise ValueError("No está autorizado en la sesión")
+
+                ids_words = []
+                words_values = {}
+
+                # Acoplar datos para usar
+                for da_wo in data_words:
+                    ids_words.append(da_wo["id"])
+                    words_values[da_wo["word"]] = da_wo["is_check"]
+
+                words_for_rating = Palabra.objects.filter(id__in=ids_words)
+                if not words_for_rating:
+                    raise ValueError("No se han encontrado sus palabras")
+
+                technique = participation.tecnica
+
+                # Creando la calificacion
+                (rating, creataed) = Calificacion.objects.get_or_create(
+                    num_repeticion=technique.repeticion,
+                    id_producto_id=data_prodct["id"],
+                    id_tecnica=technique,
+                    id_catador=request.user.user_catador
+                )
+                if not rating:
+                    raise ValueError("Problemas al crear la calificación")
+
+                # Guardando datos
+                data_for_save = []
+                for word in words_for_rating:
+                    data_for_save.append(Dato(
+                        id_palabra=word,
+                        id_calificacion=rating
+                    ))
+
+                Dato.objects.bulk_create(data_for_save)
+                data_saved = Dato.objects.filter(
+                    id_calificacion=rating).only("id_palabra")
+                if not data_saved:
+                    raise ValueError("Problemas al crear los datos")
+
+                # Guardando valores de datos
+                values_for_save = []
+                for data in data_saved:
+                    word_for_rating = data.id_palabra.nombre_palabra
+                    values_for_save.append(
+                        ValorBooleano(
+                            id_dato=data,
+                            valor=words_values[word_for_rating]
+                        )
+                    )
+
+                ValorBooleano.objects.bulk_create(values_for_save)
+                values_saves = ValorBooleano.objects.filter(
+                    id_dato__id_calificacion=rating).count()
+                if not values_saves:
+                    raise ValueError("Error al guardar los datos")
+
+            return JsonResponse({"message": "Valores guardados"})
+
+        except ValueError as e:
+            print(f"Error de calificacion: {e}")
+            return JsonResponse({"error": e}, statusstatus=500)

tecnicas/controllers/{views_controller/api_rating_controller.py → api_controller/rating_sacales_controller.py}

@@ -1,8 +1,8 @@
-from ...controllers import CalificacionController, DatoController
+from .. import CalificacionController, DatoController
 from ...utils import controller_error
 
 
-class ApiRatingController():
+class RatingScalesController():
     def __init__(self, rating_controller: CalificacionController, data_controller: DatoController):
         self.rating_controller = rating_controller
         self.data_controller = data_controller

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -21,7 +21,7 @@ class CalificacionController():
     @staticmethod
     def getRatingsByTechnique(technique: Tecnica):
         repetition = technique.repeticion
-        ratings = list(Calificacion.objects.filter(id_tecnica=technique))
+        ratings = list(Calificacion.objects.filter(id_tecnica=technique, num_repeticion=repetition))
         return ratings
 
     @staticmethod

tecnicas/controllers/views_controller/session_management/details_cata_controller.py

@@ -1,7 +1,8 @@
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
-from tecnicas.models import SesionSensorial
-from tecnicas.controllers import PalabrasController, DatoController, CalificacionController
+from django.db.models import F
+from tecnicas.models import SesionSensorial, Calificacion, ValorBooleano
+from tecnicas.controllers import PalabrasController, DatoController
 from tecnicas.utils import defaultdict_to_dict
 from .details_controller import DetallesController
 from collections import defaultdict
@@ -29,16 +30,27 @@ class DetallesCATAController(DetallesController):
         # Intentar recuperar las calificaciones
         ratings_for_repetition = []
 
-        ratings = CalificacionController.getRatingsByTechnique(
-            technique=technique)
+        ratings = list(Calificacion.objects.filter(
+            id_tecnica=technique))
 
-        if isinstance(ratings, dict) or not ratings:
+        if not ratings:
             self.context["calificaciones"] = ratings_for_repetition
             self.context["existen_calificaciones"] = False
             return self.context
 
-        data = DatoController.getWordValuesForConvecional(
-            ratings=ratings, technique=technique)
+        data = (
+            ValorBooleano.objects
+            .filter(id_dato__id_calificacion__in=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"),
+                usuario_catador=F(
+                    "id_dato__id_calificacion__id_catador__user__username"),
+                dato_valor=F("valor")
+            )
+        )
 
         ratings_for_repetition = defaultdict(
             lambda: defaultdict(lambda: defaultdict(list)))

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

@@ -13,6 +13,7 @@ class InitSessionTesterController():
     order: Orden | dict
     current_direction = "tecnicas/forms_tester/init_session.html"
     escalas_direction = "cata_system:session_convencional"
+    cata_cirection = "cata_system:session_cata"
 
     def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
         self.tester = user_tester
@@ -65,13 +66,19 @@ class InitSessionTesterController():
                 return render(request, self.current_direction, context)
 
             request.session["id_participation"] = update_participation.id
+
+            if self.session.tecnica.tipo_tecnica.nombre_tecnica == "cata":
+                return redirect(reverse(self.cata_cirection, kwargs=parameters))
+            
             return redirect(reverse(self.escalas_direction, kwargs=parameters))
+
         elif request.POST["action"] == "exit_session":
             response = ParticipacionController.outSession(
                 tester=request.user.user_catador, session=self.session)
             if isinstance(response, dict):
                 context["error"] = response["error"]
             return render(request, self.current_direction, context)
+
         else:
             context["error"] = "Acción sin especificar"
             return render(request, self.current_direction, context)

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, ParticipacionController
+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/static/js/created-scale.js

@@ -44,7 +44,7 @@ async function sendRating(word) {
   const formRatingWord = document.querySelector(`.form-rating-${word}`);
 
   const dataForm = new FormData(formRatingWord);
-  const url = "/cata/testers/api/ratingword";
+  const url = "/cata/testers/api/ratingword/escalas";
 
   const codeProduct = document
     .querySelector(".ct-product-rating")

tecnicas/static/js/test-cata.js

@@ -0,0 +1,128 @@
+document.addEventListener("DOMContentLoaded", () => {
+  const containFormData = document.querySelector(".words-check-container");
+
+  const form = document.getElementById("wordsForm");
+  const csrfToken = document.querySelector("[name=csrfmiddlewaretoken]").value;
+  const message = document.getElementById("response-message");
+
+  const modal = document.getElementById("confirmModal");
+  const modalContent = document.getElementById("confirmModalContent");
+  const cancelBtn = document.getElementById("cancelBtn");
+  const confirmBtn = document.getElementById("confirmBtn");
+
+  const URL = "/cata/testers/api/ratingword/cata";
+
+  const checkboxes = form.querySelectorAll('input[type="checkbox"]');
+  checkboxes.forEach((cb) => (cb.checked = false));
+
+  let wordsData = [];
+
+  form.addEventListener("submit", (e) => {
+    e.preventDefault();
+
+    const checkboxes = form.querySelectorAll('input[type="checkbox"]');
+    wordsData = Array.from(checkboxes).map((cb) => ({
+      id: parseInt(cb.dataset.wordId),
+      word: cb.dataset.wordName,
+      is_check: cb.checked,
+    }));
+
+    showModal(wordsData);
+  });
+
+  function showModal(words) {
+    const checkedWords = words.filter((w) => w.is_check);
+    const uncheckedWords = words.filter((w) => !w.is_check);
+
+    modalContent.innerHTML = `
+            <div>
+                <p class="font-semibold text-green-600">Palabras seleccionadas:</p>
+                <ul class="flex flex-wrap gap-2">
+                    ${
+                      checkedWords.length > 0
+                        ? checkedWords
+                            .map(
+                              (w) =>
+                                `<li class="border-r border-b p-1">${w.word}</li>`
+                            )
+                            .join("")
+                        : '<li class="border-b p-1 w-full">Ninguna</li>'
+                    }
+                </ul>
+            </div>
+            <div class="mt-3">
+                <p class="font-semibold text-red-600">Palabras no seleccionadas:</p>
+                <ul class="flex flex-wrap gap-2">
+                    ${
+                      uncheckedWords.length > 0
+                        ? uncheckedWords
+                            .map(
+                              (w) =>
+                                `<li class="border-r border-b p-1">${w.word}</li>`
+                            )
+                            .join("")
+                        : '<li class="border-b p-1 w-full">Todas seleccionadas</li>'
+                    }
+                </ul>
+            </div>
+        `;
+    modal.classList.remove("hidden");
+  }
+
+  cancelBtn.addEventListener("click", () => {
+    modalContent.innerHTML = "";
+    modal.classList.add("hidden");
+  });
+
+  confirmBtn.addEventListener("click", async () => {
+    modal.classList.add("hidden");
+    const dataProduct = {
+      id: parseInt(document.querySelector(".id-product").textContent),
+      code: document.querySelector(".code-product").textContent,
+    };
+
+    try {
+      const response = await fetch(URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-CSRFToken": csrfToken,
+          "X-Requested-With": "XMLHttpRequest",
+        },
+        body: JSON.stringify({ words: wordsData, product: dataProduct }),
+      });
+
+      if (!response.ok) {
+        message.textContent = "Error en la respuesta del servidor";
+        message.classList.remove("hidden");
+      }
+
+      const result = await response.json();
+      const messError = result.error;
+
+      console.log(messError);
+
+      if (messError) {
+        message.textContent = messError;
+        return;
+      }
+      containFormData.innerHTML = `
+            <section class="space-y-4">
+                <h3 class="text-xl font-bold">
+                    Exito al guardar
+                </h3>
+                <p class="text-sm italic">
+                    ${result.message}
+                </p>
+                <button type="button" class="cts-btn-general cts-btn-primary btn-push" onclick="window.location.reload();">
+                    Siguiente Producto
+                </button>
+            </section>
+      `;
+    } catch (err) {
+      console.error(err);
+      message.textContent = "Error en la respuesta del servidor";
+      message.classList.remove("hidden");
+    }
+  });
+});

tecnicas/templates/tecnicas/components/{table-convencional.html → table-scales.html}

@@ -4,7 +4,9 @@
         <table id="convencional-table" class="min-w-max w-full text-sm text-center border-collapse">
             <thead class="bg-surface-sweet text-black font-semibold">
                 <tr>
+                    {% if sesion.tecnica.tipo_tecnica.nombre_tecnica != "rata" %}
                     <th class="py-2 px-3 border border-surface-general">Repetición</th>
+                    {% endif %}
                     <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 %}
@@ -17,7 +19,9 @@
                     {% 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>
+                            {% if sesion.tecnica.tipo_tecnica.nombre_tecnica != "rata" %}
+                                <td class="py-2 px-3 border border-surface-general">{{ repeticion }}</td>
+                            {% endif %}
                             <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 %}

tecnicas/templates/tecnicas/components/table_cata.html

@@ -0,0 +1,50 @@
+{% load static %}
+<section>
+    <div class="overflow-x-auto rounded-lg border border-surface-general">
+        <table id="convencional-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 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">{{ 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">
+                        {% for valor in valores %}
+                            {% if valor.nombre_palabra == palabra %}
+                                {% if valor.dato_valor %}
+                                1
+                                {% else %}
+                                0
+                                {% endif %}
+                            {% endif %}
+                        {% endfor %}
+                    </td>
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+                {% endfor %}
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+
+    <div class="flex justify-end mt-3">
+        <button id="download-csv-btn" class="cts-btn-general cts-btn-primary btn-push"
+            data-session-name="{% if sesion and sesion.nombre_sesion %}{{ sesion.nombre_sesion }}{% else %}{% endif %}"
+            data-session-code="{% if sesion and sesion.codigo_sesion %}{{ sesion.codigo_sesion }}{% else %}{% endif %}">
+            Descargar CSV
+        </button>
+    </div>
+</section>
+<script src="{% static 'js/download-table-csv.js' %}"></script>

tecnicas/templates/tecnicas/forms_tester/cata.html

@@ -0,0 +1,119 @@
+{% 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 relative">
+        <header class="text-center flex-row max-sm:flex-col 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>
+        </article>
+
+        <p id="response-message"
+            class="text-white font-bold text-lg text-center bg-red-400 px-2 py-4 rounded-lg hidden">
+            Soy el mensaje para responder
+        </p>
+
+        <article
+            class="words-check-container bg-surface-card w-full max-w-3xl mx-auto p-6 bg-base-200 rounded-xl shadow-lg text-center">
+            <form id="wordsForm" method="POST" class="flex flex-col gap-4">
+                {% csrf_token %}
+                <div class="grid lg:grid-cols-4 md:grid-cols-3 grid-cols-2 gap-4">
+                    {% for word in words %}
+                    <label
+                        class="flex items-center justify-between bg-surface-sweet p-4 gap-2 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 }}" data-word-name="{{ word }}" />
+                    </label>
+                    {% empty %}
+                    <p class="text-center text-gray-500">No hay palabras disponibles.</p>
+                    {% endfor %}
+                </div>
+                <button type="submit" class="cts-btn-general cts-btn-primary btn-push mt-6">
+                    Enviar calificaciones
+                </button>
+            </form>
+        </article>
+
+        <section id="confirmModal"
+            class="absolute w-full h-full left-0 top-0 flex justify-center items-center bg-gray-500/70 hidden">
+            <div class="absolute max-w-xl bg-surface-card shadow-lg rounded-lg p-4">
+                <div class="space-y-4">
+                    <h3 class="font-bold text-lg mb-4">Confirma tu elección</h3>
+                    <div id="confirmModalContent" class="space-y-2 max-h-60 overflow-y-auto">
+                    </div>
+                    <div>
+                        <button id="cancelBtn" class="cts-btn-general-compress cts-btn-secondary btn-push py-1 px-4">
+                            Cancelar
+                        </button>
+                        <button id="confirmBtn" class="cts-btn-general-compress cts-btn-primary btn-push py-1 px-4">
+                            Confirmar
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/actions-form.js' %}"></script>
+<script src="{% static 'js/test-cata.js' %}"></script>
+{% endblock %}

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

@@ -218,7 +218,7 @@
                 </p>
             </section>
             {% if existen_calificaciones %}
-                {% include "../components/table-convencional.html" with calificaciones=calificaciones palabras=palabras sesion=sesion %}
+                {% include "../components/table_cata.html" with calificaciones=calificaciones palabras=palabras sesion=sesion %}
             {% else %}
                 {% include "../components/error-message.html" with message='Sin calificaciones que mostrar aún' %}
             {% endif %}

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

@@ -260,7 +260,7 @@
                     Máximo valor por dato: <span class="font-bold">{{ scale.size }}</span>
                 </p>
             </section>
-            {% include "../components/table-convencional.html" with calificaciones=calificaciones palabras=palabras sesion=sesion %}
+            {% include "../components/table-scales.html" with calificaciones=calificaciones palabras=palabras sesion=sesion %}
         </article>
         {% else %}
         {% include "../components/error-message.html" with message='Sin calificaciones que mostrar aún' %}

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",
@@ -124,7 +128,11 @@ urlpatterns = [
          views.wordsVocabulary,
          name="api_palabras_vocabulary"),
 
-    path("testers/api/ratingword",
-         views.reatingWord,
-         name="api_rating_word"),
+    path("testers/api/ratingword/escalas",
+         views.ratingWordScales,
+         name="api_rating_word_scalas"),
+
+    path("testers/api/ratingword/cata",
+         views.ratingWordCata,
+         name="api_rating_word_cata"),
 ]

tecnicas/views/__init__.py

@@ -25,10 +25,12 @@ from .vocabulary_management.list_vocabulary import listVocabulary
 from .apis.api_tag import newTag
 from .apis.api_words import words
 from .apis.api_words import wordsVocabulary
-from .apis.rating_word import reatingWord
+from .apis.rating_word_scales import ratingWordScales
+from .apis.rating_word_cata import ratingWordCata
 
 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/apis/rating_word_cata.py

@@ -0,0 +1,23 @@
+from django.http import HttpRequest, JsonResponse
+from tecnicas.utils import general_error
+from tecnicas.controllers import RatingCataController
+import json
+
+
+def ratingWordCata(req:  HttpRequest):
+    if req.method == "POST":
+        try:
+            data = json.loads(req.body.decode("utf-8"))
+            raw_words = data.get("words", [])
+            raw_product = data.get("product", [])
+
+            response = RatingCataController.saveRatingWords(
+                request=req, data_words=raw_words, data_prodct=raw_product)
+            return response
+            return JsonResponse({"message": "Error procesando datos"})
+        except Exception as e:
+            print("Error:", e)
+            return JsonResponse({"error": "Error procesando datos"}, status=400)
+
+    else:
+        return JsonResponse({"error": "Método no permitido"}, status=405)

tecnicas/views/apis/{rating_word.py → rating_word_scales.py}

@@ -28,12 +28,12 @@
  * Calquier otro metodo que se maneje mandar un error
 '''
 from django.http import HttpRequest, JsonResponse
-from tecnicas.controllers import ApiRatingController, CalificacionController, DatoController
+from tecnicas.controllers import RatingScalesController, CalificacionController, DatoController
 from tecnicas.utils import general_error
 import json
 
 
-def reatingWord(req:  HttpRequest):
+def ratingWordScales(req:  HttpRequest):
     if req.method == "POST":
         if not req.POST["rating-word"] or not req.POST["id-word"] or not req.POST["id-product"]:
             return JsonResponse({"error": "No se mandó información necesaria para la calificación"})
@@ -43,7 +43,7 @@ def reatingWord(req:  HttpRequest):
         received_id_product = json.loads(req.POST.get("id-product"))
         id_technique = json.loads(req.POST.get("id-technique"))
 
-        view_controller = ApiRatingController(
+        view_controller = RatingScalesController(
             rating_controller=CalificacionController(
                 technique=id_technique,
                 product=received_id_product,
@@ -60,4 +60,4 @@ def reatingWord(req:  HttpRequest):
 
         return JsonResponse(response_data)
     else:
-        return general_error("No puede usar este método aquí")
+        return general_error("No puede usar este método aquí")

tecnicas/views/sessions_management/session_details.py

@@ -35,8 +35,8 @@ 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)

tecnicas/views/sessions_management/session_monitor.py

@@ -47,7 +47,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":
+        elif use_techinique == "rata" or use_techinique == "cata":
             controll_view = MonitorRATAController(sensorial_session)
             action = req.POST["action"]
 

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',

tecnicas/views/tester_forms/init_tester_form.py

@@ -28,8 +28,9 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
 
         return response
     elif req.method == "POST":
-        if type_technique == "escalas" or type_technique == "rata":
+        if type_technique == "escalas" or type_technique == "rata" or type_technique == "cata":
             response = view_controller.controllPostEscalas(request=req)
+
         else:
             context = {
                 "session": session,