Merge pull request #36 from CascoArcilla/HU10

tecnicas/admin.py

@@ -14,7 +14,7 @@ from .models import Producto, Participacion
 
 from .models import Orden, Posicion
 
-from .models import Dato, ValorDecimal, ValorBooleano, Calificacion
+from .models import Dato, ValorDecimal, ValorBooleano, Calificacion, ListaPalabras
 
 # Register your models here.
 admin.site.register(CategoriaTecnica)
@@ -46,3 +46,4 @@ admin.site.register(Dato)
 admin.site.register(ValorDecimal)
 admin.site.register(ValorBooleano)
 admin.site.register(Calificacion)
+admin.site.register(ListaPalabras)

tecnicas/controllers/__init__.py

@@ -23,20 +23,28 @@ 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
 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.sessions_tester.tests_forms.test_scales_controller import TestScalesController
+from .views_controller.sessions_tester.tests_forms.test_rata_controller import TestRataController
+from .views_controller.sessions_tester.tests_forms.test_cata_controller import TestCataController
+from .views_controller.sessions_tester.tests_forms.test_pf_controller import TestPFController
+
+from .views_controller.sessions_tester.init_session.init_session_escalas_controller import InitSessionEscalasController
+from .views_controller.sessions_tester.init_session.init_session_rata_controller import InitSessionRATAController
+from .views_controller.sessions_tester.init_session.init_session_pf_controller import InitSessionPFController
 
 from .views_controller.vocabulary_manage.create_vocabulary_controller import CreateVocabularyController
 from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController
 
 from .api_controller.rating_sacales_controller import RatingScalesController
 from .api_controller.rating_cata_controller import RatingCataController
+from .api_controller.rating_pf_list_controller import RatingPFListController
 from .views_controller.tester_list_controller import TesterListController

tecnicas/controllers/api_controller/rating_pf_list_controller.py

@@ -0,0 +1,143 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction, IntegrityError
+from tecnicas.models import Palabra, ListaPalabras, Participacion
+from tecnicas.forms import ListWordsForm
+
+
+class RatingPFListController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def getListWords(request: HttpRequest):
+        participation_current_tester = Participacion.objects.get(
+            id=request.session["id_participation"])
+
+        technique = participation_current_tester.tecnica
+
+        participations_testers = Participacion.objects.exclude(
+            catador=participation_current_tester.catador).filter(tecnica=technique)
+
+        all_testers = [
+            participation.catador for participation in participations_testers]
+
+        list_words_testers = list(ListaPalabras.objects.filter(
+            tecnica=technique, catador__in=all_testers, es_final=True))
+
+        if not list_words_testers:
+            return JsonResponse({"error": "Aun no hay listas finales de Catadores"})
+
+        result = []
+        for list_tester in list_words_testers:
+            try:
+                username = list_tester.catador.user.username
+            except Exception:
+                username = None
+
+            finish = [
+                participation.finalizado for participation in participations_testers if participation.catador.user.username == username][0]
+
+            status = "Lista terminada" if finish else "Lista en proceso"
+
+            words_qs = list_tester.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words,
+                'status': status
+            })
+
+        return JsonResponse({
+            "message": "Listas encontradas",
+            "lists_words": result
+        })
+
+    @staticmethod
+    def saveList(request: HttpRequest, words: list, current_phase: int):
+        dic_words = {}
+        for index, word in enumerate(words, start=1):
+            dic_words[f"palabra_{index}"] = word
+
+        form = ListWordsForm(dic_words, new_words=words)
+
+        if form.is_valid():
+            participation = Participacion.objects.get(
+                id=request.session["id_participation"])
+
+            if not participation:
+                return JsonResponse({"error": "No está autorizado en la sesión"})
+
+            technique = participation.tecnica
+
+            list_words_tester: ListaPalabras
+            if current_phase == 1:
+                (list_words_tester, created) = ListaPalabras.objects.get_or_create(
+                    tecnica=technique,
+                    catador=request.user.user_catador,
+                    es_final=False,
+                )
+            elif current_phase == 2:
+                (list_words_tester, created) = ListaPalabras.objects.get_or_create(
+                    tecnica=technique,
+                    catador=request.user.user_catador,
+                    es_final=True,
+                )
+
+            added_words = RatingPFListController.addWordsToListWordsTester(
+                list_words=words, list_tester=list_words_tester)
+
+            response = JsonResponse({
+                "message": "Palabras guardadas con exito",
+                "words": [word.nombre_palabra for word in added_words]
+            })
+        else:
+            response = JsonResponse({"error": "Palabras invalidas"})
+
+        return response
+
+    @staticmethod
+    def addWordsToListWordsTester(list_words: list[str], list_tester: ListaPalabras):
+        # Normalizar
+        clean_words = [s.strip() for s in list_words if s.strip()]
+
+        # Obtener existentes
+        all_words = Palabra.objects.filter(nombre_palabra__in=clean_words)
+
+        names_words_exist = set(
+            all_words.values_list('nombre_palabra', flat=True))
+
+        # Ejecutar el query para no sumar palabras repetidas
+        all_words = list(all_words)
+
+        # Determinar faltantes
+        missing_words = [
+            nombre for nombre in clean_words if nombre not in names_words_exist]
+        print("No save words", missing_words)
+
+        created_words = []
+
+        # Intentar crear missing_words
+        for nombre in missing_words:
+            try:
+                with transaction.atomic():
+                    palabra, created = Palabra.objects.get_or_create(
+                        nombre_palabra=nombre)
+                    if created:
+                        created_words.append(palabra)
+            except IntegrityError:
+                palabra = Palabra.objects.get(nombre_palabra=nombre)
+                created_words.append(palabra)
+
+        # Combinar todas (all_words + created_words)
+        all_new_words = all_words + created_words
+
+        list_tester.palabras.set(all_new_words)
+
+        return all_new_words

tecnicas/controllers/models_controller/dato_controller.py

@@ -1,5 +1,5 @@
-from ...models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano, Tecnica
-from ...utils import controller_error, getId
+from tecnicas.models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano, Tecnica, Catador
+from tecnicas.utils import controller_error, getId
 from django.core.exceptions import ValidationError
 from django.db.models import F
 
@@ -12,11 +12,7 @@ class DatoController():
         }
 
         self.data = Dato(**atributes)
-
-        if isinstance(value_rating, bool):
-            self.value_data = ValorBooleano(valor=value_rating)
-        else:
-            self.value_data = ValorDecimal(valor=value_rating)
+        self.value_rating = value_rating
 
     def setRating(self, new_rating: Calificacion):
         try:
@@ -39,15 +35,27 @@ class DatoController():
         except ValidationError as e:
             return controller_error(e.message)
 
-    def setValue(self, new_value=None):
-        if new_value:
-            if isinstance(new_value, bool):
-                self.value_data = ValorBooleano(valor=new_value)
-            else:
-                self.value_data = ValorDecimal(valor=new_value)
+    def setValue(self):
+        if isinstance(self.value_rating, bool):
+            self.value_data = ValorBooleano(valor=self.value_rating)
+
         else:
-            self.value_data.id_dato = self.data
+            type_scale = self.data.id_calificacion.id_tecnica.escala_tecnica.id_tipo_escala.nombre_escala
+            
+
+            if type_scale == "continua":
+                decimal_value = self.value_rating/100
+                value_rounded = round(decimal_value)
+                self.value_data = ValorDecimal(valor=value_rounded)
+                
+                print(self.value_rating)
+                print(decimal_value)
+                print(value_rounded)
+
+            else:
+                self.value_data = ValorDecimal(valor=self.value_rating)
 
