Merge branch 'dev'

tecnicas/constants.py

@@ -0,0 +1,6 @@
+FORMS_TO_CREATE_SESSION = [
+    "form_basic",
+    "form_tags",
+    "form_codes",
+    "form_words"
+]

tecnicas/controllers/__init__.py

@@ -12,8 +12,20 @@ from .models_controller.posicion_controller import PosicionController
 from .models_controller.particiapacion_controller import ParticipacionController
 from .models_controller.dato_controller import DatoController
 
-from .views_controller.detalles_sesion_controller import DetallesSesionController
 from .views_controller.login_tester_controller import LoginTesterController
 from .views_controller.main_tester_form_controller import MainTesterFormController
 from .views_controller.api_rating_controller import ApiRatingController
-from .views_controller.monitor_sesion_controller import MonitorSesionController
+from .views_controller.tester_list_controller import TesterListController
+from .views_controller.list_sessions_tester_controller import ListSessionsTesterController
+
+from .views_controller.create_session.panel_basic_controller import PanelBasicController
+from .views_controller.create_session.panel_tags_controller import PanelTagsController
+from .views_controller.create_session.panel_codes_controller import PanelCodesController
+from .views_controller.create_session.panel_words_controller import PanelWordsController
+from .views_controller.create_session.panel_create_controller import PanelCreateController
+
+from .views_controller.session_management.details_controller import DetallesController
+from .views_controller.session_management.details_escala_controller import DetallesEscalasController
+from .views_controller.session_management.details_rata_controller import DetallesRATAController
+from .views_controller.session_management.monitor_controller import MonitorController
+from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -1,8 +1,7 @@
 from django.core.exceptions import ValidationError
-from django.db import DatabaseError
 from collections import defaultdict
-from ...models import Calificacion, Tecnica, Posicion, Producto, Catador
-from ...utils import controller_error, getId
+from tecnicas.models import Calificacion, Tecnica, Posicion, Producto, Catador
+from tecnicas.utils import controller_error, getId
 
 
 class CalificacionController():
@@ -46,7 +45,7 @@ class CalificacionController():
         repetition = technique.repeticion
 
         if not repetition:
-            return {"error": "sin datos calficados aun"}
+            return controller_error("Sin datos calificados aún")
 
         ratings = list(Calificacion.objects.filter(id_tecnica=technique))
 
@@ -84,7 +83,7 @@ class CalificacionController():
         elif id_tester is not None:
             filters["id_catador__id"] = id_tester
         elif user_tester is not None:
-            filters["id_catador__usuarioCatador"] = user_tester
+            filters["id_catador__user__username"] = user_tester
 
         ratings = list(Calificacion.objects.filter(**filters).select_related(
             "id_producto",

tecnicas/controllers/models_controller/dato_controller.py

@@ -89,7 +89,7 @@ class DatoController():
                 producto_code=F(
                     "id_dato__id_calificacion__id_producto__codigoProducto"),
                 usuarioCatador=F(
-                    "id_dato__id_calificacion__id_catador__usuarioCatador"),
+                    "id_dato__id_calificacion__id_catador__user__username"),
                 dato_valor=F("valor")
             )
         )

tecnicas/controllers/models_controller/escala_controller.py

@@ -26,7 +26,7 @@ class EscalaController():
             self.scale.save()
             return self.scale
         except DatabaseError as error:
-            return controller_error("error al guardar la escala")
+            return controller_error("Error al guardar la escala")
 
     def deleteScale(self):
         self.scale.delete()
@@ -67,7 +67,7 @@ class EscalaController():
             return self.tags_relation
         except DatabaseError as error:
             self.deleteRelationshipsWithLabels()
-            return controller_error("error guardar relacion etiqueta escala")
+            return controller_error("Error en guardar la relación etiqueta escala")
 
     @staticmethod
     def getScaleByTechnique(technique: Tecnica = None, id_technique: int = None):

tecnicas/controllers/models_controller/ordenes_controller.py

@@ -25,13 +25,13 @@ class OrdenesController():
 
     def saveOrders(self):
         if not self.orders:
-            return controller_error("no se han establecido las ordenes para guardar")
+            return controller_error("No se han establecido las órdenes para guardar")
         try:
             for order in self.orders:
                 order.save()
             return self.orders
         except DatabaseError as error:
-            return controller_error("error al guardar las ordenes")
+            return controller_error("Error al guardar las ordenes")
 
     def setPositions(self):
         codes_ids_products = {}
@@ -40,21 +40,21 @@ class OrdenesController():
         codes_expect = list(codes_ids_products.keys())
 
         if len(self.orders) != len(self.raw_list_orders):
-            return controller_error("el numero de ordenes guardados no coinciden con los recibidos")
+            return controller_error("El número de ordenes guardados no coinciden con los recibidos")
 
         self.positions = []
         for index, order in enumerate(self.raw_list_orders):
             received_codes_order = list(order.keys())
 
             if set(received_codes_order) != set(codes_expect):
-                return controller_error("las ordenes mandadas no contienen los productos esperados")
+                return controller_error("Las ordenes mandadas no contienen los productos esperados")
 
             for name, position_index in order.items():
                 list_product_use = [product for product in self.products
                                     if product.codigoProducto == name]
 
                 if len(list_product_use) != 1:
-                    return controller_error("no pueden existir dos productos que ocupen la misma posicion de un orden")
+                    return controller_error("No pueden existir dos productos que ocupen la misma posición de un orden")
 
                 product_use = list_product_use[0]
                 new_position = Posicion(
@@ -67,13 +67,13 @@ class OrdenesController():
 
     def savePositions(self):
         if not self.positions:
-            return controller_error("no se han establecido posiciones para guargar")
+            return controller_error("No se han establecido posiciones para guarguar")
         try:
             for position in self.positions:
                 position.save()
             return self.positions
         except DatabaseError as error:
-            return controller_error("error al guardar las posiciones")
+            return controller_error("Error al guardar las posiciones")
 
     @staticmethod
     def getOrderById(id: int):

tecnicas/controllers/models_controller/palabras_controller.py

@@ -14,11 +14,9 @@ class PalabrasController():
         self.ids_words = new_ids
 
     def setWords(self):
-        self.words = []
-        searched_words = list(Palabra.objects.filter(id__in=self.ids_words))
-        if not len(searched_words):
-            return controller_error("no se han encontrado registros")
-        self.words = searched_words
+        self.words = list(Palabra.objects.filter(id__in=self.ids_words))
+        if not len(self.words):
+            return controller_error("No se han encontrado registros")
         return self.words
 
     @staticmethod

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -1,12 +1,13 @@
-from ...models import Participacion, Tecnica, SesionSensorial
+from ...models import Participacion, Tecnica, SesionSensorial, Catador
 from ...utils import controller_error
 
 
 class ParticipacionController():
     @staticmethod
-    def enterSession(id_participation: int):
+    def enterSession(tester: Catador, session: SesionSensorial):
         try:
-            participation = Participacion.objects.get(id=id_participation)
+            participation = Participacion.objects.get(
+                catador=tester, tecnica=session.tecnica)
             participation.finalizado = False
             participation.activo = True
             participation.save()
@@ -26,9 +27,10 @@ class ParticipacionController():
             return controller_error("No se ha encontrado la participación")
 
     @staticmethod
-    def outSession(id_participation: int):
+    def outSession(tester: Catador, session: SesionSensorial):
         try:
-            participation = Participacion.objects.get(id=id_participation)
+            participation = Participacion.objects.get(
+                catador=tester, tecnica=session.tecnica)
             participation.activo = False
             participation.save()
             return participation

tecnicas/controllers/models_controller/sesion_controller.py

@@ -18,9 +18,9 @@ class SesionController():
 
     def setSession(self):
         if not self.presenter:
-            return controller_error("se requiere presentador para crear sesion")
+            return controller_error("Se requiere presentador para crear sesión")
         elif not self.technique:
-            return controller_error("se requiere tecnica para crear sesion")
+            return controller_error("Se requiere técnica para crear sesión")
 
         self.sensorial_session = SesionSensorial(
             tecnica=self.technique,
@@ -34,22 +34,22 @@ class SesionController():
 
     def saveSession(self):
         if not self.sensorial_session:
-            return controller_error("no se ha definido la sesion a guardar")
+            return controller_error("No se ha definido la sesión a guardar")
 
         try:
             self.sensorial_session.save()
             return self.sensorial_session
         except DatabaseError as error:
-            return controller_error("Error al crear la session sensorial")
+            return controller_error("Error al crear la sesión sensorial")
 
     @staticmethod
     def getSessionsSavesByCretor(user_name: str, page: int):
         elements_by_page = 6
 
         try:
-            creator = Presentador.objects.get(nombre_usuario=user_name)
+            creator = Presentador.objects.get(user__username=user_name)
         except Presentador.DoesNotExist:
-            return controller_error("presentador invalido")
+            return controller_error("Presentador invalido")
 
         queryset = (
             SesionSensorial.objects
@@ -75,10 +75,14 @@ class SesionController():
             sessions_in_page = paginator.page(page)
         except PageNotAnInteger:
             return controller_error("índice inválido")
-        except EmptyPage:
-            return controller_error("sin registros de sesiones")
 
-        return (sessions_in_page, not sessions_in_page.number < paginator.num_pages)
+        if not sessions_in_page.object_list:
+            return controller_error("Sin registros de sesiones")
+
+        current_page = sessions_in_page.number
+        is_last_page = not current_page < paginator.num_pages
+
+        return (sessions_in_page, is_last_page, current_page)
 
     @staticmethod
     def getSessionByCodePanelTester(code: str):
@@ -111,14 +115,14 @@ class SesionController():
     @staticmethod
     def getNumberSessionsByCreator(user_name: str):
         try:
-            creator = Presentador.objects.get(nombre_usuario=user_name)
+            creator = Presentador.objects.get(user__username=user_name)
 
             number_sessions = SesionSensorial.objects.filter(
                 creadoPor=creator).count()
 
             return number_sessions/9
         except Presentador.DoesNotExist:
-            return controller_error("presentador invalido")
+            return controller_error("Presentador invalido")
 
     @staticmethod
     def finishRepetion(session: SesionSensorial | str):

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -6,18 +6,18 @@ from tecnicas.utils import controller_error
 class TecnicaController():
     def setTechnique(self, **kwargs):
         self.technique = Tecnica(
-            tipo_tecnica=kwargs["tipo_tecnica"],
-            id_estilo=kwargs["estilo_palabras"],
-            repeticiones_max=kwargs["numero_repeticiones"] or 0,
+            tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=kwargs["name_tecnica"]),
+            id_estilo=EstiloPalabra.objects.get(id=kwargs["estilo_palabras"]),
+            repeticiones_max=kwargs["numero_repeticiones"] or 1,
             limite_catadores=kwargs["numero_catadores"],
             instrucciones=kwargs["instrucciones"],
         )
 
     def setTechniqueFromBasicData(self, basic):
         self.technique = Tecnica(
-            tipo_tecnica=TipoTecnica.objects.get(id=basic["id_tecnica"]),
+            tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=basic["name_tecnica"]),
             id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
-            repeticiones_max=basic["numero_repeticiones"] or 0,
+            repeticiones_max=basic["numero_repeticiones"] or 1,
             limite_catadores=basic["numero_catadores"],
             instrucciones=basic["instrucciones"] or "Espere instrucciones del Presentador",
         )
@@ -30,7 +30,7 @@ class TecnicaController():
             self.technique.save()
             return self.technique
         except DatabaseError:
-            return controller_error("No se ha podido guardar la tecnica")
+            return controller_error("No se ha podido guardar la técnica")
 
     def deleteTechnique(self):
         self.technique.delete()

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -0,0 +1,105 @@
+from tecnicas.forms import SesionBasicForm
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+
+
+class PanelBasicController():
+    conf_initial_rata = {
+        "numero_catadores": 0,
+        "numero_repeticiones": 1
+    }
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest):
+        form_sesion = SesionBasicForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "escalas"
+        }
+
+        response = render(
+            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
+        return response
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest, name_tecnica: str):
+        try:
+            form = SesionBasicForm(request.POST)
+
+            if form.is_valid():
+                values = {}
+                for name, value in form.cleaned_data.items():
+                    if name == "estilo_palabras" or name == "tipo_escala":
+                        values[name] = value.id
+                    else:
+                        values[name] = value
+
+                values["name_tecnica"] = name_tecnica
+                request.session['form_basic'] = values
+                response = redirect(
+                    reverse("cata_system:panel_configuracion_tags"))
+            else:
+                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                    "form_sesion": form, "error": "Información no valida"})
+        except KeyError:
+            response = redirect(reverse(
+                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+
+        return response
+
+    @staticmethod
+    def controllGetRATA(request: HttpRequest):
+        form_sesion = SesionBasicForm(
+            initial_conf=PanelBasicController.conf_initial_rata)
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "rata"
+        }
+
+        response = render(
+            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
+        return response
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest, name_tecnica: str):
+        try:
+            form = SesionBasicForm(
+                request.POST, initial_conf=PanelBasicController.conf_initial_rata)
+
+            if form.is_valid():
+                values = {}
+                for name, value in form.cleaned_data.items():
+                    if name == "estilo_palabras" or name == "tipo_escala":
+                        values[name] = value.id
+                    else:
+                        values[name] = value
+
+                for key, expected in PanelBasicController.conf_initial_rata.items():
+                    actual = values.get(key)
+
+                    if actual is None or str(actual) != str(expected):
+                        form.add_error(
+                            key, f"Valor inválido para '{key}': se esperaba {expected}, se recibió {actual}")
+
+                if form.errors:
+                    response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                        "form_sesion": form, "error": "No puedes modificar el número de catadores o repeticiones"})
+                else:
+                    values["name_tecnica"] = name_tecnica
+                    request.session['form_basic'] = values
+                    response = redirect(
+                        reverse("cata_system:panel_configuracion_tags"))
+            else:
+                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                    "form_sesion": form, "error": "Información no valida"})
+        except KeyError:
+            response = redirect(reverse(
+                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -0,0 +1,114 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.forms import CodesForm
+from tecnicas.utils import generarCodigos
+import json
+
+
+class PanelCodesController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest, data):
+        (
+            num_products,
+            num_tester
+        ) = PanelCodesController.defineInfoConvencional(data)
+
+        codes_products = generarCodigos(num_products)
+
+        form_codes = CodesForm(codes=codes_products)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "num_tester": num_tester,
+            "use_technique": "escalas"
+        }
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest, data):
+        (
+            num_products,
+            num_tester
+        ) = PanelCodesController.defineInfoConvencional(data)
+
+        sorts_code = json.loads(request.POST.get("sort_codes"))
+        codes = []
+        context_codes_form = {}
+
+        for name, value in request.POST.items():
+            if name.__contains__("producto_"):
+                codes.append(value)
+
+        form_codes = CodesForm(request.POST, codes=codes)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "num_tester": num_tester,
+            "use_technique": "escalas"
+        }
+
+        if form_codes.is_valid():
+            codes_sort = {"product_codes": []}
+
+            for name, value in form_codes.cleaned_data.items():
+                codes_sort["product_codes"].append({name: value})
+
+            codes_sort["sort_codes"] = sorts_code
+            request.session["form_codes"] = codes_sort
+            return redirect(reverse("cata_system:panel_configuracion_words"))
+        else:
+            context_codes_form["error"] = "error en los datos recibidos"
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
+    @staticmethod
+    def controllGetRATA(request: HttpRequest, data):
+        num_products = data["numero_productos"]
+        codes_products = generarCodigos(num_products)
+        form_codes = CodesForm(codes=codes_products)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "num_tester": 0,
+            "use_technique": "rata"
+        }
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest):
+        codes = []
+        context_codes_form = {}
+
+        for name, value in request.POST.items():
+            if name.__contains__("producto_"):
+                codes.append(value)
+
+        form_codes = CodesForm(request.POST, codes=codes)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "use_technique": "rata"
+        }
+
+        if form_codes.is_valid():
+            request.session["form_codes"] = codes
+            return redirect(reverse("cata_system:panel_configuracion_words"))
+        else:
+            context_codes_form["error"] = "error en los datos recibidos"
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
+    @staticmethod
+    def defineInfoConvencional(data):
+        num_products = data["numero_productos"]
+        num_tester = data["numero_catadores"]
+        return (
+            num_products,
+            num_tester
+        )

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

@@ -0,0 +1,274 @@
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from django.shortcuts import render
+from tecnicas.utils import general_error
+from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
+from tecnicas.utils import deleteDataSession
+
+
+class PanelCreateController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest):
+        return render(
+            request, 'tecnicas/create_sesion/creando_sesion.html')
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+
+            with transaction.atomic():
+                # ////////////////////////////////////////////////////// #
+                #
+                # First step: Create technique and scale with their tags #
+                #
+                # ////////////////////////////////////////////////////// #
+                data_basic = request.session["form_basic"]
+                controllerTechnique = TecnicaController()
+                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
+                technique = controllerTechnique.saveTechnique()
+                if not technique:
+                    return general_error("Error al guardar la técnica")
+
+                data_scale = {
+                    "id_scale": data_basic["tipo_escala"],
+                    "size": data_basic["tamano_escala"],
+                    "technique": technique
+                }
+
+                controllerScale = EscalaController(data=data_scale)
+
+                scale = controllerScale.saveScale()
+                if isinstance(scale, dict):
+                    return general_error(scale["error"])
+
+                dict_tags = request.session["form_tags"]
+                saved_related_tags = controllerScale.realteTags(dict_tags)
+                if "error" in saved_related_tags:
+                    return general_error(saved_related_tags["error"])
+
+                # ////////////////////////////////////////////////////////// #
+                #
+                # Second step: Create orders, productos and set the position #
+                #
+                # ////////////////////////////////////////////////////////// #
+                data_codes = request.session["form_codes"]
+
+                list_codes_dict = data_codes["product_codes"]
+
+                codes = []
+                for product in list_codes_dict:
+                    code = next(iter(product.values()))
+                    codes.append(code)
+
+                controllerProducts = ProductosController(
+                    codes=codes,
+                    technique=technique
+                )
+
+                controllerProducts.setProductsNoSave()
+                saved_prodcuts = controllerProducts.saveProducts()
+                if isinstance(saved_prodcuts, dict):
+                    return general_error(saved_prodcuts["error"])
+
+                raw_sort_codes = data_codes["sort_codes"]
+                controllerOrdes = OrdenesController(
+                    raw_orders=raw_sort_codes,
+                    list_products=saved_prodcuts,
+                    technique=technique
+                )
+
+                controllerOrdes.setOrdersToSave()
+                saved_orders = controllerOrdes.saveOrders()
+                if isinstance(saved_orders, dict):
+                    return general_error(saved_orders["error"])
+
+                seded_positions = controllerOrdes.setPositions()
+                if isinstance(seded_positions, dict):
+                    return general_error(seded_positions["error"])
+
+                saved_postions = controllerOrdes.savePositions()
+                if isinstance(saved_postions, dict):
+                    return general_error(saved_prodcuts["error"])
+
+                # /////////////////////////////////////////////////////// #
+                #
+                # Third step: Create relations technique with Words Style #
+                #
+                # /////////////////////////////////////////////////////// #
+                ids_words = request.session["form_words"]
+                words_controller = PalabrasController(ids=ids_words)
+
+                words_to_use = words_controller.setWords()
+                if isinstance(words_to_use, dict):
+                    return general_error(words_to_use["error"])
+
+                style_controller = EstiloPalabrasController(
+                    technique=technique, words=words_to_use)
+
+                instace_style = style_controller.createAndSaveInstaceStyle()
+                if isinstance(instace_style, dict):
+                    return general_error(instace_style["error"])
+
+                words_using = style_controller.relatedWords()
+                if isinstance(words_using, dict):
+                    return general_error(words_using["error"])
+
+                # //////////////////////////////////////////////////////// #
+                #
+                # Fourth step: Create session and relat with the technique #
+                #
+                # //////////////////////////////////////////////////////// #
+                session_controller = SesionController(
+                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                    technique=technique,
+                    creator=request.user.user_presentador
+                )
+
+                setting_session = session_controller.setSession()
+                if isinstance(setting_session, dict):
+                    return general_error(setting_session["error"])
+
+                saved_session = session_controller.saveSession()
+                if isinstance(saved_session, dict):
+                    return general_error(saved_session["error"])
+
+                context = {
+                    "message": "sesión creada",
+                    "data": {
+                        "codigo_sesion": saved_session.codigo_sesion,
+                        "nombre_sesion": saved_session.nombre_sesion
+                    }
+                }
+
+                # ////////////////////////////////// #
+                #
+                # Final step: Delete date in session #
+                #
+                # ////////////////////////////////// #
+
+                deleteDataSession(request)
+                return JsonResponse(context)
+        else:
+            return general_error("No se ha establecido acción")
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+
+            with transaction.atomic():
+                # ////////////////////////////////////////////////////// #
+                #
+                # First step: Create technique and scale with their tags #
+                #
+                # ////////////////////////////////////////////////////// #
+                data_basic = request.session["form_basic"]
+                data_basic["numero_catadores"] = 0
+                data_basic["numero_repeticiones"] = 1
+                controllerTechnique = TecnicaController()
+                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
+                technique = controllerTechnique.saveTechnique()
+                if not technique:
+                    return general_error("Error al guardar la técnica")
+
+                data_scale = {
+                    "id_scale": data_basic["tipo_escala"],
+                    "size": data_basic["tamano_escala"],
+                    "technique": technique
+                }
+
+                controllerScale = EscalaController(data=data_scale)
+
+                scale = controllerScale.saveScale()
+                if isinstance(scale, dict):
+                    return general_error(scale["error"])
+
+                dict_tags = request.session["form_tags"]
+                saved_related_tags = controllerScale.realteTags(dict_tags)
+                if "error" in saved_related_tags:
+                    return general_error(saved_related_tags["error"])
+
+                # ////////////////////////////////////////////// #
+                #
+                # Second step: Create productos with their codes #
+                #
+                # ////////////////////////////////////////////// #
+                codes = request.session["form_codes"]
+
+                controllerProducts = ProductosController(
+                    codes=codes,
+                    technique=technique
+                )
+
+                controllerProducts.setProductsNoSave()
+                saved_prodcuts = controllerProducts.saveProducts()
+                if isinstance(saved_prodcuts, dict):
+                    return general_error(saved_prodcuts["error"])
+
+                # /////////////////////////////////////////////////////// #
+                #
+                # Third step: Create relations technique with Words Style #
+                #
+                # /////////////////////////////////////////////////////// #
+                ids_words = request.session["form_words"]
+                words_controller = PalabrasController(ids=ids_words)
+
+                words_to_use = words_controller.setWords()
+                if isinstance(words_to_use, dict):
+                    return general_error(words_to_use["error"])
+
+                style_controller = EstiloPalabrasController(
+                    technique=technique, words=words_to_use)
+
+                instace_style = style_controller.createAndSaveInstaceStyle()
+                if isinstance(instace_style, dict):
+                    return general_error(instace_style["error"])
+
+                words_using = style_controller.relatedWords()
+                if isinstance(words_using, dict):
+                    return general_error(words_using["error"])
+
+                # //////////////////////////////////////////////////////// #
+                #
+                # Fourth step: Create session and relat with the technique #
+                #
+                # //////////////////////////////////////////////////////// #
+                session_controller = SesionController(
+                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                    technique=technique,
+                    creator=request.user.user_presentador
+                )
+
+                setting_session = session_controller.setSession()
+                if isinstance(setting_session, dict):
+                    return general_error(setting_session["error"])
+
+                saved_session = session_controller.saveSession()
+                if isinstance(saved_session, dict):
+                    return general_error(saved_session["error"])
+
+                context = {
+                    "message": "sesión creada",
+                    "data": {
+                        "codigo_sesion": saved_session.codigo_sesion,
+                        "nombre_sesion": saved_session.nombre_sesion
+                    }
+                }
+
+                # ////////////////////////////////// #
+                #
+                # Final step: Delete date en session #
+                #
+                # ////////////////////////////////// #
+                deleteDataSession(request)
+                return JsonResponse(context)
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panel_tags_controller.py