+        self.value_data.id_dato = self.data
         return self.value_data
 
     def saveValue(self):
@@ -94,3 +102,21 @@ class DatoController():
         )
 
         return list(result)
+
+    @staticmethod
+    def getWordValuesPF(technique: Tecnica, ratings: list[Calificacion], tester: Catador):
+        ids_ratings = [rat.id for rat in ratings]
+
+        result = (
+            ValorDecimal.objects
+            .filter(id_dato__id_calificacion_id__in=ids_ratings, id_dato__id_calificacion__id_catador=tester)
+            .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"),
+                dato_valor=F("valor")
+            )
+        )
+
+        return list(result)

tecnicas/controllers/views_controller/session_management/details_pf_controller.py

@@ -1,5 +1,11 @@
-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, ListaPalabras, Calificacion, Catador
+from tecnicas.controllers import ParticipacionController, DatoController
+from tecnicas.utils import defaultdict_to_dict
 from .details_controller import DetallesController
+from collections import defaultdict
 
 
 class DetallesPFController(DetallesController):
@@ -23,11 +29,158 @@ class DetallesPFController(DetallesController):
         # Definir el estado de la sesion
         rep = technique.repeticion
         activate = self.session.activo
-
         self.context["estado"] = self.getStatus(rep, activate)
 
+        self.getDataPhases()
+
         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 getDataPhases(self):
+        curren_repetition = self.session.tecnica.repeticion
+
+        if curren_repetition == 1:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+        elif curren_repetition == 2:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+            self.context["second_phase"] = self.getDataSecondPhase()
+        elif curren_repetition >= 3:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+            self.context["second_phase"] = self.getDataSecondPhase()
+            self.context["data_ratings"] = self.getDataRatings()
+
+        return self.context
+
+    def getDataFirstPhase(self):
+        lists_testers = ListaPalabras.objects.filter(
+            tecnica=self.session.tecnica,
+            es_final=False
+        )
+
+        result = []
+        for list in lists_testers:
+            try:
+                username = list.catador.user.username
+            except Exception:
+                username = None
+
+            words_qs = list.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words
+            })
+
+        return result
+
+    def getDataSecondPhase(self):
+        lists_testers = ListaPalabras.objects.filter(
+            tecnica=self.session.tecnica,
+            es_final=True
+        )
+
+        result = []
+        for list in lists_testers:
+            try:
+                username = list.catador.user.username
+            except Exception:
+                username = None
+
+            words_qs = list.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words
+            })
+
+        return result
+
+    def getDataRatings(self):
+        lists_words_testers = self.context["second_phase"]
+        technique = self.session.tecnica
+
+        ratings_for_tester = []
+
+        for list_tester in lists_words_testers:
+            tester_username = list_tester["username"]
+            # Se recuperan las calificaciones
+            ratings_for_repetition = []
+
+            ratings = list(Calificacion.objects.filter(
+                id_tecnica=technique, id_catador__user__username=tester_username))
+
+            if not ratings:
+                continue
+
+            data = DatoController.getWordValuesPF(
+                ratings=ratings, technique=technique, tester=Catador.objects.get(user__username=tester_username))
+
+            ratings_for_repetition = defaultdict(lambda: defaultdict(list))
+
+            for item in data:
+                rep = item["repeticion"]
+                prod = item["producto_code"]
+
+                ratings_for_repetition[rep-2][prod].append({
+                    "nombre_palabra": item["nombre_palabra"],
+                    "dato_valor": item["dato_valor"]
+                })
+
+            ratings_for_tester.append(
+                {
+                    "tester": tester_username,
+                    "ratings": defaultdict_to_dict(
+                        ratings_for_repetition),
+                    "words": list_tester["words"]
+                }
+            )
+            self.context["existen_calificaciones"] = True
+
+        return ratings_for_tester
+
     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 unfinished_participations:
+            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/controllers/views_controller/sessions_tester/{init_session_tester_controller.py → init_session/init_session_controller.py}

@@ -1,103 +1,23 @@
-from django.db import transaction
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario, Dato
-from tecnicas.controllers import ParticipacionController
+from django.db import transaction
+from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, EsVocabulario, Dato, ListaPalabras
 from tecnicas.utils import controller_error, shuffleArray
 
 
-class InitSessionTesterController():
+class InitSessionController():
     tester: Catador
     session: SesionSensorial
     order: Orden | dict
+    current_direction: str
     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
         self.session = sensorial_session
 
-    def controllGetEscalas(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        order = self.checkAndAssignOrder()
-        if isinstance(order, dict):
-            context["error"] = order["error"]
-            return render(request, self.current_direction, context)
-
-        is_end = self.isEndedSessionEscalas()
-
-        request.session["id_order"] = order.id
-        context["has_ended"] = is_end
-
-        if is_end:
-            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-
-        if "error" in request.GET:
-            context["error"] = request.GET["error"]
-
-        return render(request, self.current_direction, context)
-
-    def controllPostEscalas(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        if request.POST["action"] == "start_posting":
-            parameters = {
-                "code_sesion": self.session.codigo_sesion
-            }
-
-            is_end = self.isEndedSessionEscalas()
-            if is_end:
-                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-                return render(request, self.current_direction, context)
-
-            update_participation = ParticipacionController.enterSession(
-                tester=request.user.user_catador, session=self.session)
-            if isinstance(update_participation, dict):
-                context["error"] = update_participation["error"]
-                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)
-
-    def controllGetRATA(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        is_end = self.isEndedSessionEscalas()
-
-        context["has_ended"] = is_end
-
-        if is_end:
-            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-
-        return render(request, self.current_direction, context)
-
     def assignOrder(self):
         with transaction.atomic():
             orders_without_tester = list(Orden.objects.select_for_update().filter(
@@ -124,7 +44,7 @@ class InitSessionTesterController():
                 return create
         return self.order_to_assign
 
-    def isEndedSessionEscalas(self):
+    def isEndedSession(self):
         try:
             participation = Participacion.objects.get(
                 catador=self.tester, tecnica=self.session.tecnica)

tecnicas/controllers/views_controller/sessions_tester/init_session/init_session_escalas_controller.py

@@ -0,0 +1,82 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Catador, SesionSensorial, Orden
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionEscalasController(InitSessionController):
+    tester: Catador
+    session: SesionSensorial
+    order: Orden | dict
+
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_session.html"
+        self.escalas_direction = "cata_system:session_convencional"
+        self.cata_direction = "cata_system:session_cata"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        order = self.checkAndAssignOrder()
+        if isinstance(order, dict):
+            context["error"] = order["error"]
+            return render(request, self.current_direction, context)
+
+        is_end = self.isEndedSession()
+
+        request.session["id_order"] = order.id
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, context)
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        if request.POST["action"] == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            is_end = self.isEndedSession()
+            if is_end:
+                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+                return render(request, self.current_direction, context)
+
+            update_participation = ParticipacionController.enterSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                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_direction, 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/init_session/init_session_pf_controller.py

@@ -0,0 +1,144 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Participacion, Producto, Dato, ListaPalabras
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionPFController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_session_pf.html"
+        self.pf_direction = "cata_system:session_pf"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        (is_end, message, rep_show) = self.isEndedSession()
+
+        context["has_ended"] = is_end
+        context["activity"] = message
+        context["repetition"] = rep_show
+
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, context)
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        action = request.POST["action"]
+
+        if action == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            (is_end, message, rep_show) = self.isEndedSession()
+            if is_end:
+                return self.controllGet(request)
+
+            update_participation = ParticipacionController.enterSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                return render(request, self.current_direction, context)
+
+            request.session["id_participation"] = update_participation.id
+
+            return redirect(reverse(self.pf_direction, kwargs=parameters))
+
+        elif action == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return self.controllGet(request)
+
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)
+
+    def isEndedSession(self) -> tuple[bool, str, int]:
+        rep = self.session.tecnica.repeticion
+
+        is_end = False
+        message = ""
+        repetitiom_show = 0
+
+        if rep == 1:
+            is_end = self.endedSessionMakeList()
+            message = "Ya has creado la Lista de palabras inicial" if is_end else "Debes crear tu lista de palabras inicial"
+            repetitiom_show = 0
+        elif rep == 2:
+            is_end = self.endedSessionMakeList()
+            message = "Ya has creado la Lista de palabras final" if is_end else "Debes crear tu lista de palabras final"
+            repetitiom_show = 0
+        elif rep >= 3:
+            is_end = self.endedSessionRepetition()
+            message = "Has finalizado con el proceso de calificación" if is_end else "Debe hacer tu proceso de calificación"
+            repetitiom_show = rep - 2
+        else:
+            message = "Parece que la repetición es cero, no es posible hacer algo ahora mismo"
+
+        return (is_end, message, repetitiom_show)
+
+    def endedSessionMakeList(self):
+        try:
+            return Participacion.objects.get(
+                catador=self.tester, tecnica=self.session.tecnica).finalizado
+        except Participacion.DoesNotExist:
+            print("No se ha encontrado la participación")
+            return False
+
+    def endedSessionRepetition(self):
+        try:
+            participation = Participacion.objects.get(
+                catador=self.tester, tecnica=self.session.tecnica)
+            self.session.refresh_from_db()
+
+            # ////////////////////////////////////////////////////////////// #
+            #
+            # numero_datos_esperadas = num_productos * num_palabras
+            # Si numero_datos_esperadas es igual a numero_datos_actuales en la repetcion R
+            # Ha terminado la repeticion
+            #
+            # ////////////////////////////////////////////////////////////// #
+
+            if participation.finalizado:
+                num_products = Producto.objects.filter(
+                    id_tecnica=self.session.tecnica).count()
+
+                num_words = ListaPalabras.objects.get(
+                    tecnica=self.session.tecnica,
+                    catador=self.tester,
+                    es_final=True
+                ).palabras.all().count()
+
+                expected_ratings_repetition = num_products * num_words
+
+                technique = self.session.tecnica
+                num_ratings_now = Dato.objects.filter(
+                    id_calificacion__id_catador=self.tester,
+                    id_calificacion__id_tecnica=technique,
+                    id_calificacion__num_repeticion=technique.repeticion
+                ).count()
+
+                is_end = num_ratings_now >= expected_ratings_repetition
+
+                return is_end
+
+            else:
+                return participation.finalizado
+
+        except Participacion.DoesNotExist:
+            print("No se ha encontrado la participación")
+            return False

tecnicas/controllers/views_controller/sessions_tester/init_session/init_session_rata_controller.py

@@ -0,0 +1,24 @@
+from django.http import HttpRequest
+from django.shortcuts import render
+from .init_session_controller import InitSessionController
+
+
+class InitSessionRATAController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_session.html"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        is_end = self.isEndedSession()
+
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        return render(request, self.current_direction, context)

tecnicas/controllers/views_controller/sessions_tester/login_session_tester_controller.py

@@ -1,4 +1,4 @@
-from django.http import HttpRequest, JsonResponse
+from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from django.db import transaction
@@ -97,3 +97,6 @@ class LoginSessionTesterController():
         else:
             context["error"] = "Imposible acceder a esta sesión"
             return render(request, self.current_direcction, context)
+
+    def validateEntryPF(self, request=HttpRequest):
+        return self.validateEntryEscalas(request=request)

tecnicas/controllers/views_controller/sessions_tester/tests_forms/test_pf_controller.py

@@ -0,0 +1,188 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Producto, Participacion, Palabra, Calificacion, ListaPalabras
+from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
+from tecnicas.forms import ListWordsForm
+from .general_test_controller import GenetalTestController
+
+
+class TestPFController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+
+    def controllGet(self, request: HttpRequest, error=""):
+        self.participation = Participacion.objects.get(
+            tecnica=self.session.tecnica, catador=request.user.user_catador)
+        self.context["session"] = self.session
+
+        if error:
+            self.context["error"] = error
+
+        rep = self.session.tecnica.repeticion
+
+        if rep == 1:
+            self.current_directory = "tecnicas/forms_tester/test_pf_list_words.html"
+            response = self.getFirstPhase(request)
+        elif rep == 2:
+            self.current_directory = "tecnicas/forms_tester/test_pf_list_words.html"
+            response = self.getSecondPhase(request)
+        elif rep >= 3:
+            self.current_directory = "tecnicas/forms_tester/test_pf_rating_list.html"
+            response = self.getRepetitionPhase(request)
+        else:
+            response = self.getErrorRepetition(request)
+
+        return response
+
+    def controllPost(self, request: HttpRequest):
+        action = request.POST["action"]
+
+        if action == "finish_session":
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        else:
+            return self.controllGet(request, error="Acción no permitida")
+
+    def getFirstPhase(self, request: HttpRequest):
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["form"] = ListWordsForm()
+        self.context["initial_phase"] = True
+
+        try:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=False
+            )
+            list_words = list(tester_list.palabras.all())
+            self.context["words"] = list_words
+        except ListaPalabras.DoesNotExist:
+            self.context["words"] = []
+
+        return render(request, self.current_directory, self.context)
+
+    def getSecondPhase(self, request: HttpRequest):
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        try:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=True
+            )
+        except ListaPalabras.DoesNotExist:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=False
+            )
+
+        list_words = list(tester_list.palabras.all())
+
+        self.context["form"] = ListWordsForm()
+        self.context["initial_phase"] = False
+        self.context["words"] = list_words
+
+        return render(request, self.current_directory, self.context)
+
+    def getRepetitionPhase(self, request: HttpRequest):
+        technique = self.session.tecnica
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        words = list(
+            ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=True
+            ).palabras.all()
+        )
+
+        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))
+
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+
+        self.context["product"] = use_product
+        self.context["words"] = use_words
+        
+        self.context["scale"] = scale
+        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+        self.context["tags"] = use_tags
+
+        self.context["repetition"] = technique.repeticion - 2
+
+        if self.context["type_scale"] == "continua":
+            self.context["size_scale"] = {
+                "max_size": scale.longitud * 100,
+                "middle_size": (scale.longitud * 100)/2
+            }
+
+        return render(request, self.current_directory, self.context)
+
+    def getErrorRepetition(self, request: HttpRequest):
+        params = {
+            "code_sesion": self.session.codigo_sesion
+        }
+        return redirect(reverse(self.previus_directory, kwargs=params))

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

@@ -78,5 +78,10 @@ class TestScalesController(GenetalTestController):
         ctx["scale"] = scale
         ctx["type_scale"] = scale.id_tipo_escala.nombre_escala
         ctx["tags"] = EscalaController.getRelatedTagsInScale(scale=scale)