@@ -0,0 +1,71 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.forms import SesionTagsForm, EtiquetaForm
+from tecnicas.models import TipoEscala
+
+
+class PanelTagsController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest, data):
+        (
+            type_scale,
+            tamano_escala,
+            form_new_etiqueta
+        ) = PanelTagsController.defineInfoScale(data)
+
+        form_etiqutas = SesionTagsForm(
+            longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
+
+        context_tags = {
+            "form_tags": form_etiqutas,
+            "form_new_tag": form_new_etiqueta
+        }
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest, data):
+        (
+            type_scale,
+            tamano_escala,
+            form_new_etiqueta
+        ) = PanelTagsController.defineInfoScale(data)
+
+        values = {}
+        form = SesionTagsForm(request.POST, longitud=tamano_escala,
+                              tipo_escala=type_scale.nombre_escala)
+
+        context_tags = {
+            "form_tags": form,
+            "form_new_tag": form_new_etiqueta
+        }
+
+        if form.is_valid():
+            for name, value in form.cleaned_data.items():
+                values[name] = value.id
+
+            request.session["form_tags"] = values
+            response = redirect(
+                reverse("cata_system:panel_configuracion_codes"))
+        else:
+            context_tags["error"] = "ha ocurrido un error"
+            response = render(
+                request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+
+        return response
+
+    @staticmethod
+    def defineInfoScale(data):
+        type_scale = TipoEscala.objects.get(pk=data["tipo_escala"])
+        tamano_escala = data["tamano_escala"]
+        form_new_etiqueta = EtiquetaForm()
+
+        return (
+            type_scale,
+            tamano_escala,
+            form_new_etiqueta
+        )

tecnicas/controllers/views_controller/create_session/panel_words_controller.py

@@ -0,0 +1,49 @@
+from django.http import HttpRequest
+from tecnicas.forms import WordForm
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Palabra
+import json
+
+
+class PanelWordsController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest):
+        form = WordForm()
+        context = {
+            "form_word": form
+        }
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest):
+        form = WordForm()
+        context = {
+            "form_word": form
+        }
+
+        if not request.POST.get("words"):
+            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+        words = json.loads(request.POST.get("words"))
+        context["words"] = words
+
+        ids_words = [word["id"] for word in words]
+
+        if len(ids_words) != len(set(ids_words)):
+            context["error"] = "existen palabras duplicadas"
+            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+        exist_words = Palabra.objects.filter(
+            id__in=ids_words).count() == len(ids_words)
+
+        if not exist_words:
+            context["error"] = "algunas palabras no existen"
+            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+        request.session["form_words"] = ids_words
+        return redirect(reverse("cata_system:creando_sesion"))

tecnicas/controllers/views_controller/list_sessions_tester_controller.py

@@ -0,0 +1,76 @@
+from django.core.paginator import Paginator, PageNotAnInteger
+from django.db.models import OuterRef, Subquery, BooleanField
+from tecnicas.models import Catador, SesionSensorial, Participacion
+from tecnicas.utils import controller_error
+
+
+class ListSessionsTesterController():
+    def __init__(self):
+        pass
+
+    def getContext(self, user: Catador, page: int):
+        context_view = {}
+
+        response = ListSessionsTesterController.getSessionByTester(page, user)
+        if isinstance(response, dict):
+            return response
+
+        (sessions, is_last_page, current_page) = response
+        context_view["sessions"] = sessions
+        context_view["last_page"] = is_last_page
+        context_view["page"] = current_page
+
+        return context_view
+
+    @staticmethod
+    def getSessionByTester(page: int, tester: Catador):
+        elements_by_page = 6
+
+        base_qs = SesionSensorial.objects.filter(
+            tecnica__tecnica_participacion__catador=tester
+        )
+
+        participacion_finalizado_subq = Subquery(
+            Participacion.objects.filter(
+                tecnica=OuterRef('tecnica_id'),
+                catador=tester
+            ).values('finalizado')[:1],
+            output_field=BooleanField()
+        )
+
+        participacion_activo_subq = Subquery(
+            Participacion.objects.filter(
+                tecnica=OuterRef('tecnica_id'),
+                catador=tester
+            ).values('activo')[:1],
+            output_field=BooleanField()
+        )
+
+        queryset = (
+            base_qs
+            .select_related(
+                'tecnica',
+                'tecnica__tipo_tecnica',
+                'tecnica__id_estilo',
+            )
+            .annotate(
+                participacion_finalizado=participacion_finalizado_subq,
+                participacion_activo=participacion_activo_subq,
+            )
+            .order_by('participacion_finalizado', '-activo', '-fechaCreacion')
+            .distinct()
+        )
+
+        paginator = Paginator(queryset, elements_by_page)
+        try:
+            sessions_in_page = paginator.page(page)
+        except PageNotAnInteger:
+            return controller_error("índice inválido")
+
+        if not sessions_in_page.object_list:
+            return controller_error("Sin registros de Participaciones")
+
+        current_page = sessions_in_page.number
+        is_last_page = not current_page < paginator.num_pages
+
+        return (sessions_in_page, is_last_page, current_page)

tecnicas/controllers/views_controller/login_tester_controller.py

@@ -1,12 +1,17 @@
-from ...models import Catador, SesionSensorial, Participacion
-from ...utils import controller_error
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import render, redirect
+from django.urls import reverse
 from django.db import transaction
+from tecnicas.models import Catador, SesionSensorial, Participacion
+from tecnicas.utils import controller_error
 
 
 class LoginTesterController():
     tester: Catador
     session: SesionSensorial
     taster_participation: Participacion
+    current_direcction = "tecnicas/forms_tester/login_session.html"
+    destinity_direcction = "cata_system:catador_init_session"
 
     def __init__(self):
         self.tester = Catador()
@@ -14,7 +19,7 @@ class LoginTesterController():
 
     def existCredential(self, user_tester: str, code_session: str):
         try:
-            self.tester = Catador.objects.get(usuarioCatador=user_tester)
+            self.tester = Catador.objects.get(user__username=user_tester)
             self.session = SesionSensorial.objects.get(
                 codigo_sesion=code_session)
 
@@ -22,42 +27,73 @@ class LoginTesterController():
         except (Catador.DoesNotExist, SesionSensorial.DoesNotExist):
             return controller_error("Credenciales inválidas")
 
-    def validateEntry(self):
-        if not self.tester.nombre or not self.session.codigo_sesion:
-            return controller_error("Credenciales no definidas")
-
+    def validateEntryEscalas(self, request=HttpRequest):
+        context = {}
         if not self.session.activo:
-            return controller_error("La sesión no está activa actualmente")
+            context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, context)
 
         if self.session.tecnica.repeticion > 1:
             try:
                 self.taster_participation = Participacion.objects.get(
                     tecnica=self.session.tecnica, catador=self.tester)
-                return self.taster_participation
+                context["error"] = "Usted ya esta dentro de la sesión"
+                return render(request, self.current_direcction, context)
             except Participacion.DoesNotExist:
-                return controller_error("No tienes permitido entrar a esta sesión")
+                context["error"] = "No tienes permitido entrar a esta sesión"
+                return render(request, self.current_direcction, context)
         else:
+            with transaction.atomic():
+                code_session = self.session.codigo_sesion
+                self.session = SesionSensorial.objects.select_for_update().get(
+                    codigo_sesion=code_session)
+
+                max_testers = self.session.tecnica.limite_catadores
+                current_num_testers = Participacion.objects.filter(
+                    tecnica=self.session.tecnica).count()
+
+                if current_num_testers >= max_testers:
+                    context["error"] = "La sesión ha alcanzado el número máximo de catadores"
+                    return render(request, self.current_direcction, context)
+
+                self.taster_participation = Participacion.objects.create(
+                    tecnica=self.session.tecnica,
+                    catador=self.tester,
+                    finalizado=False
+                )
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.destinity_direcction, kwargs=params))
+
+    def validateEntryRATA(self, request: HttpRequest):
+        context = {}
+        if not self.session.activo:
+            context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, context)
+
+        if self.session.tecnica.repeticion <= 1:
             try:
                 self.taster_participation = Participacion.objects.get(
                     tecnica=self.session.tecnica, catador=self.tester)