+        if ctx["type_scale"] == "continua":
+            ctx["size_scale"] = {
+                "max_size": scale.longitud * 100,
+                "middle_size": (scale.longitud * 100)/2
+            }
 
-        return render(request, self.current_directory, ctx)
+        return render(request, self.current_directory, ctx)

tecnicas/forms/__init__.py

@@ -8,3 +8,5 @@ from .codes_form import CodesForm
 from .catador_form import CatadorForm
 from .word_form import WordForm
 from .vocabulary_select import VocabularioSelectForm
+
+from .list_words_form import ListWordsForm

tecnicas/forms/list_words_form.py

@@ -0,0 +1,49 @@
+from django import forms
+import re
+
+
+class ListWordsForm(forms.Form):
+    regex = re.compile(r'^[a-zñ]{3,}$')
+
+    def __init__(self, *args, new_words=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if not new_words:
+            self.fields['nombre_palabra'] = forms.CharField(
+                label='Nombre de la palabra',
+                max_length=255,
+                widget=forms.TextInput(attrs={
+                    'placeholder': 'Escribe una palabra',
+                    'class': 'cts-input-list-word bg-surface-ligt p-1 border-b-1 text-center w-full',
+                    'pattern': self.regex.pattern,
+                    'title': 'Solo letras minúsculas y la letra ñ, no poner acentos. No se permiten mayúsculas ni caracteres especiales. Mínimo 3 letras',
+                })
+            )
+        else:
+            for index, name in enumerate(new_words, start=1):
+                self.fields[f'palabra_{index}'] = forms.CharField(
+                    label=f'Palabra {index}',
+                    max_length=255,
+                    initial=name,
+                    widget=forms.TextInput(attrs={
+                        'placeholder': 'Escribe una palabra',
+                        'class': 'cts-input-list-word bg-surface-ligt p-1 border-b-1 text-center w-full',
+                        'pattern': self.regex.pattern,
+                        'title': 'Solo letras minúsculas y la letra ñ. No se permiten mayúsculas ni caracteres especiales.'
+                    })
+                )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        errores = []
+
+        for field_name, value in cleaned_data.items():
+            if not self.regex.match(value):
+                errores.append(f"'{value}' contiene caracteres no permitidos.")
+            elif len(value) > 255:
+                errores.append(f"'{value}' excede los 255 caracteres.")
+
+        if errores:
+            raise forms.ValidationError(errores)
+
+        return cleaned_data

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.sesion_tecnica.codigo_sesion} - {self.catador.user.username}"

tecnicas/static/js/download-table-zip.js