-                return self.taster_participation
+                context["error"] = "Usted ya esta dentro de la sesión"
+                return render(request, self.current_direcction, context)
             except Participacion.DoesNotExist:
                 with transaction.atomic():
                     code_session = self.session.codigo_sesion
                     self.session = SesionSensorial.objects.select_for_update().get(
                         codigo_sesion=code_session)
 
-                    max_testers = self.session.tecnica.limite_catadores
-                    current_num_testers = Participacion.objects.filter(
-                        tecnica=self.session.tecnica).count()
-
-                    if current_num_testers >= max_testers:
-                        return controller_error("La sesión ha alcanzado el número máximo de catadores")
-
                     self.taster_participation = Participacion.objects.create(
                         tecnica=self.session.tecnica,
                         catador=self.tester,
                         finalizado=False
                     )
 
-                    return self.taster_participation
+                params = {
+                    "code_sesion": self.session.codigo_sesion
+                }
+                return redirect(reverse(self.destinity_direcction, kwargs=params))
+        else:
+            context["error"] = "Imposible acceder a esta sesión"
+            return render(request, self.current_direcction, context)

tecnicas/controllers/views_controller/main_tester_form_controller.py

@@ -10,7 +10,7 @@ class MainTesterFormController():
 
     def __init__(self, code_session: str, user_tester: str):
         try:
-            self.tester = Catador.objects.get(usuarioCatador=user_tester)
+            self.tester = Catador.objects.get(user__username=user_tester)
             self.session = SesionSensorial.objects.get(
                 codigo_sesion=code_session)
         except (Catador.DoesNotExist, SesionSensorial.DoesNotExist):
@@ -21,6 +21,8 @@ class MainTesterFormController():
             orders_without_tester = list(Orden.objects.select_for_update().filter(
                 id_tecnica=self.session.tecnica, id_catador=None))
 
+            print(orders_without_tester)
+
             if not orders_without_tester:
                 return controller_error("Las ordenes se han acabado")
 
@@ -32,21 +34,20 @@ class MainTesterFormController():
 
             return self.order_to_assign
 
-    def checkAssignOrder(self):
-        if not self.tester or not self.session:
-            return controller_error("Atributos no establecidos")
-
+    def checkAndAssignOrder(self):
         try:
-            res_order = Orden.objects.get(
+            self.order_to_assign = Orden.objects.get(
                 id_tecnica=self.session.tecnica, id_catador=self.tester)
-            self.order = res_order
-            return self.order
         except Orden.DoesNotExist:
-            return controller_error("Catador sin orden")
+            create = self.assignOrder()
+            if isinstance(create, dict):
+                return create
+        return self.order_to_assign
 
-    def isEndedSession(self, id_participation: int, repetition: int):
+    def isEndedSession(self, repetition: int):
         try:
-            participation = Participacion.objects.get(id=id_participation)
+            participation = Participacion.objects.get(
+                catador=self.tester, tecnica=self.session.tecnica)
 
             # ////////////////////////////////////////////////////////////// #
             #
@@ -76,7 +77,7 @@ class MainTesterFormController():
 
                 expected_ratings_repetition = num_products * num_words
 
-                return  num_ratings_now >= expected_ratings_repetition
+                return num_ratings_now >= expected_ratings_repetition
             else:
                 return participation.finalizado
         except Participacion.DoesNotExist:

tecnicas/controllers/views_controller/session_management/details_controller.py

@@ -0,0 +1,13 @@
+from tecnicas.models import SesionSensorial, Presentador, Tecnica
+from tecnicas.utils import controller_error
+
+
+class DetallesController():
+    url_template = "tecnicas/manage_sesions/detalles-sesion.html"
+
+    def __init__(self, session: SesionSensorial):
+        self.session = session
+
+    def deleteSesorialSession(self):
+        technique = Tecnica.objects.get(id=self.session.tecnica.id)
+        technique.delete()

tecnicas/controllers/views_controller/{detalles_sesion_controller.py → session_management/details_escala_controller.py}

@@ -11,29 +11,42 @@ Encabezados de como deben de aparecer los datos juntos
 | Repeticion | Codigo Producto | Catador | P1 | P2 | P3 | Pn |
 
 '''
-
-from ...models import SesionSensorial, Presentador, Tecnica, Palabra
-from .. import CalificacionController, PalabrasController
-from ...utils import controller_error
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Presentador, Tecnica
+from tecnicas.controllers import DatoController, CalificacionController, PalabrasController
+from .details_controller import DetallesController
+from tecnicas.utils import defaultdict_to_dict, controller_error
 from collections import defaultdict
-from tecnicas.controllers import DatoController
-from tecnicas.utils import defaultdict_to_dict
 
 
-class DetallesSesionController():
-    def __init__(self, session_code: str):
-        self.session = SesionSensorial.objects.get(codigo_sesion=session_code)
+class DetallesEscalasController(DetallesController):
+    url_template = "tecnicas/manage_sesions/detalles-sesion.html"
 
-    def getContextForView(self):
-        self.context = {}
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
 
-        self.context["sesion"] = self.session
+    def getResponse(self, request: HttpRequest, error: str = "", message: str = ""):
+        context = self.getContext()
+
+        if error != "" or error:
+            context["error"] = error
+        if message != "" or message:
+            context["message"] = message
+            
+        return render(
+            request, self.url_template, context)
 
+    def getContext(self):
+        self.context = {
+            "use_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+        self.context["sesion"] = self.session
         self.words = PalabrasController.getWordsInTechnique(
             self.session.tecnica)
         self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
-    def getContextWithData(self):
         ratings_for_repetition = []
 
         ratings = CalificacionController.getRatingsByTechnique(
@@ -66,30 +79,25 @@ class DetallesSesionController():
 
         return self.context
 
-    @staticmethod
-    def startRepetition(session_code: str, username: str):
-        try:
-            creator = Presentador.objects.get(nombre_usuario=username)
-            session = SesionSensorial.objects.get(codigo_sesion=session_code)
-            technique = Tecnica.objects.get(id=session.tecnica.id)
-        except Presentador.DoesNotExist:
-            return controller_error("no existe presentador")
-        except SesionSensorial.DoesNotExist:
-            return controller_error("no existe sesión sensorial")
-        except Tecnica.DoesNotExist:
-            return controller_error("Ha ocurrido un error al recuperar la técnica")
-
-        if creator.nombre_usuario != session.creadoPor.nombre_usuario:
-            return controller_error("solo el presentador que crea la sesión puede iniciar la repetición")
-        elif session.activo:
-            return controller_error("la sesión ya está activada")
+    def startRepetition(self, presenter: Presentador):
+        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")
+        elif self.session.activo:
+            return self.getResponse(error="La sesión ya está activada")
         elif technique.repeticion == technique.repeticiones_max:
-            return controller_error("se ha alcanzado el número de repeticiones máxima")
+            return self.getResponse(error="Se ha alcanzado el número de repeticiones máxima")
 
-        session.activo = True
+        self.session.activo = True
         technique.repeticion = technique.repeticion + 1
 
         technique.save()
-        session.save()
+        self.session.save()
 
-        return session
+        parameters = {
+            "session_code": self.session.codigo_sesion
+        }
+        return redirect(
+            reverse("cata_system:monitor_sesion", kwargs=parameters))

tecnicas/controllers/views_controller/session_management/details_rata_controller.py

@@ -0,0 +1,56 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import PalabrasController, DatoController, CalificacionController
+from tecnicas.utils import defaultdict_to_dict
+from .details_controller import DetallesController
+from collections import defaultdict
+
+
+class DetallesRATAController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+
+    def getResponse(self, request: HttpRequest, error: str = ""):
+        context = self.getContext()
+        if error != "" or error:
+            context["error"] = error
+        return render(
+            request, self.url_template, context)
+
+    def getContext(self):
+        self.context = {}
+        self.context["sesion"] = self.session
+        self.words = PalabrasController.getWordsInTechnique(
+            self.session.tecnica)
+        self.context["palabras"] = [word.nombre_palabra for word in self.words]
+
+        ratings_for_repetition = []
+
+        ratings = CalificacionController.getRatingsByTechnique(
+            technique=self.session.tecnica)
+
+        if isinstance(ratings, dict) or not ratings:
+            self.context["calificaciones"] = ratings_for_repetition
+            self.context["existen_calificaciones"] = False
+            return self.context
+
+        data = DatoController.getWordValuesForConvecional(
+            ratings=ratings, technique=self.session.tecnica)
+
+        ratings_for_repetition = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(list)))
+
+        for item in data:
+            user = item["usuarioCatador"]
+            rep = item["repeticion"]
+            prod = item["producto_code"]
+
+            ratings_for_repetition[rep][user][prod].append({
+                "nombre_palabra": item["nombre_palabra"],
+                "dato_valor": item["dato_valor"]
+            })
+
+        self.context["calificaciones"] = defaultdict_to_dict(
+            ratings_for_repetition)
+        self.context["existen_calificaciones"] = True

tecnicas/controllers/views_controller/session_management/monitor_controller.py

@@ -0,0 +1,10 @@
+from tecnicas.models import SesionSensorial
+
+
+class MonitorController():
+    def __init__(self, session: SesionSensorial):
+        self.sensorial_session = session
+
+    def updataSession(self):
+        self.sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=self.sensorial_session.codigo_sesion)

tecnicas/controllers/views_controller/{monitor_sesion_controller.py → session_management/monitor_escalas_controller.py}

@@ -1,61 +1,72 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
 from tecnicas.models import SesionSensorial, EsAtributo, EsVocabulario, Producto, Calificacion
 from tecnicas.controllers import ParticipacionController, SesionController
 from tecnicas.utils import controller_error
+from .monitor_controller import MonitorController
 
 
-class MonitorSesionController():
-    def __init__(self, session_code: str):
-        self.code_session = session_code
+class MonitorEscalasController(MonitorController):
+    url_view = "tecnicas/manage_sesions/monitor-sesion.html"
 
-    def defineSession(self):
-        self.session = SesionSensorial.objects.get(
-            codigo_sesion=self.code_session)
+    def __init__(self, session: SesionController):
+        super().__init__(session)
 
-    def monitorView(self):
-        try:
-            self.sensorial_session = SesionSensorial.objects.select_related(
-                "tecnica"
-            ).only(
-                "nombre_sesion",
-                "tecnica__limite_catadores",
-            ).get(codigo_sesion=self.code_session)
+    def controlGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
+        self.setContext()
 
-            self.participations = ParticipacionController.getParticipationsInTechinique(
-                self.sensorial_session.tecnica)
-        except SesionSensorial.DoesNotExist as error:
-            return controller_error("No existe Sesión sensorial")
+        if error != "" or error:
+            self.context["error"] = error
+        if message != "" or message:
+            self.context["message"] = message
 
-        context = {
+        return render(request, self.url_view, self.context)
+
+    def controlPostResponseFinishSession(self, request: HttpRequest):
+        self.setContext()
+        (is_all_end, message) = self.checkAllParticipantsEnded()
+        if not is_all_end:
+            self.context["error"] = message
+            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+        response = self.finishSession()
+        if isinstance(response, dict):
+            self.context["error"] = response["error"]
+            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+        self.context["message"] = message
+        return redirect(reverse("cata_system:detalles_sesion", kwargs={"session_code": self.sensorial_session.codigo_sesion}))
+
+    def setContext(self):
+        self.participations = ParticipacionController.getParticipationsInTechinique(
+            self.sensorial_session.tecnica)
+
+        self.context = {
+            "code_session": self.sensorial_session.codigo_sesion,
             "session_name": self.sensorial_session.nombre_sesion,
             "max_testers": self.sensorial_session.tecnica.limite_catadores,
             "current_testers": len(self.participations),
             "active_testers": len([part for part in self.participations if part.activo]),
-            "participations": self.participations
+            "participations": self.participations,
+            "use_technique": self.sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
         }
 
-        return context
-
     def getExpectedRatings(self):
         num_products = Producto.objects.filter(
-            id_tecnica=self.session.tecnica).count()
-
-        style_words = self.session.tecnica.id_estilo
-
+            id_tecnica=self.sensorial_session.tecnica).count()
+        style_words = self.sensorial_session.tecnica.id_estilo
         num_words: int
 
         if style_words.nombre_estilo == "atributos":
             num_words = EsAtributo.objects.get(
-                id_tecnica=self.session.tecnica).palabras.count()
+                id_tecnica=self.sensorial_session.tecnica).palabras.count()
         elif style_words.nombre_estilo == "vocabulario":
             num_words = EsVocabulario.objects.get(
-                id_tecnica=self.session.tecnica).id_vocabulario.palabras.count()
+                id_tecnica=self.sensorial_session.tecnica).id_vocabulario.palabras.count()
 
         return num_products * num_words
 
     def checkAllParticipantsEnded(self):
-        self.defineSession()
-
-        technique = self.session.tecnica
+        technique = self.sensorial_session.tecnica
 
         expected_ratings_repetition = self.getExpectedRatings()
 
@@ -75,8 +86,8 @@ class MonitorSesionController():
         return (True, "Puedes finalizar la sesión")
 
     def finishSession(self):
-        response = SesionController.finishRepetion(self.session)
+        response = SesionController.finishRepetion(self.sensorial_session)
         if isinstance(response, dict):
             return controller_error(response["error"])
-        self.defineSession()
-        return self.session
+        self.updataSession()
+        return self.sensorial_session

tecnicas/controllers/views_controller/tester_list_controller.py

@@ -0,0 +1,58 @@
+from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
+from tecnicas.models import Catador
+from tecnicas.utils import controller_error
+
+
+class TesterListController():
+    def __init__(self, page: int):
+        self.num_page = page
+
+    def getContext(self):
+        view_context = {"num_page": self.num_page}
+
+        res_tuple = TesterListController.getTestersByPage(page=self.num_page)
+
+        if isinstance(res_tuple, dict):
+            view_context["error"] = res_tuple["error"]
+            return view_context
+        
+        (testers, last_page) = res_tuple
+
+        view_context["testers"] = testers
+        view_context["last_page"] = last_page
+
+        return view_context
+
+    @staticmethod
+    def getTestersByPage(page: int):
+        elements_by_page = 6
+
+        queryset = (
+            Catador.objects
+            .select_related(
+                "user"
+            )
+            .only(
+                "user__first_name",
+                "user__last_name",
+                "user__username",
+                "user__email",
+                "genero",
+                "telefono",
+                "nacimiento"
+            )
+            .order_by("-user__date_joined")
+        )
+
+        paginator = Paginator(queryset, elements_by_page)
+        try:
+            testers_in_page = paginator.page(page)
+        except PageNotAnInteger:
+            return controller_error("índice inválido")
+
+        if not testers_in_page.object_list:
+            return controller_error("Sin registros de Catadores")
+
+        is_last_page = not testers_in_page.number < paginator.num_pages
+
+        return (testers_in_page, is_last_page)

tecnicas/decorators/required_presenter.py

@@ -8,7 +8,7 @@ def required_presenter(view_func):
         if not request.user.is_authenticated:
             return redirect("cata_system:autenticacion")
         
-        if not hasattr(request.user, "presentador"):
+        if not hasattr(request.user, "user_presentador"):
             raise PermissionDenied(
                 "Solo los presentadores pueden acceder a esta vista")
         return view_func(request, *args, **kwargs)

tecnicas/forms/catador_form.py

@@ -1,25 +1,148 @@
 from django import forms
-from ..models import Catador
-
-class CatadorForm(forms.ModelForm):
-    class Meta:
-        model =  Catador
-        fields = "__all__"
-        widgets = {
-            "usuarioCatador": forms.TextInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general" } ),
-            "nombre": forms.TextInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general" } ),
-            "apellido": forms.TextInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general" } ),
-            "telefono": forms.NumberInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general", "max": "10", "min": "10" } ),
-            "correo": forms.EmailInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general" } ),
-            "fechaNacimiento": forms.DateInput( attrs={ "class": "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-general", "type": "date", } ),
+from django.contrib.auth.models import User
+from django.core.validators import RegexValidator, EmailValidator
+
+
+class CatadorForm(forms.Form):
+    styles_input = "ct-inputs-pos-cata bg-surface-ligt text-center w-full p-1 rounded-lg text-black disabled:bg-surface-alter-card"
+
+    nombre_usuario = forms.CharField(
+        label="Nombre de usuario",
+        max_length=30,
+        min_length=5,
+        required=True,
+        validators=[
+            RegexValidator(
+                regex=r'^(?![0-9._])[A-Za-z0-9._]+$',
+                message=(
+                    "El nombre de usuario debe iniciar con una letra y solo puede "
+                    "contener letras, números, puntos y guiones bajos."
+                ),
+                code='invalid_username'
+            )
+        ],
+        widget=forms.TextInput(
+            attrs={
+                "placeholder": "Ej. mario_hugo23",
+                "class": styles_input,
+            }
+        )
+    )
+
+    nombre = forms.CharField(
+        label="Nombre del catador",
+        max_length=50,
+        required=True,
+        validators=[
+            RegexValidator(
+                regex=r'^[A-Za-zÁÉÍÓÚáéíóúÑñ\s]+$',
+                message="El nombre solo puede contener letras y espacios."
+            )
+        ],
+        widget=forms.TextInput(
+            attrs={
+                "placeholder": "Ej. Mario",
+                "class": styles_input,
+            }
+        )
+    )
+
+    apellido = forms.CharField(
+        label="Apellido del catador",
+        max_length=50,
+        required=True,
+        validators=[
+            RegexValidator(
+                regex=r'^[A-Za-zÁÉÍÓÚáéíóúÑñ\s]+$',
+                message="El apellido solo puede contener letras y espacios."
+            )
+        ],
+        widget=forms.TextInput(
+            attrs={
+                "placeholder": "Ej. Sánchez",
+                "class": styles_input,
+            }
+        )
+    )
+
+    telefono = forms.CharField(
+        label="Teléfono",
+        max_length=10,
+        required=True,
+        validators=[
+            RegexValidator(
+                regex=r'^\d{10}$',
+                message="El teléfono debe contener solo números (puede incluir + al inicio)."
+            )
+        ],
+        widget=forms.TextInput(
+            attrs={
+                "placeholder": "Ej. 5512345678",
+                "class": styles_input,
+                "type": "tel",
+            }
+        )
+    )
+
+    correo = forms.EmailField(
+        label="Correo electrónico",
+        required=True,
+        validators=[EmailValidator(
+            message="Introduce un correo electrónico válido.")],
+        widget=forms.EmailInput(
+            attrs={
+                "placeholder": "Ej. mario@example.com",
+                "class": styles_input,
+            }
+        )
+    )
+
+    fecha_nacimiento = forms.DateField(
+        label="Fecha de nacimiento",
+        required=True,
+        widget=forms.DateInput(
+            attrs={
+                "type": "date",
+                "class": styles_input,
+            }
+        ),
+        error_messages={
+            "invalid": "Introduce una fecha válida (DD-MM-YYYY)."
         }
+    )
+
+    GENERO_OPCIONES = [
+        ('Hombre', 'Hombre'),
+        ('Mujer', 'Mujer')
+    ]
+
+    genero = forms.ChoiceField(
+        label="Género",
+        required=True,
+        choices=GENERO_OPCIONES,
+        widget=forms.RadioSelect(
+            attrs={
+                "class": "ct-inputs-pos-cata radio radio-warning checked:bg-btn-secondary mx-2 bg-surface-ligt disabled:bg-ct-error"
+            }
+        )
+    )
+
+    is_update = forms.BooleanField(
+        initial=False,
+        required=False,
+        widget=forms.HiddenInput()
+    )
 
     def clean(self):
-        data_cleand = super().clean()
-
-        phone = data_cleand["telefono"]
-        size_phone = len(str(abs(phone)))
-        print("tamano de telefono", size_phone)
-        if size_phone != 10:
-            self.add_error("telefono", "telefono debe tener 10 digitos")
-            return data_cleand
+        cleaned_data = super().clean()
+        username = cleaned_data.get("nombre_usuario")
+        is_update = cleaned_data.get("is_update")
+
+        print(username, is_update)
+
+        if not is_update:
+            if User.objects.filter(username__iexact=username).exists():
+                raise forms.ValidationError(
+                    "Este nombre de usuario ya está registrado.")
+
+        return cleaned_data

tecnicas/forms/codes_form.py

@@ -1,10 +1,11 @@
 from django import forms
 
+
 class CodesForm(forms.Form):
-    def __init__(self, *args, codes = [], **kwargs):
+    def __init__(self, *args, codes=[], **kwargs):
         super().__init__(*args, **kwargs)
 
         for index, code in enumerate(codes):
             self.fields[f'producto_{index+1}'] = forms.CharField(max_length=3, required=True, min_length=3, initial=code, label=f"codigo {index+1}", widget=forms.TextInput(attrs={
                 "class": "ct-code bg-surface-ligt p-1 border-b-1 text-center w-full disabled:bg-surface-general uppercase"
-            }))
+            }))

tecnicas/forms/sesion_basic_form.py

@@ -5,7 +5,8 @@ from ..models import EstiloPalabra
 
 
 class SesionBasicForm(forms.Form):
-    id_tecnica = forms.IntegerField(widget=forms.HiddenInput())
+    sizes_structure = [5, 7, 9]
+    sizes_continue = [9, 13, 15]
 
     nombre_sesion = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
         "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
@@ -28,36 +29,37 @@ class SesionBasicForm(forms.Form):
         "placeholder": "Solo números"
     }), required=True)
 
-    tamano_escala = forms.IntegerField(widget=forms.NumberInput(attrs={
-        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
-    }), required=True, min_value=5)
-
     instrucciones = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
         "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
         "placeholder": "Este campo es opcional"
     }), required=False)
 
-    def __init__(self, *args, id_tecnica_new=0, **kwargs):
+    def __init__(self, *args, initial_conf: dict = None, **kwargs):
         super().__init__(*args, **kwargs)
 
+        if initial_conf is None:
+            initial_conf = {}
+
         self.fields['estilo_palabras'] = forms.ModelChoiceField(queryset=EstiloPalabra.objects.all(), widget=forms.RadioSelect(attrs={
-        "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
+            "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
         }), required=True, initial=EstiloPalabra.objects.first())
 
         self.fields['tipo_escala'] = forms.ModelChoiceField(queryset=TipoEscala.objects.all(), widget=forms.RadioSelect(attrs={
             "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
         }), required=True, initial=TipoEscala.objects.first())
 
-        if id_tecnica_new != 0:
-            self.fields['id_tecnica'] = forms.IntegerField(
-                initial=id_tecnica_new, widget=forms.HiddenInput())
+        self.fields['tamano_escala'] = forms.IntegerField(widget=forms.HiddenInput(attrs={
+            "class": "cts-size-input",
+        }), required=True)
 
-    def clean(self):
-        data_clean = super().clean()
+        if "numero_catadores" in initial_conf:
+            self.fields["numero_catadores"].initial = initial_conf["numero_catadores"]
 
-        sizes_estruturada = [5, 7, 9]
-        sizes_continua = [9, 12, 15]
+        if "numero_repeticiones" in initial_conf:
+            self.fields["numero_repeticiones"].initial = initial_conf["numero_repeticiones"]
 
+    def clean(self):
+        data_clean = super().clean()
         escala = data_clean.get("tipo_escala")
 
         if escala and not isinstance(escala, TipoEscala):
@@ -70,14 +72,7 @@ class SesionBasicForm(forms.Form):
 
         tamano_escala = data_clean.get("tamano_escala")
 
-        if escala.nombre_escala == "estructurada" and not sizes_estruturada.__contains__(tamano_escala):
+        if escala.nombre_escala == "estructurada" and not self.sizes_structure.__contains__(tamano_escala):
             self.add_error("tamano_escala", "El tamaño de la escala no aplica")
-        elif escala.nombre_escala == "continua" and not sizes_continua.__contains__(tamano_escala):
+        elif escala.nombre_escala == "continua" and not self.sizes_continue.__contains__(tamano_escala):
             self.add_error("tamano_escala", "El tamaño de la escala no aplica")
-
-        id_tecnica = data_clean.get("id_tecnica")
-
-        try:
-            tecnica = TipoTecnica.objects.get(pk=id_tecnica)
-        except (ValueError, TipoTecnica.DoesNotExist):
-            return data_clean

tecnicas/forms/sesion_tags_form.py

@@ -1,25 +1,35 @@
 from django import forms
-
 from ..models import Etiqueta
 
+
 class SesionTagsForm(forms.Form):
-    def __init__(self, *args, longitud=None, tipo_escala:str=None, **kwargs):
+    available_struture_tags = {
+        "5": ["percepcion nula", "percepcion moderada", "se puede percibir",
+              "percepcion intensa", "percepcion total"],
+        "7": ["percepcion nula", "ligera percepcion", "percepcion moderada", "se puede percibir", "buena percepcion",
+              "percepcion intensa", "percepcion total"],
+        "9": ["percepcion nula", "ligera percepcion", "poca percepcion", "percepcion moderada", "se puede percibir", "buena percepcion",
+              "percepcion intensa", "percepcion muy intensa", "percepcion total"]
+    }
+
+    def __init__(self, *args, longitud=None, tipo_escala: str = None, **kwargs):
         super().__init__(*args, **kwargs)
 
         if tipo_escala == "estructurada":
+            use_tags = self.available_struture_tags[f"{longitud}"]
             for i in range(longitud):
-                self.fields[f'segmento_{i+1}'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), required=True, label=f"segmento {i+1}", empty_label="Selecione opcion", widget=forms.Select(attrs={
-                    "class":"ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
+                self.fields[f'segmento_{i+1}'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), initial=Etiqueta.objects.get(valor_etiqueta=use_tags[i]), required=True, label=f"segmento {i+1}", empty_label="Selecione opcion", widget=forms.Select(attrs={
+                    "class": "ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
                 }))
         else:
-            self.fields['punto_inicial'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), required=True, label="Punto inicial", empty_label="Selecione opcion", widget=forms.Select(attrs={
-                    "class":"ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
-                }))
-            
-            self.fields['punto_medio'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), required=True, label="Punto medio", empty_label="Selecione opcion", widget=forms.Select(attrs={
-                    "class":"ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
-                }))
-            
-            self.fields['punto_final'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), required=True, label="Punto final", empty_label="Selecione opcion", widget=forms.Select(attrs={
-                    "class":"ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
-                }))
+            self.fields['punto_inicial'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), initial=Etiqueta.objects.get(valor_etiqueta="percepcion nula"), required=True, label="Punto inicial", empty_label="Selecione opcion", widget=forms.Select(attrs={
+                "class": "ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
+            }))
+
+            self.fields['punto_medio'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), initial=Etiqueta.objects.get(valor_etiqueta="se puede percibir"), required=True, label="Punto medio", empty_label="Selecione opcion", widget=forms.Select(attrs={
+                "class": "ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
+            }))
+
+            self.fields['punto_final'] = forms.ModelChoiceField(queryset=Etiqueta.objects.all(), initial=Etiqueta.objects.get(valor_etiqueta="percepcion total"), required=True, label="Punto final", empty_label="Selecione opcion", widget=forms.Select(attrs={
+                "class": "ct-select-op p-1 max-sm:w-full bg-surface-ligt [*]:capitalize"
+            }))

tecnicas/middlewares/presenter_middleware.py

@@ -1,18 +1,17 @@
-from django.core.exceptions import PermissionDenied
-
 class PresenterAccessMiddleware:
     def __init__(self, get_response):
         self.get_response = get_response
 
     def __call__(self, request):
         path = request.path_info
-        
+
         if path.startswith('/cata/presenter/'):
             if not request.user.is_authenticated:
                 from django.shortcuts import redirect
                 return redirect("cata_system:autenticacion")
 
             if not hasattr(request.user, 'user_presentador'):
+                from django.shortcuts import redirect
                 return redirect("cata_system:autenticacion")
 
         return self.get_response(request)

tecnicas/middlewares/tester_middleware.py

@@ -9,38 +9,13 @@ class TesterAccessMiddleware:
     def __call__(self, request):
         path = request.path_info
 
-        if path.startswith('/cata/tester/'):
+        if path.startswith('/cata/testers/'):
             if not request.user.is_authenticated:
                 from django.shortcuts import redirect
                 return redirect("cata_system:catador_login")
 
-            if not hasattr(request.user, 'catador'):
+            if not hasattr(request.user, 'user_catador'):
+                from django.shortcuts import redirect
                 return redirect("cata_system:catador_login")
 
         return self.get_response(request)
-
-# from django.http import HttpRequest
-
-
-# class LoginTesterMiddleware():
-#     def __init__(self, get_response):
-#         self.get_response = get_response
-
-#     def __call__(self, req: HttpRequest):
-#         base_url_protected = "/cata/testers/"
-
-#         if req.path.startswith(base_url_protected):
-#             if not "cata_username" in req.session:
-#                 id_participacion = req.COOKIES.get("id_participacion")
-#                 if id_participacion:
-#                     from tecnicas.controllers import ParticipacionController
-#                     ParticipacionController.outSession(id_participacion)
-#                 from django.shortcuts import redirect
-#                 from django.urls import reverse
-#                 response = redirect(reverse("cata_system:catador_login"))
-#                 response.delete_cookie("id_participacion")
-#                 return response
-
-#         response = self.get_response(req)
-
-#         return response

tecnicas/models/participacion.py

@@ -12,4 +12,4 @@ class Participacion(models.Model):
     finalizado = models.BooleanField(default=True)
 
     def __str__(self):
-        return f"{self.catador.usuarioCatador} {'activo' if self.activo else 'no activo'}"
+        return f"{self.catador.user.username} {'activo' if self.activo else 'no activo'}"

tecnicas/models/sesion_sensorial.py

@@ -17,4 +17,9 @@ class SesionSensorial(models.Model):
         Tecnica, on_delete=models.CASCADE, related_name="sesion_tecnica")
 
     def __str__(self):
-        return self.nombre_sesion if self.nombre_sesion else self.codigo_sesion
+        name_str = f"{self.codigo_sesion}"
+
+        if self.nombre_sesion:
+            name_str += f" : {self.nombre_sesion}"
+        
+        return name_str

tecnicas/static/js/catador-craete.js

@@ -7,7 +7,6 @@ for (let index = 0; index < inputs.length; index++) {
 
 function hiddenErrorAndMessages(e) {
   for (let index = 0; index < notifiactions.length; index++) {
-    console.log("Oculto");
     notifiactions.item(index).classList.add("hidden");
   }
 }

tecnicas/static/js/create-session.js

@@ -90,7 +90,7 @@ function renderElementsResponse({
   ];
 
   const aIndex = document.createElement("a");
-  aIndex.href = "/cata";
+  aIndex.href = "/cata/presenter/";
   aIndex.textContent = "Volver al inicio";
 
   aIndex.classList.add(
@@ -99,7 +99,7 @@ function renderElementsResponse({
   );
 
   const aDetails = document.createElement("a");
-  aDetails.href = `/cata/detalles-sesion/${sessionId}`;
+  aDetails.href = `/cata/presenter/detalles-sesion/${sessionId}`;
   aDetails.textContent = "Ver detalles la sesion";
 
   aDetails.classList.add(

tecnicas/static/js/details-session.js

@@ -4,23 +4,17 @@ const notificationError = document.querySelector(".ct-notification-error");
 if (notificationError) {
   setTimeout(function () {
     notificationError.classList.add("hidden");
-  }, 2000);
+  }, 3000);
 }
 
 function startRepetition() {
-  const inputAction = document.createElement("input");
-  inputAction.type = "hidden";
-  inputAction.name = "action";
-  inputAction.value = "start_session";
-
-  const inputUser = document.createElement("input");
-  inputUser.type = "hidden";
-  inputUser.name = "username";
-  inputUser.value = "aguBido";
-
-  actionForm.appendChild(inputAction);
-  actionForm.appendChild(inputUser);
-
-  actionForm.classList.remove("hidden");
+  const input = actionForm.querySelector(".action-option")
+  input.value = "start_session";
   actionForm.submit();
 }
+
+function deleteSession() {
+  const input = actionForm.querySelector(".action-option")
+  input.value = "delete_session";
+  actionForm.submit();
+}

tecnicas/static/js/panel-basic.js

@@ -1,6 +1,6 @@
 const descriptons = {
-  estructurada: ["Establece número de segmentos:", "Puede ser 5, 7 o 9"],
-  continua: ["Establece la longitud de la escala:", "Puede ser 9, 12 o 15"],
+  estructurada: "Establece número de segmentos:",
+  continua: "Establece la longitud de la escala:",
   atributos:
     "Con el estilo atributos elijes las palabras para evaluar los productos",
   vocabulario:
@@ -12,6 +12,11 @@ let inputTamano;
 
 let inputsStyle;
 let helpStyle;
+let sizeOptionsContainer;
+const SIZE_OPTIONS = {
+  estructurada: [5, 7, 9],
+  continua: [9, 13, 15],
+};
 
 initPanel();
 
@@ -22,6 +27,7 @@ function initPanel() {
 function initRadios() {
   inputsScale = document.getElementsByName("tipo_escala");
   inputTamano = document.getElementsByName("tamano_escala").item(0);
+  sizeOptionsContainer = document.getElementsByClassName("cts-options-size-scale")[0];
 
   for (let index = 0; index < inputsScale.length; index++) {
     let parent = inputsScale.item(index).parentElement;
@@ -46,6 +52,73 @@ function initRadios() {
       showDescriptionStyle(parent);
     }
   }
+
+  initSizeOptions();
+}
+
+function initSizeOptions() {
+  for (let i = 0; i < inputsScale.length; i++) {
+    const radio = inputsScale.item(i);
+    radio.addEventListener('change', () => {
+      const tag = getTagFromLabel(radio);
+      populateSizeOptions(tag);
+    });
+    if (radio.checked) {
+      const tag = getTagFromLabel(radio);
+      populateSizeOptions(tag);
+    }
+  }
+
+  const form = document.querySelector('form');
+  if (!form) return;
+
+  form.addEventListener('submit', (e) => {
+    const chosen = document.querySelector('input[name="option_size_scale"]:checked');
+    if (chosen && inputTamano) {
+      inputTamano.value = chosen.value;
+    }
+
+    if (sizeOptionsContainer) {
+      const toRemove = sizeOptionsContainer.querySelectorAll('input[name="option_size_scale"]');
+      toRemove.forEach((el) => el.remove());
+    }
+  });
+}
+
+function getTagFromLabel(radio) {
+  try {
+    const parent = radio.parentElement;
+    if (!parent) return '';
+    const text = parent.textContent || '';
+    return text.trim().split(/\s+/)[0].toLowerCase();
+  } catch (err) {
+    return '';
+  }
+}
+
+function populateSizeOptions(tag) {
+  const options = SIZE_OPTIONS[tag] || SIZE_OPTIONS['estructurada'];
+  if (!sizeOptionsContainer) return;
+  sizeOptionsContainer.innerHTML = '';
+
+  options.forEach((val) => {
+    const label = document.createElement('label');
+    label.className = 'flex flex-col items-center cursor-pointer';
+
+    const input = document.createElement('input');
+    input.type = 'radio';
+    input.name = 'option_size_scale';
+    input.value = String(val);
+    input.className = 'radio radio-lg checked:bg-pink-500';
+
+    const span = document.createElement('span');
+    span.className = 'mt-2 text-xl text-gray-700 font-medium';
+    span.textContent = String(val);
+
+    label.appendChild(input);
+    label.appendChild(span);
+    sizeOptionsContainer.appendChild(label);
+  });
 }
 
 function showDescriptionStyle(label) {
@@ -56,6 +129,5 @@ function showDescriptionStyle(label) {
 function showDescriptionTamanoScale(label) {
   const text = label.textContent.trim();
   let parent = inputTamano.parentElement;
-  parent.getElementsByTagName("p")[0].textContent = descriptons[text][0];
-  inputTamano.placeholder = descriptons[text][1];
+  parent.getElementsByTagName("p")[0].textContent = descriptons[text];
 }

tecnicas/static/js/panel-words.js

@@ -28,7 +28,7 @@ async function getWordsByName(e) {
     palabra: dataForm.get("search").trim(),
   });
 
-  const url = `api/palabras?${params}`;
+  const url = `/cata/api/palabras?${params}`;
 
   try {
     const respone = await fetch(url, {

tecnicas/static/js/showHiddenElement.js

@@ -0,0 +1,9 @@
+function hiddenWarningDialog(styleClass) {
+  const element = document.querySelector(`.${styleClass}`)
+  element.classList.add("hidden")
+}
+
+function showWarningDialog(styleClass) {
+  const element = document.querySelector(`.${styleClass}`)
+  element.classList.remove("hidden")
+}

tecnicas/templates/tecnicas/auth.html

@@ -26,7 +26,7 @@
                 </label>
 
                 <label for="password">
-                    <input type="text" name="password" id="password" placeholder="Ingrese Contraseña"
+                    <input type="password" name="password" id="password" placeholder="Ingrese Contraseña"
                         class="placeholder:text-gray-400 placeholder:font-semibold text-xl max-sm:text-base bg-surface-ligt py-3 px-6 rounded-xl lg:w-sm border-b-2 border-surface-sweet"
                         required>
                 </label>

tecnicas/templates/tecnicas/cata-login.html

@@ -13,23 +13,15 @@
             </header>
 
             {% if error %}
-            <article class="bg-ct-error p-4 text-white rounded-xl ct-notification-error">
-                <p
-                    class="block font-sans text-white text-xl antialiased font-bold uppercase tracking-wider text-center">
-                    {{ error }}
-                </p>
-            </article>
+            {% include "./components/error-message.html" with message=error %}
+            {% endif %}
+            {% if message %}
+            {% include "./components/error-message.html" with message=message %}
             {% endif %}
 
             <article class="flex flex-col gap-6 items-center w-full mt-5">
-                <label for="id">
-                    <input type="text" name="code_session" id="id" placeholder="Codigo de sesion"
-                        class="placeholder:text-gray-400 placeholder:font-semibold text-xl max-sm:text-base bg-surface-ligt py-3 px-6 rounded-xl lg:w-sm border-b-2 border-surface-sweet"
-                        required>
-                </label>
-
-                <label for="id">
-                    <input type="text" name="user_tester" id="id" placeholder="Nombre de usuario"
+                <label for="tester">
+                    <input type="text" name="user_tester" id="tester" placeholder="Nombre de usuario"
                         class="placeholder:text-gray-400 placeholder:font-semibold text-xl max-sm:text-base bg-surface-ligt py-3 px-6 rounded-xl lg:w-sm border-b-2 border-surface-sweet"
                         required>
                 </label>
@@ -44,15 +36,4 @@
         </form>
     </article>
 </article>
-{% endblock %}
-
-{% block extra_js %}
-<script>
-    const error = document.querySelector(".ct-notification-error")
-    if (error) {
-        setTimeout(() => {
-            error.classList.add("hidden")
-        }, 4000)
-    }
-</script>
 {% endblock %}

tecnicas/templates/tecnicas/components/item-tester.html

@@ -0,0 +1,39 @@
+<div
+    class="card w-full min-w-2xs max-w-sm bg-surface-ligt shadow-md hover:shadow-lg transition-shadow duration-300 text-black">
+    <div class="card-body">
+        <h2 class="text-center text-lg font-bold bg-surface-sweet rounded">
+            {{ tester.user.first_name }} {{ tester.user.last_name }}
+        </h2>
+        <p class="text-lg text-center bg-surface-alter-card rounded px-2">
+            <span class="font-bold">Usuario: </span>
+            {{ tester.user.username }}
+        </p>
+
+        <div class="w-full text-base flex gap-2 flex-wrap text-center">
+            <p class="font-semibold bg-btn-secondary rounded text-white p-1">
+                <span class="font-bold">Genero:</span>
+                {{ tester.genero }}
+            </p>
+            <p class="font-semibold bg-btn-secondary rounded text-white p-1">
+                <span class="font-bold">Teléfono: </span>
+                {{ tester.telefono }}
+            </p>
+            <p class="font-semibold bg-btn-secondary rounded text-white p-1">
+                <span class="font-bold">Email: </span>
+                {{ tester.user.email }}
+            </p>
+            <p class="font-semibold bg-btn-secondary rounded text-white p-1">
+                <span class="font-bold">Nacimiento: </span>
+                {{ tester.nacimiento|date:"d/m/Y" }}
+            </p>
+        </div>
+
+        <div class="card-actions justify-end mt-3">
+            <a href="{% url 'cata_system:buscar_catador' %}?user={{ tester.user.username }}" class="w-full">
+                <button class="btn bg-btn-primary border-0 block w-full btn-push">
+                    Actualizar datos
+                </button>
+            </a>
+        </div>
+    </div>
+</div>

tecnicas/templates/tecnicas/components/item_session.html

@@ -0,0 +1,47 @@
+<div
+    class='card {{ sesion.activo|yesno:"bg-surface-ligt,bg-surface-card" }} shadow-lg text-black sm:max-w-80 w-full flex justify-center items-center'>
+    <div class="card-body flex flex-col justify-between w-full">
+        <div class="flex flex-col gap-1 [&>*]:first:text-xl [&>*]:first:font-bold [&>*]:first:border-b">
+            {% if sesion.nombre_sesion %}
+            <h2>{{ sesion.nombre_sesion }}</h2>
+            <span class="text-lg underline"><b>Código:</b><br>{{ sesion.codigo_sesion }}</span>
+            {% else %}
+            <span class="text-lg">Código:<br>{{ sesion.codigo_sesion }}</span>
+            {% endif %}
+        </div>
+        <ul class="mt-6 flex flex-col gap-2 text-base">
+            <li>
+                Se usa la Técnica:
+                <span class="uppercase font-bold">
+                    {{ sesion.tecnica.tipo_tecnica.nombre_tecnica }}
+                </span>
+            </li>
+            <li>
+                El Estilo de palabras:
+                <span class="uppercase font-bold">
+                    {{ sesion.tecnica.id_estilo.nombre_estilo }}
+                </span>
+            </li>
+            <li>
+                {{ sesion.fechaCreacion }}
+            </li>
+            <li>
+                Estado:
+                <span class="uppercase font-bold">
+                    {% if sesion.activo %}
+                    Activo
+                    {% else %}
+                    No activo
+                    {% endif %}
+                </span>
+            </li>
+        </ul>
+        <div class="mt-6">
+            <a href="{% url 'cata_system:detalles_sesion' session_code=sesion.codigo_sesion %}">
+                <button class="btn bg-btn-primary border-0 block w-full btn-push">
+                    Inspeccionar sesión
+                </button>
+            </a>
+        </div>
+    </div>
+</div>

tecnicas/templates/tecnicas/components/item_session_tester.html

@@ -0,0 +1,40 @@
+<div class="card bg-surface-sweet border border-base-300 shadow-md hover:shadow-lg transition">
+    <div class="card-body space-y-4">
+        <h4 class="card-title text-lg font-bold">
+            {% if session.nombre_sesion %}
+            {{ session.nombre_sesion }}
+            {% else %}
+            <span class="italic text-gray-500">Sin nombre</span>
+            {% endif %}
+        </h4>
+
+        <article class="text-sm space-y-1">
+            <p><span class="font-semibold">Código:</span> {{ session.codigo_sesion }}</p>
+            <p><span class="font-semibold">Técnica:</span> {{ session.tecnica.tipo_tecnica }}</p>
+            <p><span class="font-semibold">Fecha:</span> {{ session.fechaCreacion }}</p>
+            <p>
+                <span class="font-semibold">Finazliado:</span>
+                {% if session.participacion_finalizado %}
+                <span class="badge badge-success">Se ha concluido</span>
+                {% else %}
+                <span class="badge badge-warning">Sin concluir</span>
+                {% endif %}
+            </p>
+            <p>
+                <span class="font-semibold">Estatus:</span>
+                {% if session.activo %}
+                <span class="badge badge-success">En proceso</span>
+                {% else %}
+                <span class="badge badge-error">No activo</span>
+                {% endif %}
+            </p>
+        </article>
+        <article>
+            <a href="{% url 'cata_system:catador_init_session' code_sesion=session.codigo_sesion %}">
+                <button class="btn bg-btn-primary border-0 block w-full btn-push">
+                    Inspeccionar
+                </button>
+            </a>
+        </article>
+    </div>
+</div>

tecnicas/templates/tecnicas/components/table-convencional.html

@@ -23,7 +23,6 @@
                         {% with match=None %}
                         {% for valor in valores %}
                         {% if valor.nombre_palabra == palabra %}
-                        {{ palabra }} <br>
                         {{ valor.dato_valor }}
                         {% with match=True %}{% endwith %}
                         {% endif %}

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-basic.html

@@ -13,8 +13,8 @@
         <hr>
         <form method="post" action="" class="[&>article]:not-last:mb-4 [&>article]:not-first:pt-4 [&>article]:px-6">
             {% csrf_token %}
-            <label for="form_sesion.id_tecnica.id_for_label" class="hidden">
-                {{ form_sesion.id_tecnica }}
+            <label for="form_sesion.name_tecnica.id_for_label" class="hidden">
+                {{ form_sesion.name_tecnica }}
             </label>
 
             <article>
@@ -26,20 +26,45 @@
                         {{ form_sesion.nombre_sesion }}
                     </label>
                 </section>
-                <section
-                    class="flex flex-row flex-wrap justify-center gap-4 [&>label]:text-lg [&>label]:flex [&>label]:flex-col [&>label]:items-center [&>label]:px-2 [&>label]:font-medium [&>label]:tracking-wide [&>label]:[&>p]:tracking-normal [&>label]:[&>p]:text-base [&>label]:[&>p]:font-bold">
-                    <label for="{{ form_sesion.numero_productos.id_for_label }}">
-                        <p>Número de Productos:</p>
+                <section class="flex flex-row flex-wrap justify-center gap-4">
+                    <label for="{{ form_sesion.numero_productos.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Productos:
+                        </p>
                         {{ form_sesion.numero_productos }}
                     </label>
-                    <label for="{{ form_sesion.numero_catadores.id_for_label }}">
-                        <p>Número de Catadores:</p>
+                    {% if use_technique == 'escalas' %}
+                    <label for="{{ form_sesion.numero_catadores.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Catadores:
+                        </p>
                         {{ form_sesion.numero_catadores }}
                     </label>
-                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}">
-                        <p>Número de Repeticiones:</p>
+                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                    <p class="tracking-normal text-base font-bold">
+                        Número de Repeticiones:
+                    </p>
+                    {{ form_sesion.numero_repeticiones }}
+                    </label>
+                    {% else %}
+                    <label for="{{ form_sesion.numero_catadores.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide hidden">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Catadores:
+                        </p>
+                        {{ form_sesion.numero_catadores }}
+                    </label>
+                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide hidden">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Repeticiones:
+                        </p>
                         {{ form_sesion.numero_repeticiones }}
                     </label>
+                    {% endif %}
                 </section>
                 <section class="flex justify-center items-center mt-2">
                     <label for="{{form_sesion.instrucciones.id_for_label}}"
@@ -93,6 +118,23 @@
                         <p>Establece número de segmentos:</p>
                         {{ form_sesion.tamano_escala }}
                     </label>
+                    <div class="flex justify-around max-sm:flex-col gap-8 cts-options-size-scale">
+                        <label class="flex flex-col items-center cursor-pointer">
+                            <input type="radio" name="option_size_scale" value="5"
+                                class="radio radio-lg checked:bg-pink-500" />
+                            <span class="mt-2 text-xl text-gray-700 font-medium">5</span>
+                        </label>
+                        <label class="flex flex-col items-center cursor-pointer">
+                            <input type="radio" name="option_size_scale" value="7"
+                                class="radio radio-lg checked:bg-pink-500" />
+                            <span class="mt-2 text-xl text-gray-700 font-medium">7</span>
+                        </label>
+                        <label class="flex flex-col items-center cursor-pointer">
+                            <input type="radio" name="option_size_scale" value="9"
+                                class="radio radio-lg checked:bg-pink-500" />
+                            <span class="mt-2 text-xl text-gray-700 font-medium">9</span>
+                        </label>
+                    </div>
                     {% if form_sesion.tamano_escala.errors %}
                     <article
                         class="w-fit rounded px-2 py-0.5 text-center text-white text-sm font-medium tracking-wide bg-red-500">

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-codes.html

@@ -27,12 +27,15 @@
                     </label>
                     {% endfor %}
                 </article>
+                {% if use_technique == 'escalas' %}
                 <button type="button" class="cts-btn-general cts-btn-secondary btn-push uppercase"
                     onclick="setPermutations()">
                     regenerar ordenes
                 </button>
+                {% endif %}
             </article>
 
+            {% if use_technique == 'escalas' %}
             <h2 class="text-2xl mb-2 font-bold">Ordenes</h2>
             <hr>
             <article class="w-full">
@@ -42,6 +45,7 @@
                     </article>
                 </section>
             </article>
+            {% endif %}
 
             <hr>
             <article class="flex flex-col items-center gap-4">
@@ -62,11 +66,16 @@
                 </a>
             </article>
         </form>
+
+        {% if use_technique == 'escalas' %}
         <input type="number" value="{{ num_tester }}" class="ct-num-cata hidden" disabled>
+        {% endif %}
     </article>
 </article>
 {% endblock %}
 
 {% block extra_js %}
+{% if use_technique == 'escalas' %}
 <script src="{% static 'js/panel-codes.js' %}"></script>
+{% endif %}
 {% endblock %}

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-tags.html

@@ -19,7 +19,8 @@
                 <article class="p-4 flex flex-col gap-2 rounded max-sm:text-center">
                     <h2 class="text-2xl mb-2 font-bold">Seleccion de etiquetas</h2>
                     {% for field in form_tags %}
-                    <div class="flex max-sm:flex-col justify-center items-center gap-5 max-sm:gap-2 text-lg border-b-4 border-l-4 border-btn-secondary bg-surface-card p-1">
+                    <div
+                        class="flex max-sm:flex-col justify-center items-center gap-5 max-sm:gap-2 text-lg border-b-4 border-l-4 border-btn-secondary bg-surface-card p-1">
                         <label for="{{ field.id_for_label }}"
                             class="font-medium p-1 px-3 max-sm:w-full capitalize rounded">
                             {{ field.label }}
@@ -44,11 +45,10 @@
                         <button type="submit" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full">
                             Continuar
                         </button>
-                        <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
-                            <button type="button" class="cts-btn-general cts-btn-secondary btn-push w-full">
-                                Paso anterior
-                            </button>
-                        </a>
+                        <button type="button" class="cts-btn-general cts-btn-secondary btn-push w-full"
+                        onclick="window.history.back();">
+                            Paso anterior
+                        </button>
                     </section>
                     <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
                         <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
@@ -71,7 +71,8 @@
                     <p
                         class="ct-error-tag mt-4 font-bold bg-red-500 text-white text-md capitalize text-center rounded hidden">
                         error</p>
-                    <article class="flex max-sm:flex-col justify-center gap-8 max-sm:gap-4 mt-4 text-white font-medium tracking-wide">
+                    <article
+                        class="flex max-sm:flex-col justify-center gap-8 max-sm:gap-4 mt-4 text-white font-medium tracking-wide">
                         <button type="submit" class="cts-btn-general cts-btn-primary btn-push">
                             Agregar
                         </button>
@@ -89,20 +90,7 @@
 
 {% block extra_js %}
 <script src="{% static 'js/panel-tags.js' %}"></script>
+{% endblock %}
 
-{%if escala == "estructurada"%}
-<script>
-    for (let i = 0; i < options.length; i++) {
-        if (options.item(i).value) {
-            values.push(options.item(i).value)
-        }
-    }
-
-    values.sort()
-
-    for (let i = 0; i < values.length; i++) {
-        itemsSelects.item(i).value = values[i]
-    }
-</script>
-{% endif %}
-{% endblock %}
+<a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
+</a>

tecnicas/templates/tecnicas/create_sesion/seleccion-tecnica.html

@@ -33,7 +33,7 @@
                 <section
                     class="modal-list-{{ cate }} flex flex-col text-lg bg-surface-ligt p-4 pr-6 pl-8 sm:pl-12 z-10 -translate-y-1 rounded-b-2xl *:not-last:mb-4 transition-all duration-1000 hidden w-full">
                     {% for tecnica in tecnicas %}
-                    <a href="{% url 'cata_system:panel_configuracion_basic'%}?id_tecnica={{tecnica.id}}">
+                    <a href="{% url 'cata_system:panel_configuracion_basic'%}?name_tecnica={{ tecnica }}">
                         <button
                             class="cts-btn-secondary btn-push rounded-lg border-b-0 border-l-4 border-gray-700 px-3 py-2 w-full text-left font-bold uppercase">
                             {{ tecnica.nombre_tecnica }}

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -45,7 +45,7 @@
         </header>
 
         <article class="hidden">
-            <form action="{% url 'cata_system:catador_main' %}" method="post" class="form-actions">
+            <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>