@@ -0,0 +1,74 @@
+document.addEventListener("DOMContentLoaded", function () {
+  const btn = document.getElementById("download-csv-btn");
+  if (!btn) return;
+
+  btn.addEventListener("click", async function () {
+    if (typeof JSZip === "undefined" || typeof saveAs === "undefined") {
+      alert(
+        "Librerías JSZip o FileSaver no están cargadas. Asegúrate de incluir los CDN de JSZip y FileSaver."
+      );
+      return;
+    }
+
+    const sections = document.querySelectorAll("section[data-tester]");
+    if (!sections || sections.length === 0) {
+      alert("No hay tablas para descargar.");
+      return;
+    }
+
+    const zip = new JSZip();
+
+    let zipName = "";
+
+    sections.forEach((sec) => {
+      const tester = sec.getAttribute("data-tester") || "tester";
+      const sessionName = sec.getAttribute("data-session-name") || "";
+      const sessionCode = sec.getAttribute("data-session-code") || "";
+
+      const fileName = `${tester}_${
+        sessionName ? sessionName.trim() : sessionCode.trim()
+      }`;
+
+      zipName = `datos_sesion_${
+        sessionName ? sessionName.trim() : sessionCode.trim()
+      }`;
+
+      const table = sec.querySelector("table");
+      if (!table) return;
+
+      // Build CSV
+      const rows = [];
+      const headerCells = Array.from(table.querySelectorAll("thead tr th"));
+      const headers = headerCells.map((h) => h.textContent.trim());
+      rows.push(headers.map(escapeCsv).join(","));
+
+      const trs = table.querySelectorAll("tbody tr");
+      trs.forEach((tr) => {
+        const tds = Array.from(tr.querySelectorAll("td"));
+        const values = tds.map((td) => escapeCsv(td.textContent.trim()));
+        rows.push(values.join(","));
+      });
+
+      const csvContent = rows.join("\r\n");
+      zip.file(`${fileName}.csv`, csvContent);
+    });
+
+    try {
+      const blob = await zip.generateAsync({ type: "blob" });
+      const zipNameWithExtension = zipName + ".zip";
+      saveAs(blob, zipNameWithExtension);
+    } catch (err) {
+      console.error(err);
+      alert("Error al generar el ZIP: " + err.message);
+    }
+  });
+
+  const escapeCsv = (val) => {
+    if (val == null) return "";
+    let normalVal = val.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    const needsQuotes = /[",\n,]/.test(normalVal);
+    let v = String(normalVal).replace(/"/g, '""');
+    if (needsQuotes) v = `"${v}"`;
+    return v;
+  };
+});

tecnicas/static/js/lists-words-testers.js

@@ -0,0 +1,103 @@
+async function getListWordsTesters() {
+  const URL = "/cata/testers/api/ratingword/pf/list";
+  try {
+    const response = await fetch(URL, {
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      spanNotifaction("Fallo con la respuesta recibida");
+      return false;
+    }
+
+    const result = await response.json();
+    const messError = result.error;
+    if (messError) {
+      spanNotifaction(messError);
+      const containerWords = document.querySelector(".cts-content-list-words");
+      containerWords.innerHTML = `
+            <p class="bg-surface-sweet font-bold text-center text-lg px-4 pt-2 pb-3 rounded w-full max-sm:mx-2">
+                ${messError}
+            </p>`;
+      return false;
+    }
+    spanNotifaction(result.message, false);
+    const containerWords = document.querySelector(".cts-content-list-words");
+    containerWords.innerHTML = "";
+
+    const listWordsTesters = result.lists_words;
+
+    listWordsTesters.forEach((listTester) => {
+      const username = listTester.username;
+      const words = listTester.words;
+      const status = listTester.status;
+      const listDiv = createListWords(username, words, status);
+      containerWords.appendChild(listDiv);
+    });
+
+    return true;
+  } catch (error) {
+    console.error(error);
+    spanNotifaction("Error del servidor con la API");
+    return false;
+  }
+}
+
+function createListWords(username, words, status = "indefinido") {
+  const div = document.createElement("div");
+  const paragraph = document.createElement("p");
+  const paragraphStatus = document.createElement("p");
+  const ul = document.createElement("ul");
+
+  div.classList.add(
+    "cts-item-list-tester",
+    "bg-surface-sweet",
+    "px-4",
+    "pt-2",
+    "pb-3",
+    "rounded",
+    "shrink-0",
+    "w-64",
+    "space-y-2"
+  );
+
+  paragraph.classList.add(
+    "bg-surface-card",
+    "text-lg",
+    "font-semibold",
+    "text-center",
+    "rounded"
+  );
+
+  paragraphStatus.classList.add(
+    "bg-surface-card",
+    "text-lg",
+    "font-semibold",
+    "text-center",
+    "rounded"
+  );
+
+  paragraph.textContent = username;
+  paragraphStatus.textContent = status;
+
+  ul.classList.add("text-center", "grid", "grid-cols-2", "gap-2", "w-full");
+
+  words.forEach((word) => {
+    const li = document.createElement("li");
+    li.classList.add(
+      "bg-surface-ligt",
+      "rounded",
+      "font-bold",
+      "py-1",
+      "px-2",
+      "truncate"
+    );
+    li.textContent = word.nombre_palabra;
+    ul.appendChild(li);
+  });
+
+  div.appendChild(paragraph);
+  div.appendChild(paragraphStatus);
+  div.appendChild(ul);
+  return div;
+}

tecnicas/static/js/pf-make-list.js

@@ -0,0 +1,227 @@
+const FORM_DESCRIBE = document.querySelector(".cts-form-pf-word");
+const BOX_WORDS = document.querySelector(".cts-box-words");
+const IMG_LIST = document.querySelector(".cts-img-list");
+const ERROR_INPUT_WORD = document.querySelector(".error-input-word");
+const FORM_ACTION = document.querySelector(".form-actions");
+
+const WORDS = [];
+const STYLES_LI = [
+  "cts-item-words",
+  "bg-gray-400",
+  "text-black",
+  "rounded",
+  "font-bold",
+  "text-lg",
+  "px-4",
+  "py-3",
+  "flex",
+  "flex-wrap",
+  "flex-row",
+  "flex-1",
+  "min-w-fit",
+  "justify-center",
+  "items-center",
+  "gap-3",
+];
+
+const STYLES_BTN = [
+  "cts-remove-word",
+  "px-4",
+  "border-b-2",
+  "active:border-b-0",
+  "active:border-t-2",
+  "transition-all",
+  "rounded-xl",
+  "font-black",
+  "w-fit",
+  "capitalize",
+  "active:border-red-500",
+  "border-red-800",
+  "bg-red-500",
+];
+
+const itemWord = (wordName, index) => {
+  const btn = document.createElement("button");
+  btn.setAttribute("data-index", index);
+  btn.classList.add(...STYLES_BTN);
+  btn.textContent = "➖";
+
+  const ph = document.createElement("p");
+  ph.classList.add("ct-word-received");
+  ph.textContent = wordName;
+
+  const li = document.createElement("li");
+  li.setAttribute("id", `word-${index}`);
+  li.classList.add(...STYLES_LI);
+
+  li.appendChild(ph);
+  li.appendChild(btn);
+
+  return li;
+};
+
+function initWordsFromBox() {
+  if (!BOX_WORDS) return;
+  const current_words = BOX_WORDS.querySelectorAll(".cts-item-words");
+  if (!current_words.length) return;
+
+  WORDS.length = 0;
+  current_words.forEach((li) => {
+    const p = li.querySelector(".ct-word-received");
+    const text = p ? p.textContent.trim() : li.textContent.trim();
+    if (text) WORDS.push(text);
+  });
+  renderWords();
+}
+
+function renderWords() {
+  if (!BOX_WORDS) return;
+  if (!WORDS.length) {
+    BOX_WORDS.innerHTML = "";
+    IMG_LIST.classList.remove("hidden");
+    BOX_WORDS.appendChild(IMG_LIST);
+    return;
+  }
+
+  BOX_WORDS.innerHTML = "";
+  WORDS.forEach((word, index) => {
+    let liElement = itemWord(word, index);
+    BOX_WORDS.appendChild(liElement);
+  });
+
+  const removeButtons = BOX_WORDS.querySelectorAll("button.cts-remove-word");
+  removeButtons.forEach((btn) => {
+    btn.addEventListener("click", (e) => {
+      const idx = parseInt(btn.dataset.index);
+      if (!Number.isNaN(idx)) {
+        WORDS.splice(idx, 1);
+        renderWords();
+      }
+    });
+  });
+}
+
+function setupDescribeFormToAddWord() {
+  if (!FORM_DESCRIBE) return;
+  FORM_DESCRIBE.addEventListener("submit", (e) => {
+    e.preventDefault();
+
+    if (!FORM_DESCRIBE.reportValidity()) {
+      return;
+    }
+
+    const input = FORM_DESCRIBE.querySelector('input[type="text"]');
+    if (!input) return;
+
+    const value = input.value.trim();
+    if (!value) return;
+
+    if (WORDS.includes(value)) {
+      spanNotifaction("Esa palabra ya está en la lista");
+      return;
+    }
+
+    WORDS.push(value);
+    renderWords();
+
+    input.value = "";
+    input.focus();
+  });
+}
+
+function spanNotifaction(messageError, isError = true) {
+  const span = document.createElement("span");
+  span.textContent = messageError;
+
+  const div = document.createElement("div");
+  div.classList.add("alert", isError ? "alert-error" : "alert-success");
+  div.appendChild(span);
+
+  ERROR_INPUT_WORD.append(div);
+
+  setTimeout(() => {
+    ERROR_INPUT_WORD.removeChild(div);
+  }, 3000);
+}
+
+async function sendWordsToSave() {
+  if (!WORDS.length) {
+    spanNotifaction("Debe existir al menos una palabra en la lista");
+    return false;
+  }
+
+  const currentPhase = parseInt(
+    document.querySelector(".cts-phase-pf").dataset.phase
+  );
+
+  const csrfToken = document.querySelector("[name=csrfmiddlewaretoken]").value;
+
+  const requestData = {
+    phase: currentPhase,
+    words: WORDS,
+  };
+
+  const URL = "/cata/testers/api/ratingword/pf/list";
+
+  try {
+    const response = await fetch(URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CSRFToken": csrfToken,
+        "X-Requested-With": "XMLHttpRequest",
+      },
+      body: JSON.stringify(requestData),
+    });
+
+    if (!response.ok) {
+      spanNotifaction("Fallo con la respuesta recibida");
+      return false;
+    }
+
+    const result = await response.json();
+
+    const messError = result.error;
+
+    if (messError) {
+      spanNotifaction(messError);
+      return false;
+    }
+
+    spanNotifaction(result.message, false);
+    const addedWords = result.words;
+    WORDS.length = 0;
+    addedWords.forEach((word) => WORDS.push(word));
+    renderWords();
+    return true;
+  } catch (err) {
+    console.error(err);
+    spanNotifaction("Error en la respuesta del servidor");
+    return false;
+  }
+}
+
+async function setUpFormAction() {
+  const saveWords = await sendWordsToSave();
+  if (!saveWords) {
+    return false;
+  }
+
+  const input = FORM_ACTION.querySelector(".action-input");
+  FORM_ACTION.action = "";
+  input.value = "finish_session";
+  FORM_ACTION.submit();
+}
+
+window.addEventListener("DOMContentLoaded", async () => {
+  initWordsFromBox();
+  setupDescribeFormToAddWord();
+
+  const currentPhase = parseInt(
+    document.querySelector(".cts-phase-pf").dataset.phase
+  );
+
+  if (currentPhase == 2) await sendWordsToSave();
+  if (document.querySelector(".cts-content-list-words"))
+    await getListWordsTesters();
+});

tecnicas/static/js/test-cata.js

@@ -100,8 +100,6 @@ document.addEventListener("DOMContentLoaded", () => {
       const result = await response.json();
       const messError = result.error;
 
-      console.log(messError);
-
       if (messError) {
         message.textContent = messError;
         return;

tecnicas/templates/tecnicas/components/form-scale-continue.html

@@ -6,10 +6,11 @@
                 class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
 
             <span class="hidden id-word">{{ word.id }}</span>
-
+            
             <section class="block">
                 <div class="relative mx-6">
-                    <input type="range" type="range" min="0" max="1000" value="500" name="rating-word"
+                    <input type="range" type="range" min="0" max="{{ size_scale.max_size }}"
+                        value="{{ size_scale.middle_size }}" name="rating-word"
                         class="range range-md text-blue-400 [--range-bg:orange] [--range-thumb:blue] [--range-fill:0]"
                         style="width: {{scale.longitud}}cm;">
 

tecnicas/templates/tecnicas/components/item-list-words.html

@@ -0,0 +1,8 @@
+<div class="cts-item-list-tester bg-surface-sweet px-4 pt-2 pb-3 rounded shrink-0 w-64 space-y-2">
+    <p class="bg-surface-card text-lg font-semibold text-center rounded">{{ list_tester.username }}</p>
+    <ul class="text-center grid grid-cols-2 gap-2 w-full">
+        {% for word in list_tester.words %}
+        <li class="bg-surface-ligt rounded font-bold py-1 px-2 truncate">{{ word.nombre_palabra }}</li>
+        {% endfor %}
+    </ul>
+</div>

tecnicas/templates/tecnicas/components/table_pf.html

@@ -0,0 +1,39 @@
+{% load static %}
+
+<section data-tester="{{ data.tester }}" {% if session_name %} data-session-name="{{ session_name }}" {% endif %}
+    data-session-code="{{ session_code }}">
+    <h3 class="text-xl font-bold">Datos de usuario {{ data.tester }}</h3>
+
+    <div class="overflow-x-auto rounded-lg border border-surface-general">
+        <table class="convencional-table 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">Repetición</th>
+                    <th class="py-2 px-3 border border-surface-general">Producto</th>
+                    {% for word in data.words %}
+                    <th class="py-2 px-3 border border-surface-general uppercase">{{ word.nombre_palabra }}</th>
+                    {% endfor %}
+                </tr>
+            </thead>
+            <tbody class="bg-surface-ligt divide-y divide-gray-200">
+                {% for repeticion, data_product in data.ratings.items %}
+                {% for codigo, valores in data_product.items %}
+                <tr>
+                    <td class="py-2 px-3 border border-surface-general">{{ repeticion }}</td>
+                    <td class="py-2 px-3 border border-surface-general">{{ codigo }}</td>
+                    {% for word in data.words %}
+                    <td class="py-2 px-3 border border-surface-general">
+                        {% for valor in valores %}
+                        {% if valor.nombre_palabra == word.nombre_palabra %}
+                        {{ valor.dato_valor }}
+                        {% endif %}
+                        {% endfor %}
+                    </td>
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</section>

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -104,7 +104,7 @@
             {% with path_con="../components/form-scale-continue.html" path_str="../components/form-scale-structure.html" %}
                 {% if type_scale == "continua" %}
                     {% for word in words %}
-                        {% include path_con with word=word tags=tags scale=scale id_tecnica=session.tecnica.id %}
+                        {% include path_con with word=word tags=tags scale=scale size_scale=size_scale %}
                     {% endfor %}
                 {% elif type_scale == "estructurada" %}
                     {% for word in words %}

tecnicas/templates/tecnicas/forms_tester/init_session_pf.html

@@ -0,0 +1,123 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Detalles Sesion{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black max-w-4xl">
+        <header class="text-center flex-row w-full flex justify-around items-center flex-wrap gap-10">
+            <h1 class="rounded-xl font-bold text-2xl bg-surface-ligt p-4 flex-1">
+                Panel principal de Catadores
+            </h1>
+        </header>
+
+        <article>
+            <p class="text-2xl font-medium text-center bg-surface-sweet p-4 rounded-lg">
+                Información sobre la sesión en la que participa
+            </p>
+        </article>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+        <hr>
+
+        <article
+            class="rounded-xl grid grid-cols-1 gap-3 text-center *:bg-surface-card *:flex *:flex-wrap *:items-center *:justify-center *:gap-x-2 *:p-4 *:rounded-2xl">
+            <section>
+                <p class="text-xl font-bold">
+                    Código:
+                </p>
+                <p class="font-sans text-xl font-normal">
+                    {{ session.codigo_sesion }}
+                </p>
+            </section>
+
+            <section>
+                <p class="text-xl font-bold">
+                    {% if session.nombre_sesion %}
+                    {{ session.nombre_sesion }}
+                    {% else %}
+                    Sin nombre
+                    {% endif %}
+                </p>
+            </section>
+
+            <section>
+                <p class="text-xl font-medium">
+                    Esta sesión usa la técnica <span class="uppercase">{{ session.tecnica.tipo_tecnica }}</span>
+                </p>
+            </section>
+
+            <section>
+                <p class="text-xl font-medium">
+                    <b>Actividad:</b> {{ activity }}
+                </p>
+            </section>
+
+            {% if repetition >= 1 %}
+            <section>
+                <p class="text-xl font-medium">
+                    Repetición de la calificación: {{ repetition }}
+                </p>
+            </section>
+            {% endif %}
+
+            <section>
+                <p class="text-xl">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+        </article>
+
+        <hr>
+
+        <article class="flex flex-wrap gap-10">
+            {% if has_ended %}
+            {% if repetition >= 1 %}
+            <div
+                class="text-2xl font-semibold flex-1 cts-btn-secondary p-4 flex justify-center items-center rounded-lg select-none">
+                <p class=" text-black">Finalizaste la repetición</p>
+            </div>
+            {% else %}
+            <div
+                class="text-2xl font-semibold flex-1 cts-btn-secondary p-4 flex justify-center items-center rounded-lg select-none">
+                <p class=" text-black">Finalizaste la actividad</p>
+            </div>
+            {% endif %}
+            {% else %}
+            <button
+                class="ct-btn-start-repition flex-1 uppercase text-lg tracking-wider cts-btn-general cts-btn-primary btn-push flex flex-col justify-center items-center gap-2"
+                onclick="startTest()">
+                Entrar en fase o repetición
+                <figure class="w-10">
+                    <img src="{% static 'img/check.svg' %}" alt="flechas girando" class="invert">
+                </figure>
+            </button>
+            {% endif %}
+            <a href="{% url 'cata_system:catador_list_sessions' num_page=1 %}">
+                <button
+                    class="flex-1 uppercase text-lg tracking-wider cts-btn-general cts-btn-error btn-push flex flex-col justify-center items-center gap-2">
+                    Regresar a la lista
+                    <figure class="w-10">
+                        <img src="{% static 'img/exit.svg' %}" alt="bote de basura" class="invert">
+                    </figure>
+                </button>
+            </a>
+        </article>
+
+        <form action="" method="post" class="hidden ct-action-form">
+            {% csrf_token %}
+            <input type="hidden" class="action-option" name="action" value="start_posting">
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/start-tester-test.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/forms_tester/test_pf_list_words.html

@@ -0,0 +1,184 @@
+{% 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 max-w-4xl">
+        <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 not initial_phase %}
+        <div role="alert" class="alert alert-info">
+            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
+                class="h-6 w-6 shrink-0 stroke-current">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+            </svg>
+            <span class="text-lg">
+                Para poder compartir tu nueva lista de palabras con los demás Catadores, debes usar el botón de
+                <b>“Guardar y comprobar palabras actuales”</b>
+            </span>
+        </div>
+        {% 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 bg-surface-ligt p-2 rounded-lg">
+                {% if initial_phase %}
+                <p class="text-xl font-bold text-center">
+                    Fase <span class="cts-phase-pf" data-phase="1">1</span>:
+                </p>
+                <p class="text-xl font-bold text-center">
+                    Lista inicial
+                </p>
+                {% else %}
+                <p class="text-xl font-bold text-center">
+                    Fase <span class="cts-phase-pf" data-phase="2">2</span>:
+                </p>
+                <p class="text-xl font-bold text-center">
+                    Lista Final
+                </p>
+                {% endif %}
+            </section>
+        </article>
+
+        <div class="error-input-word toast toast-bottom toast-center"></div>
+
+        <section class="cts-list-words space-y-4">
+            <article class="flex gap-4 flex-wrap">
+                <section class="bg-surface-card p-4 rounded-lg text-center space-y-4 sm:w-[300px] w-full flex-shrink-0">
+                    <h3 class="text-xl font-bold border-b-1">Describe el producto</h3>
+
+                    <form action="" method="get" class="cts-form-pf-word flex gap-4 flex-col">
+                        <label for="{{ form.nombre_palabra.id_for_label }}" class="text-left">
+                            <p class="text-lg font-semibold">
+                                {{ form.nombre_palabra.label }}:
+                            </p>
+                            {{ form.nombre_palabra }}
+                            <small>
+                                Solo letras minúsculas y la letra ñ, no poner acentos. No se permiten mayúsculas ni
+                                caracteres especiales. Mínimo 3 letras
+                            </small>
+                        </label>
+                        <button type="submit" class="cts-btn-general-compress cts-btn-primary btn-push w-full py-2">
+                            Agregar
+                        </button>
+                    </form>
+                </section>
+
+                <section
+                    class="bg-surface-card p-4 rounded-lg text-center flex-1 h-[400px] min-h-[400px] max-h-[600px] flex-shrink-0 overflow-y-auto">
+                    <div>
+                        <p class="text-xl font-bold pb-3">Lista de palabras</p>
+                        <hr>
+                    </div>
+
+                    <ul class="cts-box-words flex flex-col gap-3 overflow-y-auto mt-4">
+                        {% if not words %}
+                        <img src="{% static 'img/list.svg' %}" alt="lista de palabras" class="cts-img-list h-[300px]">
+                        {% endif %}
+
+                        {% for word in words %}
+                        <img src="{% static 'img/list.svg' %}" alt="lista de palabras"
+                            class="cts-img-list h-[300px] hidden">
+
+                        <li class="cts-item-words bg-gray-400 text-black rounded font-bold text-lg 
+                       px-4 py-3 flex flex-wrap flex-row min-w-fit justify-center items-center gap-3">
+                            <p class="ct-word-received">{{ word.nombre_palabra }}</p>
+
+                            <button class="px-4 border-b-2 active:border-b-0 active:border-t-2 
+                           transition-all rounded-xl font-black capitalize 
+                           active:border-red-500 border-red-800 bg-red-500">
+                                ➖
+                            </button>
+                        </li>
+                        {% endfor %}
+                    </ul>
+                </section>
+            </article>
+        </section>
+
+        <article class="flex max-sm:flex-col gap-4">
+            <button type="button" class="cts-btn-general-compress cts-btn-primary btn-push py-2 px-4 flex-1"
+                onclick="sendWordsToSave()">
+                Guardar y comprobar palabras actuales
+            </button>
+
+            <button type="button" class="cts-btn-general cts-btn-secondary btn-push py-2 px-4 flex-1"
+                onclick="setUpFormAction()">
+                Finalizar la sesión
+            </button>
+        </article>
+
+        <div role="alert" class="alert alert-warning">
+            <svg xmlns="http://www.w3.org/2000/svg" class="h-6 w-6 shrink-0 stroke-current" fill="none"
+                viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+            </svg>
+            <div class="flex-col">
+                <span class="text-lg block">
+                    Si usas el botón <b>“Salir de la sesión”</b> asegúrese de guardar las palabras de lo contrario las
+                    palabras no se guardaran pero podrás ingresar otra vez
+                </span>
+                <span class="text-lg block">
+                    Con el botón <b>“Finalizar la sesión”</b>, se guardan las palabras, sales de la sesión y no podrás
+                    ingresar otra vez
+                </span>
+            </div>
+        </div>
+
+        {% if not initial_phase %}
+        <section class="space-y-4">
+            <section class="flex items-center justify-center flex-wrap gap-4 bg-surface-ligt p-2 rounded-lg">
+                <h3 class="text-xl font-bold text-center">
+                    Listas de los demás participantes
+                </h3>
+            </section>
+            <article class="cts-content-list-words bg-surface-card flex gap-4 overflow-x-auto p-2"></article>
+            <article class="flex justify-center">
+                <button class="cts-btn-general cts-btn-primary btn-push" onclick="getListWordsTesters()">
+                    Actualizar las listas
+                </button>
+            </article>
+        </section>
+        <script src="{% static 'js/lists-words-testers.js' %}"></script>
+        {% endif %}
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/pf-make-list.js' %}"></script>
+<script src="{% static 'js/actions-form.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/forms_tester/test_pf_rating_list.html

@@ -0,0 +1,129 @@
+{% extends 'tecnicas/layouts/base.html' %}
+
+{% load static %}
+
+{% block title %}Convencional{% endblock %}
+
+{% block extra_css %}
+<style>
+    input[type="range"]::-webkit-slider-thumb {
+        -webkit-appearance: none;
+        appearance: none;
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        background: var(--color-blue-500);
+        cursor: pointer;
+    }
+
+    input[type="range"]::-moz-range-thumb {
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        background: #3b82f6;
+        cursor: pointer;
+    }
+
+    @media (width < 40rem) {
+        .container-forms {
+            width: inherit;
+        }
+    }
+</style>
+{% 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 %}
+
+        <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 bg-surface-ligt p-2 rounded-lg">
+                <p class="text-xl font-bold text-center">
+                    Fase <span class="cts-phase-pf" data-phase="3">3</span>:
+                </p>
+                <p class="text-xl font-bold text-center">
+                    Calificación de listas
+                </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">
+                        {{ repetition }}
+                    </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="scales-container [&>*:not(:last-child)]:mb-5 min-lg:grid min-lg:items-start grid-cols-2 gap-3 justify-center items-center">
+            {% with path_con="../components/form-scale-continue.html" path_str="../components/form-scale-structure.html" %}
+                {% if type_scale == "continua" %}
+                    {% for word in words %}
+                        {% include path_con with word=word tags=tags scale=scale size_scale=size_scale %}
+                    {% endfor %}
+                {% elif type_scale == "estructurada" %}
+                    {% for word in words %}
+                        {% include path_str with word=word tags=tags scale=scale %}
+                    {% endfor %}
+                {% endif %}
+            {% endwith %}
+        </article>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/created-scale.js' %}"></script>
+<script src="{% static 'js/actions-form.js' %}"></script>
+{% endblock %}

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

@@ -166,21 +166,72 @@
             Datos obtenidos
         </p>
 
-        <article class="bg-surface-card p-4 max-sm:px-2 text-black rounded">
-            <section class="text-xl space-y-4 space-x-4 mb-4">
-                <p class="inline italic underline font-semibold">
-                    Se usa una escala <b>{{ tipo_escala }}</b> para calificar
-                </p>
-                <p class="inline italic underline font-semibold">
-                    El valor máximo por calificación es <b>{{ valor_max }}</b>
-                </p>
+        <article class="bg-surface-card p-4 max-sm:px-2 text-black rounded space-y-4">
+            <section class="">
+                <header class="text-center">
+                    <h3 class="text-xl font-bold">Prmera fase</h3>
+                    <p class="text-lg">Listas iniciales de Catadores</p>
+                </header>
+
+                {% if fisrt_phase %}
+                <article class="flex gap-4 overflow-x-auto py-2">
+                    {% for list_tester in fisrt_phase %}
+                    {% include "../components/item-list-words.html" with list_tester=list_tester %}
+                    {% endfor %}
+                </article>
+                {% else %}
+                {% include "../components/error-message.html" with message='Sin datos por mostrar aún' %}
+                {% endif %}
+            </section>
+
+
+            <section class="">
+                <header class="text-center">
+                    <h3 class="text-xl font-bold">Segunda fase</h3>
+                    <p class="text-lg">Listas finales de Catadores</p>
+                </header>
+
+                {% if second_phase %}
+                <article class="flex gap-4 overflow-x-auto py-2">
+                    {% for list_tester in second_phase %}
+                    {% include "../components/item-list-words.html" with list_tester=list_tester %}
+                    {% endfor %}
+                </article>
+                {% else %}
+                {% include "../components/error-message.html" with message='Sin datos por mostrar aún' %}
+                {% endif %}
+            </section>
+
+            <section class="">
+                <header class="text-center">
+                    <h3 class="text-xl font-bold">Tercera fase</h3>
+                    <p class="text-lg">Listas finales de Catadores</p>
+                </header>
+
+                <article class="text-xl space-y-4 space-x-4 mb-4">
+                    <p class="inline italic underline font-semibold">
+                        Se usa una escala <b>{{ tipo_escala }}</b> para calificar
+                    </p>
+                    <p class="inline italic underline font-semibold">
+                        El valor máximo por calificación es <b>{{ valor_max }}</b>
+                    </p>
+                </article>
+
+                {% if data_ratings %}
+                <article class="overflow-x-auto py-2 space-y-4">
+                    {% for data_tester in data_ratings %}
+                    {% include "../components/table_pf.html" with data=data_tester session_name=sesion.nombre_sesion session_code=sesion.codigo_sesion %}
+                    {% endfor %}
+                </article>
+                <div class="flex justify-end mt-3">
+                    <button id="download-csv-btn" class="cts-btn-general cts-btn-primary btn-push">
+                        Descargar datos como CSV en zip
+                    </button>
+                </div>
+                {% else %}
+                {% include "../components/error-message.html" with message='Sin datos por mostrar aún' %}
+                {% endif %}
             </section>
-            {% if existen_calificaciones %}
-            {% 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 %}
         </article>
 
         <form action="" method="post" class="form-action-session hidden">
@@ -192,6 +243,9 @@
 {% endblock %}
 
 {% block extra_js %}
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+<script src="{% static 'js/download-table-zip.js' %}"></script>
 <script src="{% static 'js/details-session.js' %}"></script>
 <script src="{% static 'js/showHiddenElement.js' %}"></script>
 {% endblock %}

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

@@ -114,6 +114,10 @@ urlpatterns = [
          views.cataTest,
          name="session_cata"),
 
+    path("testers/init-session/<str:code_sesion>/perfil-flash",
+         views.pfTest,
+         name="session_pf"),
+
 
     # APIs
     path("presenter/api/nueva-etiqueta",
@@ -135,4 +139,8 @@ urlpatterns = [
     path("testers/api/ratingword/cata",
          views.ratingWordCata,
          name="api_rating_word_cata"),
+
+    path("testers/api/ratingword/pf/list",
+         views.apiListWordsPF,
+         name="api_rating_word_pf_list"),
 ]

tecnicas/views/__init__.py

@@ -25,6 +25,7 @@ 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.api_list_words_pf import apiListWordsPF
 from .apis.rating_word_scales import ratingWordScales
 from .apis.rating_word_cata import ratingWordCata
 
@@ -34,3 +35,4 @@ 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
+from .tester_forms.pf_test import pfTest

tecnicas/views/apis/api_list_words_pf.py

@@ -0,0 +1,23 @@
+from django.http import HttpRequest, JsonResponse
+from tecnicas.utils import general_error
+from tecnicas.controllers import RatingPFListController
+import json
+
+
+def apiListWordsPF(req:  HttpRequest):
+    if req.method == "GET":
+        return RatingPFListController.getListWords(request=req)
+    elif req.method == "POST":
+        try:
+            data = json.loads(req.body.decode("utf-8"))
+            raw_words = data.get("words", [])
+            phase = data.get("phase", [])
+
+            response = RatingPFListController.saveList(
+                request=req, current_phase=phase, words=raw_words)
+            return response
+        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_cata.py

@@ -14,10 +14,8 @@ def ratingWordCata(req:  HttpRequest):
             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/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={

tecnicas/views/tester_forms/cata_test.py

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

tecnicas/views/tester_forms/init_tester_form.py

@@ -1,7 +1,6 @@
 from django.http import HttpRequest, JsonResponse
-from django.shortcuts import render, redirect
-from django.urls import reverse
-from tecnicas.controllers import InitSessionTesterController, ParticipacionController
+from django.shortcuts import render
+from tecnicas.controllers import InitSessionEscalasController, InitSessionRATAController, InitSessionPFController
 from tecnicas.models import SesionSensorial
 
 
@@ -10,14 +9,22 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
     type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
     template_url = "tecnicas/forms_tester/init_session.html"
 
-    view_controller = InitSessionTesterController(
-        sensorial_session=session, user_tester=req.user.user_catador)
-
     if req.method == "GET":
         if type_technique == "escalas":
-            response = view_controller.controllGetEscalas(request=req)
+            view_controller = InitSessionEscalasController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllGet(request=req)
+
         elif type_technique == "rata" or type_technique == "cata":
-            response = view_controller.controllGetRATA(request=req)
+            view_controller = InitSessionRATAController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllGet(request=req)
+
+        elif type_technique == "perfil flash":
+            view_controller = InitSessionPFController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllGet(request=req)
+
         else:
             context = {
                 "session": session,
@@ -27,10 +34,17 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
                 req, template_url, context)
 
         return response
+
     elif req.method == "POST":
         if type_technique == "escalas" or type_technique == "rata" or type_technique == "cata":
-            response = view_controller.controllPostEscalas(request=req)
+            view_controller = InitSessionEscalasController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllPost(request=req)
 
+        elif type_technique == "perfil flash":
+            view_controller = InitSessionPFController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllPost(request=req)
         else:
             context = {
                 "session": session,

tecnicas/views/tester_forms/login_session.py

@@ -29,8 +29,12 @@ def loginSessionTester(req: HttpRequest):
 
         if type_technique == "escalas":
             response = login_controller.validateEntryEscalas(request=req)
+
         elif type_technique == "rata" or type_technique == "cata":
             response = login_controller.validateEntryRATA(request=req)
+
+        elif type_technique == "perfil flash":
+            response = login_controller.validateEntryRATA(request=req)
         else:
             context = {
                 "error": "La técnica usada en esta sesión es invalida o no ha sido implementada para ingresar a ella"

tecnicas/views/tester_forms/pf_test.py

@@ -0,0 +1,19 @@
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import redirect
+from django.urls import reverse
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import TestPFController, ParticipacionController
+
+
+def pfTest(req: HttpRequest, code_sesion: str):
+    if req.method == "GET":
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestPFController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllGet(request=req)
+
+    if req.method == "POST":
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestPFController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllPost(request=req)