Merge pull request #38 from CascoArcilla/HU3

Implementación de Sort, creacion de Napping, redefinicion de logica general y ajustes menores.

tecnicas/admin.py

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

tecnicas/controllers/__init__.py

@@ -16,18 +16,26 @@ from .views_controller.create_session.panel_basic_controller import PanelBasicCo
 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.details_cata_controller import DetallesCATAController
-from .views_controller.session_management.details_pf_controller import DetallesPFController
+from .views_controller.create_session.panels_create.panel_create_escalas_controller import PanelCreateEscalasController
+from .views_controller.create_session.panels_create.panel_create_rata_controller import PanelCreateRataController
+from .views_controller.create_session.panels_create.panel_create_cata_controller import PanelCreateCataController
+from .views_controller.create_session.panels_create.panel_create_pf_controller import PanelCreatePFController
+from .views_controller.create_session.panels_create.panel_create_sort_controller import PanelCreateSortController
+from .views_controller.create_session.panels_create.panel_create_napping_controller import PanelCreateNappingController
 
-from .views_controller.session_management.monitor_controller import MonitorController
-from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController
-from .views_controller.session_management.monitor_rata_controller import MonitorRATAController
-from .views_controller.session_management.monitor_pf_controller import MonitorPFController
+
+from .views_controller.session_management.details.details_controller import DetallesController
+from .views_controller.session_management.details.details_escala_controller import DetallesEscalasController
+from .views_controller.session_management.details.details_rata_controller import DetallesRATAController
+from .views_controller.session_management.details.details_cata_controller import DetallesCATAController
+from .views_controller.session_management.details.details_pf_controller import DetallesPFController
+from .views_controller.session_management.details.details_sort_controller import DetallesSortController
+
+from .views_controller.session_management.monitor.monitor_escalas_controller import MonitorEscalasController
+from .views_controller.session_management.monitor.monitor_rata_controller import MonitorRATAController
+from .views_controller.session_management.monitor.monitor_pf_controller import MonitorPFController
+from .views_controller.session_management.monitor.monitor_sort_controller import MonitorSortController
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
@@ -36,10 +44,12 @@ from .views_controller.sessions_tester.tests_forms.test_scales_controller import
 from .views_controller.sessions_tester.tests_forms.test_rata_controller import TestRataController
 from .views_controller.sessions_tester.tests_forms.test_cata_controller import TestCataController
 from .views_controller.sessions_tester.tests_forms.test_pf_controller import TestPFController
+from .views_controller.sessions_tester.tests_forms.test_sort_controller import TestSortController
 
 from .views_controller.sessions_tester.init_session.init_session_escalas_controller import InitSessionEscalasController
 from .views_controller.sessions_tester.init_session.init_session_rata_controller import InitSessionRATAController
 from .views_controller.sessions_tester.init_session.init_session_pf_controller import InitSessionPFController
+from .views_controller.sessions_tester.init_session.init_session_sort_controller import InitSessionSortController
 
 from .views_controller.vocabulary_manage.create_vocabulary_controller import CreateVocabularyController
 from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController
@@ -48,3 +58,4 @@ from .api_controller.rating_sacales_controller import RatingScalesController
 from .api_controller.rating_cata_controller import RatingCataController
 from .api_controller.rating_pf_list_controller import RatingPFListController
 from .views_controller.tester_list_controller import TesterListController
+from .api_controller.rating_sort_controller import RatingSortController

tecnicas/controllers/api_controller/rating_sort_controller.py

@@ -0,0 +1,67 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction
+from tecnicas.models import Participacion, Palabra, GrupoProducto, Producto
+
+
+class RatingSortController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def saveRating(request: HttpRequest, data: list[dict]):
+        try:
+            with transaction.atomic():
+                participation = Participacion.objects.get(
+                    id=request.session["id_participation"])
+
+                technique = participation.tecnica
+                catador = participation.catador
+
+                # Obtener productos de la técnica
+                technique_products = Producto.objects.filter(
+                    id_tecnica=technique)
+                technique_product_ids = set(p.id for p in technique_products)
+
+                # Recolectar IDs de productos enviados
+                sent_product_ids = set()
+                for group in data:
+                    for product in group["products"]:
+                        sent_product_ids.add(int(product["id"]))
+
+                # Validar que los productos enviados existan en la técnica
+                if not sent_product_ids.issubset(technique_product_ids):
+                    return JsonResponse({"error": "Productos enviados no pertenecen a la técnica"})
+
+                # Validar que todos los productos de la técnica estén presentes
+                if sent_product_ids != technique_product_ids:
+                    return JsonResponse({"error": "Faltan productos por clasificar"})
+
+                for group in data:
+                    words_data = group["words"]
+                    products_data = group["products"]
+
+                    # Crear u obtener palabras
+                    words_objs = []
+                    for word_name in words_data:
+                        word, created = Palabra.objects.get_or_create(nombre_palabra=word_name)
+                        words_objs.append(word)
+
+                    # Crear GrupoProducto
+                    group_product = GrupoProducto.objects.create(
+                        tecnica=technique,
+                        catador=catador
+                    )
+
+                    # Asignar palabras
+                    group_product.palabras.set(words_objs)
+
+                    # Asignar productos
+                    product_ids = [p["id"] for p in products_data]
+                    group_product.productos.set(product_ids)
+
+            return JsonResponse({"message": "Valores guardados"})
+        except Participacion.DoesNotExist:
+            return JsonResponse({"error": "Participación no encontrada"})
+        except Exception as e:
+            print(f"Error de calificacion: {e}")
+            return JsonResponse({"error": "Error al guardar los datos"})

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -16,7 +16,7 @@ class TecnicaController():
     def setTechniqueFromBasicData(self, basic):
         self.technique = Tecnica(
             tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=basic["name_tecnica"]),
-            id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
+            id_estilo=EstiloPalabra.objects.get(nombre_estilo=basic["estilo_palabras"]),
             repeticiones_max=basic["numero_repeticiones"] or 1,
             limite_catadores=basic["numero_catadores"],
             instrucciones=basic["instrucciones"] or "Espere instrucciones del Presentador",

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -1,4 +1,4 @@
-from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm, SesionBasicPFForm
+from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm, SesionBasicPFForm, SesionBasicSortForm, SesionBasicNappingForm
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
@@ -10,9 +10,11 @@ class PanelBasicController():
         "numero_repeticiones": 1
     }
 
-    url_panel_basic = "tecnicas/create_sesion/configuracion-panel-basic.html"
+    url_panel_basic = "tecnicas/create_sesion/conf-panel-basic.html"
     url_panel_basic_cata = "tecnicas/create_sesion/panel-basic-cata.html"
     url_panel_basic_pf = "tecnicas/create_sesion/panel-basic-pf.html"
+    url_panel_basic_sort = "tecnicas/create_sesion/panel-basic-sort.html"
+    url_panel_basic_napping = "tecnicas/create_sesion/panel-basic-napping.html"
 
     url_next_panel_tags = "cata_system:panel_configuracion_tags"
     url_next_panel_codes = "cata_system:panel_configuracion_codes"
@@ -43,7 +45,7 @@ class PanelBasicController():
             if form.is_valid():
                 values = {}
                 for name, value in form.cleaned_data.items():
-                    if name == "estilo_palabras" or name == "tipo_escala":
+                    if name == "tipo_escala":
                         values[name] = value.id
                     else:
                         values[name] = value
@@ -84,7 +86,7 @@ class PanelBasicController():
             if form.is_valid():
                 values = {}
                 for name, value in form.cleaned_data.items():
-                    if name == "estilo_palabras" or name == "tipo_escala":
+                    if name == "tipo_escala":
                         values[name] = value.id
                     else:
                         values[name] = value
@@ -132,10 +134,7 @@ class PanelBasicController():
         if form.is_valid():
             values = {}
             for name, value in form.cleaned_data.items():
-                if name == "estilo_palabras":
-                    values[name] = value.id
-                else:
-                    values[name] = value
+                values[name] = value
 
             values["name_tecnica"] = name_tecnica
             request.session['form_basic'] = values
@@ -164,7 +163,6 @@ class PanelBasicController():
         form = SesionBasicPFForm(request.POST)
 
         if form.is_valid():
-            print(form.cleaned_data)
             values = {}
             for name, value in form.cleaned_data.items():
                 values[name] = value
@@ -178,3 +176,65 @@ class PanelBasicController():
                 "form_sesion": form, "error": "Información no valida"})
 
         return response
+
+    @staticmethod
+    def controllGetSort(request: HttpRequest):
+        form_sesion = SesionBasicSortForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "sort"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_sort, view_context)
+
+    @staticmethod
+    def controllPostSort(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicSortForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_sort, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response
+
+    @staticmethod
+    def controllGetNapping(request: HttpRequest):
+        form_sesion = SesionBasicNappingForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "napping"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_napping, view_context)
+
+    @staticmethod
+    def controllPostNapping(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicNappingForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_napping, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -7,7 +7,7 @@ import json
 
 
 class PanelCodesController():
-    url_current_panel = "tecnicas/create_sesion/configuracion-panel-codes.html"
+    url_current_panel = "tecnicas/create_sesion/conf-panel-codes.html"
     url_words = "cata_system:panel_configuracion_words"
     url_create_session = "cata_system:creando_sesion"
 
@@ -66,7 +66,7 @@ class PanelCodesController():
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllGetRATA(request: HttpRequest, data, name_technique: str):
+    def controllGetWithoutOrders(request: HttpRequest, data, name_technique: str):
         num_products = data["numero_productos"]
         codes_products = generarCodigos(num_products)
         form_codes = CodesForm(codes=codes_products)
@@ -80,7 +80,7 @@ class PanelCodesController():
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllPostRATA(request: HttpRequest, is_rata=True):
+    def controllPostWithWords(request: HttpRequest, name_technique: str):
         codes = []
         context_codes_form = {}
 
@@ -92,7 +92,7 @@ class PanelCodesController():
 
         context_codes_form = {
             "form_codes": form_codes,
-            "use_technique": "rata" if is_rata else "cata"
+            "use_technique": name_technique
         }
 
         if form_codes.is_valid():
@@ -117,7 +117,7 @@ class PanelCodesController():
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllPostPF(request: HttpRequest):
+    def controllPostWithoutOrdersWords(request: HttpRequest, name_technique: str):
         codes = []
         context_codes_form = {}
 
@@ -129,7 +129,7 @@ class PanelCodesController():
 
         context_codes_form = {
             "form_codes": form_codes,
-            "use_technique": "perfil flash"
+            "use_technique": name_technique
         }
 
         if form_codes.is_valid():

tecnicas/controllers/views_controller/create_session/panel_tags_controller.py

@@ -25,7 +25,7 @@ class PanelTagsController():
             "form_new_tag": form_new_etiqueta
         }
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+        return render(request, "tecnicas/create_sesion/conf-panel-tags.html", context_tags)
 
     @staticmethod
     def controllPostEscalas(request: HttpRequest, data):
@@ -54,7 +54,7 @@ class PanelTagsController():
         else:
             context_tags["error"] = "ha ocurrido un error"
             response = render(
-                request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+                request, "tecnicas/create_sesion/conf-panel-tags.html", context_tags)
 
         return response
 

tecnicas/controllers/views_controller/create_session/panel_words_controller.py

@@ -7,7 +7,7 @@ import json
 
 
 class PanelWordsController():
-    current_url_escalas_atribute = "tecnicas/create_sesion/configuracion-panel-words.html"
+    current_url_escalas_atribute = "tecnicas/create_sesion/conf-panel-words.html"
     current_url_escalas_vocabulary = "tecnicas/create_sesion/conf-panel-vocabulary.html"
 
     def __init__(self):

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_cata_controller.py

@@ -0,0 +1,137 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import EsVocabulario, Tecnica, TipoTecnica, EstiloPalabra, EsAtributo, Vocabulario, Palabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateCataController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if 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")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = 0
+                    data_basic["numero_repeticiones"] = 1
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo=data_basic["estilo_palabras"]),
+                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+
+                    if style_words == "atributos":
+                        raw_ids_words = request.session["form_words"]
+                        ids_words = [int(id_w) for id_w in raw_ids_words]
+
+                        words = Palabra.objects.filter(id__in=ids_words)
+
+                        style_atribute = EsAtributo.objects.create(
+                            id_tecnica=technique
+                        )
+
+                        if not style_atribute:
+                            raise ValueError(
+                                "Error al intentar relacionar las palabras con la técnica")
+
+                        style_atribute.palabras.set(words)
+
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        try:
+                            vocabulary = Vocabulario.objects.get(
+                                nombre_vocabulario=name_vocabulary)
+                        except Vocabulario.DoesNotExist:
+                            raise ValueError("Vocabulario no encontrado")
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                        if not es_vocabulary:
+                            raise ValueError(
+                                "Error al intentar relacionar el vocabulario con la técnica")
+
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_controller.py

@@ -0,0 +1,17 @@
+from django.http import JsonResponse, HttpRequest
+from django.shortcuts import render
+
+class PanelCreateController():
+    url_template = 'tecnicas/create_sesion/creating_session.html'
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGet(request: HttpRequest):
+        return render(
+            request, PanelCreateController.url_template)
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/controllers/views_controller/create_session/{panel_create_controller.py → panels_create/panel_create_escalas_controller.py}

@@ -1,23 +1,17 @@
+from .panel_create_controller import PanelCreateController
 from django.http import HttpRequest, JsonResponse
 from django.db import transaction
-from django.shortcuts import render
-from tecnicas.utils import general_error
-from tecnicas.models import EsAtributo, EsVocabulario, Vocabulario, Tecnica, TipoTecnica, EstiloPalabra, Producto, Palabra, SesionSensorial, Escala, TipoEscala, EtiquetasEscala
-from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
-from tecnicas.utils import deleteDataSession
+from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, PalabrasController, EstiloPalabrasController, SesionController
+from tecnicas.models import EsVocabulario, Vocabulario
+from tecnicas.utils import deleteDataSession, general_error
 
 
-class PanelCreateController():
+class PanelCreateEscalasController(PanelCreateController):
     def __init__(self):
-        pass
+        super().__init__()
 
     @staticmethod
-    def controllGetEscalas(request: HttpRequest):
-        return render(
-            request, 'tecnicas/create_sesion/creando_sesion.html')
-
-    @staticmethod
-    def controllPostEscalas(request: HttpRequest):
+    def controllPost(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)
@@ -173,368 +167,3 @@ class PanelCreateController():
                 return general_error(f"Error: {e}")
         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")
-            try:
-                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
-
-                    technique = Tecnica.objects.create(
-                        tipo_tecnica=TipoTecnica.objects.get(
-                            nombre_tecnica=data_basic["name_tecnica"]),
-                        id_estilo=EstiloPalabra.objects.get(
-                            id=data_basic["estilo_palabras"]),
-                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
-                        limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
-                    )
-
-                    if not technique:
-                        raise ValueError("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):
-                        raise ValueError(scale["error"])
-
-                    dict_tags = request.session["form_tags"]
-                    saved_related_tags = controllerScale.realteTags(dict_tags)
-                    if "error" in saved_related_tags:
-                        raise ValueError(saved_related_tags["error"])
-
-                    # ////////////////////////////////////////////// #
-                    #
-                    # Second step: Create productos with their codes #
-                    #
-                    # ////////////////////////////////////////////// #
-                    codes = request.session["form_codes"]
-
-                    if not codes:
-                        raise ValueError("No hay códigos de productos")
-
-                    products_without_save = []
-                    for code in codes:
-                        product = Producto(
-                            codigoProducto=code,
-                            id_tecnica=technique
-                        )
-                        products_without_save.append(product)
-
-                    Producto.objects.bulk_create(products_without_save)
-
-                    # /////////////////////////////////////////////////////// #
-                    #
-                    # Third step: Create relations technique with Words Style #
-                    #
-                    # /////////////////////////////////////////////////////// #
-                    style_words = technique.id_estilo.nombre_estilo
-
-                    if style_words == "atributos":
-                        raw_ids_words = request.session["form_words"]
-                        ids_words = [int(id_w) for id_w in raw_ids_words]
-
-                        words = Palabra.objects.filter(id__in=ids_words)
-
-                        style_atribute = EsAtributo.objects.create(
-                            id_tecnica=technique
-                        )
-
-                        if not style_atribute:
-                            raise ValueError(
-                                "Error al intentar relacionar las palabras con la técnica")
-
-                        style_atribute.palabras.set(words)
-
-                    elif style_words == "vocabulario":
-                        name_vocabulary = request.session["form_words"]
-                        try:
-                            vocabulary = Vocabulario.objects.get(
-                                nombre_vocabulario=name_vocabulary)
-                        except Vocabulario.DoesNotExist:
-                            raise ValueError("Vocabulario no encontrado")
-
-                        es_vocabulary = EsVocabulario.objects.create(
-                            id_tecnica=technique,
-                            id_vocabulario=vocabulary
-                        )
-                        if not es_vocabulary:
-                            raise ValueError(
-                                "Error al intentar relacionar el vocabulario con la técnica")
-
-                    else:
-                        raise ValueError("Estilo de palabas no permitido")
-
-                    # //////////////////////////////////////////////////////// #
-                    #
-                    # Fourth step: Create session and relat with the technique #
-                    #
-                    # //////////////////////////////////////////////////////// #
-                    session = SesionSensorial.objects.create(
-                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else "",
-                        tecnica=technique,
-                        creadoPor=request.user.user_presentador
-                    )
-
-                    if not session:
-                        raise ValueError("Error al crear sesion sensorial")
-
-                    context = {
-                        "message": "sesión creada",
-                        "data": {
-                            "codigo_sesion": session.codigo_sesion,
-                            "nombre_sesion": session.nombre_sesion
-                        }
-                    }
-
-                    # ////////////////////////////////// #
-                    #
-                    # Final step: Delete date en session #
-                    #
-                    # ////////////////////////////////// #
-
-                    deleteDataSession(request)
-                    return JsonResponse(context)
-            except ValueError as e:
-                return general_error(f"Error: {e}")
-        else:
-            return general_error("No se ha establecido acción")
-
-    @staticmethod
-    def controllPostCATA(request: HttpRequest):
-        if request.POST.get('action') == 'create_session':
-            if 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")
-            try:
-                with transaction.atomic():
-                    # //////////////////////////// #
-                    #
-                    # First step: Create technique #
-                    #
-                    # //////////////////////////// #
-                    data_basic = request.session["form_basic"]
-                    data_basic["numero_catadores"] = 0
-                    data_basic["numero_repeticiones"] = 1
-
-                    technique = Tecnica.objects.create(
-                        tipo_tecnica=TipoTecnica.objects.get(
-                            nombre_tecnica=data_basic["name_tecnica"]),
-                        id_estilo=EstiloPalabra.objects.get(
-                            id=data_basic["estilo_palabras"]),
-                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
-                        limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
-                    )
-
-                    if not technique:
-                        raise ValueError("Error al guardar la técnica")
-
-                    # ////////////////////////////////////////////// #
-                    #
-                    # Second step: Create productos with their codes #
-                    #
-                    # ////////////////////////////////////////////// #
-                    codes = request.session["form_codes"]
-
-                    if not codes:
-                        raise ValueError("No hay códigos de productos")
-
-                    products_without_save = []
-                    for code in codes:
-                        product = Producto(
-                            codigoProducto=code,
-                            id_tecnica=technique
-                        )
-                        products_without_save.append(product)
-
-                    Producto.objects.bulk_create(products_without_save)
-
-                    # /////////////////////////////////////////////////////// #
-                    #
-                    # Third step: Create relations technique with Words Style #
-                    #
-                    # /////////////////////////////////////////////////////// #
-                    style_words = technique.id_estilo.nombre_estilo
-
-                    if style_words == "atributos":
-                        raw_ids_words = request.session["form_words"]
-                        ids_words = [int(id_w) for id_w in raw_ids_words]
-
-                        words = Palabra.objects.filter(id__in=ids_words)
-
-                        style_atribute = EsAtributo.objects.create(
-                            id_tecnica=technique
-                        )
-
-                        if not style_atribute:
-                            raise ValueError(
-                                "Error al intentar relacionar las palabras con la técnica")
-
-                        style_atribute.palabras.set(words)
-
-                    elif style_words == "vocabulario":
-                        name_vocabulary = request.session["form_words"]
-                        try:
-                            vocabulary = Vocabulario.objects.get(
-                                nombre_vocabulario=name_vocabulary)
-                        except Vocabulario.DoesNotExist:
-                            raise ValueError("Vocabulario no encontrado")
-
-                        es_vocabulary = EsVocabulario.objects.create(
-                            id_tecnica=technique,
-                            id_vocabulario=vocabulary
-                        )
-                        if not es_vocabulary:
-                            raise ValueError(
-                                "Error al intentar relacionar el vocabulario con la técnica")
-
-                    else:
-                        raise ValueError("Estilo de palabas no permitido")
-
-                    # //////////////////////////////////////////////////////// #
-                    #
-                    # Fourth step: Create session and relat with the technique #
-                    #
-                    # //////////////////////////////////////////////////////// #
-                    session = SesionSensorial.objects.create(
-                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                        tecnica=technique,
-                        creadoPor=request.user.user_presentador
-                    )
-
-                    if not session:
-                        raise ValueError("Error al crear sesion sensorial")
-
-                    context = {
-                        "message": "sesión creada",
-                        "data": {
-                            "codigo_sesion": session.codigo_sesion,
-                            "nombre_sesion": session.nombre_sesion
-                        }
-                    }
-
-                    # ////////////////////////////////// #
-                    #
-                    # Final step: Delete date en session #
-                    #
-                    # ////////////////////////////////// #
-                    deleteDataSession(request)
-                    return JsonResponse(context)
-
-            except ValueError as e:
-                return general_error(f"Error: {e}")
-        else:
-            return general_error("No se ha establecido acción")
-
-    @staticmethod
-    def controllPostPF(request: HttpRequest):
-        if request.POST.get('action') == 'create_session':
-            if not request.session.get("form_codes"):
-                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")
-            try:
-                with transaction.atomic():
-                    # ////////////////////////////////////// #
-                    #
-                    # First step: Create technique and scale #
-                    #
-                    # ////////////////////////////////////// #
-                    data_basic = request.session["form_basic"]
-                    phases_before_reptition = 2
-
-                    technique = Tecnica.objects.create(
-                        tipo_tecnica=TipoTecnica.objects.get(
-                            nombre_tecnica=data_basic["name_tecnica"]),
-                        id_estilo=EstiloPalabra.objects.get(
-                            nombre_estilo="vocabulario"),
-                        repeticiones_max=data_basic["numero_repeticiones"] + phases_before_reptition,
-                        limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Analista",
-                    )
-
-                    if not technique:
-                        raise ValueError("Error al guardar la técnica")
-
-                    created_scale = Escala.objects.create(
-                        id_tipo_escala=TipoEscala.objects.get(
-                            nombre_escala="estructurada"),
-                        longitud=data_basic["numero_productos"],
-                        tecnica=technique
-                    )
-                    
-                    if not created_scale:
-                        raise ValueError("No se ha podido crear la escala")
-
-                    # ////////////////////////////////////////////// #
-                    #
-                    # Second step: Create productos with their codes #
-                    #
-                    # ////////////////////////////////////////////// #
-                    codes = request.session["form_codes"]
-
-                    if not codes:
-                        raise ValueError("No hay códigos de productos")
-
-                    products_without_save = []
-                    for code in codes:
-                        product = Producto(
-                            codigoProducto=code,
-                            id_tecnica=technique
-                        )
-                        products_without_save.append(product)
-
-                    Producto.objects.bulk_create(products_without_save)
-
-                    # /////////////////////////////////////////////////////// #
-                    #
-                    # Third step: Create session and relat with the technique #
-                    #
-                    # /////////////////////////////////////////////////////// #
-                    session = SesionSensorial.objects.create(
-                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                        tecnica=technique,
-                        creadoPor=request.user.user_presentador
-                    )
-
-                    if not session:
-                        raise ValueError("Error al crear sesion sensorial")
-
-                    context = {
-                        "message": "sesión creada",
-                        "data": {
-                            "codigo_sesion": session.codigo_sesion,
-                            "nombre_sesion": session.nombre_sesion
-                        }
-                    }
-
-                    # ////////////////////////////////// #
-                    #
-                    # Final step: Delete date en session #
-                    #
-                    # ////////////////////////////////// #
-                    deleteDataSession(request)
-                    return JsonResponse(context)
-
-            except ValueError as e:
-                return general_error(f"Error: {e}")
-        else:
-            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_napping_controller.py

@@ -0,0 +1,95 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, Producto, SesionSensorial
+from django.db import transaction
+from tecnicas.utils import deleteDataSession
+
+
+class PanelCreateNappingController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_basic") or not request.session.get("form_codes"):
+                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")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = data_basic["numero_catadores"] or 2
+                    data_basic["numero_repeticiones"] = 0
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="napping"),
+                        repeticiones_max=data_basic["numero_repeticiones"],
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_pf_controller.py

@@ -0,0 +1,105 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, SesionSensorial, Escala, TipoEscala, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreatePFController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_codes"):
+                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")
+            try:
+                with transaction.atomic():
+                    # ////////////////////////////////////// #
+                    #
+                    # First step: Create technique and scale #
+                    #
+                    # ////////////////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    phases_before_reptition = 2
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="perfil flash"),
+                        repeticiones_max=data_basic["numero_repeticiones"] +
+                        phases_before_reptition,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Analista",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    created_scale = Escala.objects.create(
+                        id_tipo_escala=TipoEscala.objects.get(
+                            nombre_escala="estructurada"),
+                        longitud=data_basic["numero_productos"],
+                        tecnica=technique
+                    )
+
+                    if not created_scale:
+                        raise ValueError("No se ha podido crear la escala")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_rata_controller.py

@@ -0,0 +1,155 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.controllers import EscalaController
+from tecnicas.models import EsVocabulario, Tecnica, TipoTecnica, EstiloPalabra, EsAtributo, Vocabulario, Palabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateRataController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(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")
+            try:
+                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
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo=data_basic["estilo_palabras"]),
+                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("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):
+                        raise ValueError(scale["error"])
+
+                    dict_tags = request.session["form_tags"]
+                    saved_related_tags = controllerScale.realteTags(dict_tags)
+                    if "error" in saved_related_tags:
+                        raise ValueError(saved_related_tags["error"])
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+
+                    if style_words == "atributos":
+                        raw_ids_words = request.session["form_words"]
+                        ids_words = [int(id_w) for id_w in raw_ids_words]
+
+                        words = Palabra.objects.filter(id__in=ids_words)
+
+                        style_atribute = EsAtributo.objects.create(
+                            id_tecnica=technique
+                        )
+
+                        if not style_atribute:
+                            raise ValueError(
+                                "Error al intentar relacionar las palabras con la técnica")
+
+                        style_atribute.palabras.set(words)
+
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        try:
+                            vocabulary = Vocabulario.objects.get(
+                                nombre_vocabulario=name_vocabulary)
+                        except Vocabulario.DoesNotExist:
+                            raise ValueError("Vocabulario no encontrado")
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                        if not es_vocabulary:
+                            raise ValueError(
+                                "Error al intentar relacionar el vocabulario con la técnica")
+
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else "",
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_sort_controller.py

@@ -0,0 +1,95 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateSortController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_basic") or not request.session.get("form_codes"):
+                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")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = data_basic["numero_catadores"] or 1
+                    data_basic["numero_repeticiones"] = 1
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="sort"),
+                        repeticiones_max=data_basic["numero_repeticiones"],
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/session_management/{details_cata_controller.py → details/details_cata_controller.py}

@@ -9,7 +9,7 @@ from collections import defaultdict
 class DetallesCATAController(DetallesController):
     def __init__(self, session: SesionSensorial):
         super().__init__(session)
-        self.url_template = "tecnicas/manage_sesions/detalles-sesion-cata.html"
+        self.url_template = "tecnicas/manage_sesions/details-session-cata.html"
         self.url_next = "cata_system:monitor_sesion"
 
     def getContext(self):

tecnicas/controllers/views_controller/session_management/{details_controller.py → details/details_controller.py}

@@ -7,7 +7,7 @@ from tecnicas.controllers import ParticipacionController
 
 class DetallesController():
     url_template: str
-    url_next: str
+    url_next = "cata_system:monitor_sesion"
 
     def __init__(self, session: SesionSensorial):
         self.session = session

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

@@ -11,20 +11,17 @@ Encabezados de como deben de aparecer los datos juntos
 | Repeticion | Codigo Producto | Catador | P1 | P2 | P3 | Pn |
 
 '''
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion, Escala
-from tecnicas.controllers import DatoController, PalabrasController, ParticipacionController
+from tecnicas.models import SesionSensorial, Calificacion, Escala
+from tecnicas.controllers import DatoController, PalabrasController
 from .details_controller import DetallesController
-from tecnicas.utils import defaultdict_to_dict, controller_error
+from tecnicas.utils import defaultdict_to_dict
 from collections import defaultdict
 
 
 class DetallesEscalasController(DetallesController):
     def __init__(self, session: SesionSensorial):
         super().__init__(session)
-        self.url_template = "tecnicas/manage_sesions/detalles-sesion.html"
+        self.url_template = "tecnicas/manage_sesions/details-session.html"
         self.url_next = "cata_system:monitor_sesion"
 
     def getContext(self):

tecnicas/controllers/views_controller/session_management/{details_pf_controller.py → details/details_pf_controller.py}

@@ -1,8 +1,5 @@
-from django.http import HttpRequest
-from django.shortcuts import redirect
-from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Participacion, ListaPalabras, Calificacion, Catador
-from tecnicas.controllers import ParticipacionController, DatoController
+from tecnicas.models import SesionSensorial, ListaPalabras, Calificacion, Catador
+from tecnicas.controllers import DatoController
 from tecnicas.utils import defaultdict_to_dict
 from .details_controller import DetallesController
 from collections import defaultdict
@@ -20,9 +17,7 @@ class DetallesPFController(DetallesController):
         self.context = {
             "sesion": self.session,
             "use_technique": technique,
-            "existen_calificaciones": False,
             "tipo_escala": technique.escala_tecnica.id_tipo_escala.nombre_escala,
-            "valor_max": technique.escala_tecnica.longitud,
             "repeticiones_max": technique.repeticiones_max - 2
         }
 

tecnicas/controllers/views_controller/session_management/{details_rata_controller.py → details/details_rata_controller.py}

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

tecnicas/controllers/views_controller/session_management/details/details_sort_controller.py

@@ -0,0 +1,91 @@
+from .details_controller import DetallesController
+from tecnicas.models import SesionSensorial, GrupoProducto, Producto, Participacion
+from collections import defaultdict
+
+
+class DetallesSortController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_template = "tecnicas/manage_sesions/details-session-sort.html"
+        self.url_next = "cata_system:monitor_sesion"
+
+    def getContext(self):
+        technique = self.session.tecnica
+
+        finished = False
+        status = ""
+
+        if technique.repeticion < technique.repeticiones_max and not self.session.activo:
+            status = "En espera para iniciar la sesión"
+        elif technique.repeticion >= technique.repeticiones_max and not self.session.activo:
+            status = "Esta sesión ha sido finalizada"
+            finished = True
+        else:
+            status = "La sesión está en progreso"
+
+        self.context = {
+            "sesion": self.session,
+            "technique": technique,
+            "status": status,
+            "finished": finished
+        }
+
+        self.context["data_groups"] = {
+            "data": self.setDataSort(),
+            "testers": self.setHeaders()
+        }
+
+        return self.context
+
+    def setDataSort(self):
+        data = []
+        technique = self.session.tecnica
+
+        products = Producto.objects.filter(id_tecnica=technique)
+
+        groups = GrupoProducto.objects.select_related("catador").filter(
+            tecnica=technique
+        )
+
+        if len(groups):
+            self.context["there_data"] = True
+        else:
+            self.context["there_data"] = False
+            return []
+
+        for product in products:
+            product_data = {
+                "codigo_producto": product.codigoProducto,
+                "palabras": {}
+            }
+
+            related_groups = groups.filter(productos=product).select_related(
+                "catador__user"
+            ).prefetch_related("palabras")
+
+            data_words = defaultdict(set)
+
+            for group in related_groups:
+                catador_username = group.catador.user.username
+
+                for word in group.palabras.all():
+                    data_words[catador_username].add(word.nombre_palabra)
+
+            product_data["palabras"] = {
+                username: list(words)
+                for username, words in data_words.items()
+            }
+
+            data.append(product_data)
+
+        return data
+
+    def setHeaders(self):
+        participacions = list(Participacion.objects.filter(
+            tecnica=self.session.tecnica
+        ).only("catador").select_related("catador__user"))
+
+        testers = [
+            participacion.catador.user.username for participacion in participacions]
+
+        return testers

tecnicas/controllers/views_controller/session_management/{monitor_controller.py → monitor/monitor_controller.py}

@@ -1,9 +1,7 @@
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Producto, EsAtributo, EsVocabulario
-from tecnicas.controllers import ParticipacionController, SesionController
-from tecnicas.utils import controller_error
+from tecnicas.models import SesionSensorial, Producto, EsAtributo, EsVocabulario, Participacion
 
 
 class MonitorController():
@@ -14,20 +12,20 @@ class MonitorController():
         self.sensorial_session = session
 
     def controllPostFinishSession(self, request: HttpRequest):
-        self.setContext()
         (is_all_end, message) = self.checkAllFinish()
         if not is_all_end:
+            self.setContext()
             self.context["error"] = message
             return render(request, self.url_view, self.context)
         self.finishSession()
         return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
 
-    def checkAllFinish(self):
+    def checkAllFinish(self) -> (bool, str):
         return (False, "Función sin implementar")
 
     def setContext(self):
-        self.participations = ParticipacionController.getParticipationsInTechinique(
-            self.sensorial_session.tecnica)
+        self.participations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica)
 
         self.context = {
             "code_session": self.sensorial_session.codigo_sesion,

tecnicas/controllers/views_controller/session_management/{monitor_pf_controller.py → monitor/monitor_pf_controller.py}

@@ -1,6 +1,3 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from django.urls import reverse
 from tecnicas.models import Dato, Participacion, Catador, ListaPalabras, Producto
 from tecnicas.controllers import SesionController
 from .monitor_controller import MonitorController

tecnicas/controllers/views_controller/session_management/monitor/monitor_sort_controller.py

@@ -0,0 +1,27 @@
+from tecnicas.models import SesionSensorial
+from tecnicas.models import Participacion
+from .monitor_controller import MonitorController
+
+
+class MonitorSortController(MonitorController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-session-sort.html"
+        self.previus_view = "cata_system:detalles_sesion"
+
+    def checkAllFinish(self):
+        technique = self.sensorial_session.tecnica
+
+        num_participations = Participacion.objects.filter(
+            tecnica=technique).count()
+
+        if num_participations < technique.limite_catadores:
+            return (False, "No se ha alcanzado el número máximo de catadores")
+
+        unfinished_participations = Participacion.objects.filter(
+            tecnica=technique, finalizado=False).count()
+
+        if unfinished_participations > 0:
+            return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")

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

@@ -11,7 +11,7 @@ class InitSessionController():
     session: SesionSensorial
     order: Orden | dict
     current_direction: str
-    current_direction = "tecnicas/forms_tester/init_session.html"
+    current_direction = "tecnicas/forms_tester/init_scales_test.html"
     escalas_direction = "cata_system:session_convencional"
 
     def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):

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

@@ -13,7 +13,7 @@ class InitSessionEscalasController(InitSessionController):
 
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_direction = "tecnicas/forms_tester/init_session.html"
+        self.current_direction = "tecnicas/forms_tester/init_scales_test.html"
         self.escalas_direction = "cata_system:session_convencional"
         self.cata_direction = "cata_system:session_cata"
 

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

@@ -9,7 +9,7 @@ from .init_session_controller import InitSessionController
 class InitSessionPFController(InitSessionController):
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_direction = "tecnicas/forms_tester/init_session_pf.html"
+        self.current_direction = "tecnicas/forms_tester/init_pf_test.html"
         self.pf_direction = "cata_system:session_pf"
 
     def controllGet(self, request: HttpRequest):

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

@@ -6,7 +6,7 @@ from .init_session_controller import InitSessionController
 class InitSessionRATAController(InitSessionController):
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_direction = "tecnicas/forms_tester/init_session.html"
+        self.current_direction = "tecnicas/forms_tester/init_scales_test.html"
 
     def controllGet(self, request: HttpRequest):
         context = {

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

@@ -0,0 +1,77 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Participacion
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionSortController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_test_sort.html"
+        self.sort_direction = "cata_system:session_sort"
+
+    def controllGet(self, request: HttpRequest, error=""):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        is_end = self.isEndedSession()
+
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, context)
+
+    def isEndedSession(self):
+        participation = Participacion.objects.get(
+            catador=self.tester, tecnica=self.session.tecnica)
+
+        return participation.finalizado
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        use_action = request.POST["action"]
+
+        if use_action == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            is_end = self.isEndedSession()
+            if is_end:
+                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+                return render(request, self.current_direction, context)
+
+            update_participation = ParticipacionController.enterSession(
+                tester=request.user.user_catador, session=self.session)
+
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                return render(request, self.current_direction, context)
+
+            request.session["id_participation"] = update_participation.id
+
+            return redirect(reverse(self.sort_direction, kwargs=parameters))
+
+        elif use_action == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return render(request, self.current_direction, context)
+
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)

tecnicas/controllers/views_controller/sessions_tester/login_session_tester_controller.py

@@ -98,5 +98,51 @@ class LoginSessionTesterController():
             context["error"] = "Imposible acceder a esta sesión"
             return render(request, self.current_direcction, context)
 
+    def validateEntrySort(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)
+                context["error"] = "Usted ya esta dentro de la sesión"
+                return render(request, self.current_direcction, context)
+
+            except Participacion.DoesNotExist:
+                try:
+                    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:
+                            raise ValueError(
+                                "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
+                        )
+                        params = {
+                            "code_sesion": self.session.codigo_sesion
+                        }
+                        return redirect(reverse(self.destinity_direcction, kwargs=params))
+                        
+                except ValueError as e:
+                    context["error"] = str(e)
+                    return render(request, self.current_direcction, context)
+
+        else:
+            context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, context)
+
     def validateEntryPF(self, request=HttpRequest):
         return self.validateEntryEscalas(request=request)

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

@@ -1,7 +1,8 @@
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Catador
+from tecnicas.models import SesionSensorial, Catador, Participacion
+from tecnicas.controllers import ParticipacionController
 
 
 class GenetalTestController():
@@ -12,3 +13,16 @@ class GenetalTestController():
     def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
         self.tester = user_tester
         self.session = sensorial_session
+
+    def controllPost(self, request: HttpRequest):
+        action = request.POST["action"]
+
+        if action == "finish_session":
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        else:
+            return self.controllGet(request, error="Acción no permitida")

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

@@ -9,7 +9,7 @@ from .general_test_controller import GenetalTestController
 class TestCataController(GenetalTestController):
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_directory = "tecnicas/forms_tester/cata.html"
+        self.current_directory = "tecnicas/forms_tester/test_cata.html"
 
     def controllGet(self, request: HttpRequest):
         technique = self.session.tecnica

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

@@ -9,7 +9,7 @@ from .general_test_controller import GenetalTestController
 class TestRataController(GenetalTestController):
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_directory = "tecnicas/forms_tester/convencional.html"
+        self.current_directory = "tecnicas/forms_tester/test_convencional.html"
 
     def controllGet(self, request: HttpRequest):
         technique = self.session.tecnica

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

@@ -9,7 +9,7 @@ from .general_test_controller import GenetalTestController
 class TestScalesController(GenetalTestController):
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
-        self.current_directory = "tecnicas/forms_tester/convencional.html"
+        self.current_directory = "tecnicas/forms_tester/test_convencional.html"
 
     def controllGet(self, request: HttpRequest):
         technique = self.session.tecnica

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

@@ -0,0 +1,50 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Participacion, Producto, Calificacion, Palabra, GrupoProducto
+from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
+from tecnicas.forms import ListWordsForm
+from .general_test_controller import GenetalTestController
+
+
+class TestSortController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/test_sort.html"
+
+    def controllGet(self, request: HttpRequest):
+        '''
+        Objetivo: Entregar al cliente los grupos de productos guardados hechos por el catador en una lista, de lo contrario solo mandar una lista vacia
+        - Comprobar que el Catador aun no finalice su la sesion
+        - Obtener todos los productos en la tecnica
+        - Obtener todos los grupos creadas por el usuario
+            - Si hay grupos, cada item de la lista a mandar debe incluir los productos asociados al grupo como las palabras que describen al grupo
+            - Si no hay grupos, solo mandar una lista vacia
+        - Mandar la lista de grupos como la lista de productos
+        - Agregar el formulario para describir los grupo
+        '''
+        self.context["session"] = self.session
+        technique = self.session.tecnica
+
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        # Comprobar que el Catador no haya finalizado
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+        self.context["products"] = products_in_technique
+
+        grups_products = GrupoProducto.objects.filter(
+            tecnica=technique, catador=request.user.user_catador).select_related("productos", "palabras")
+
+        self.context["grups_products"] = grups_products if grups_products else []
+
+        self.context["form_word"] = ListWordsForm()
+
+        return render(request, self.current_directory, self.context)
+

tecnicas/forms/__init__.py

@@ -2,6 +2,8 @@ from .create_session.sesion_basic_form import SesionBasicForm
 from .create_session.sesiob_basic_cata_form import SesionBasicCATAForm
 from .create_session.sesion_basic_pf_form import SesionBasicPFForm
 from .create_session.sesion_tags_form import SesionTagsForm
+from .create_session.sesion_basic_sort_form import SesionBasicSortForm
+from .create_session.sesion_basic_napping import SesionBasicNappingForm
 
 from .etiqueta_form import EtiquetaForm
 from .codes_form import CodesForm

tecnicas/forms/create_session/sesiob_basic_cata_form.py

@@ -22,6 +22,11 @@ class SesionBasicCATAForm(forms.Form):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self.fields['estilo_palabras'] = forms.ModelChoiceField(queryset=EstiloPalabra.objects.all(), widget=forms.RadioSelect(attrs={
+        options = [
+            ("atributos", "atributos"),
+            ("vocabulario", "vocabulario")
+        ]
+
+        self.fields['estilo_palabras'] = forms.ChoiceField(choices=options, 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=EstiloPalabra.objects.first())
+        }), required=True, initial=options[0])

tecnicas/forms/create_session/sesion_basic_form.py

@@ -38,9 +38,14 @@ class SesionBasicForm(forms.Form):
         if initial_conf is None:
             initial_conf = {}
 
-        self.fields['estilo_palabras'] = forms.ModelChoiceField(queryset=EstiloPalabra.objects.all(), widget=forms.RadioSelect(attrs={
+        options = [
+            ("atributos", "atributos"),
+            ("vocabulario", "vocabulario")
+        ]
+
+        self.fields['estilo_palabras'] = forms.ChoiceField(choices=options, 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=EstiloPalabra.objects.first())
+        }), required=True, initial=options[0])
 
         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",

tecnicas/forms/create_session/sesion_basic_napping.py

@@ -0,0 +1,24 @@
+from django import forms
+
+
+class SesionBasicNappingForm(forms.Form):
+    nombre_sesion = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
+        "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
+        "name": "nombre_sesion",
+        "placeholder": "Ej. Mermelada de mango picante"
+    }), required=False)
+
+    numero_productos = forms.IntegerField(widget=forms.NumberInput(attrs={
+        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
+        "placeholder": "Solo números"
+    }), required=True)
+
+    numero_catadores = forms.IntegerField(widget=forms.NumberInput(attrs={
+        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
+        "placeholder": "Solo números"
+    }), required=True)
+
+    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)

tecnicas/forms/create_session/sesion_basic_pf_form.py

@@ -1,5 +1,4 @@
 from django import forms
-from tecnicas.models import TipoEscala
 
 
 class SesionBasicPFForm(forms.Form):

tecnicas/forms/create_session/sesion_basic_sort_form.py

@@ -0,0 +1,24 @@
+from django import forms
+
+
+class SesionBasicSortForm(forms.Form):
+    nombre_sesion = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
+        "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
+        "name": "nombre_sesion",
+        "placeholder": "Ej. Mermelada de mango picante"
+    }), required=False)
+
+    numero_productos = forms.IntegerField(widget=forms.NumberInput(attrs={
+        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
+        "placeholder": "Solo números"
+    }), required=True)
+
+    numero_catadores = forms.IntegerField(widget=forms.NumberInput(attrs={
+        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
+        "placeholder": "Solo números"
+    }), required=True)
+
+    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)

tecnicas/migrations/0024_alter_sesionsensorial_codigo_sesion_grupoproducto.py

@@ -0,0 +1,30 @@
+# Generated by Django 5.2.1 on 2025-11-25 01:18
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0023_alter_sesionsensorial_codigo_sesion_listapalabras'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.CreateModel(
+            name='GrupoProducto',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('catador', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='catador_grupo_producto', to='tecnicas.catador')),
+                ('palabras', models.ManyToManyField(related_name='grupo_producto', to='tecnicas.palabra')),
+                ('productos', models.ManyToManyField(related_name='grupo_producto', to='tecnicas.producto')),
+                ('tecnica', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tecnica_grupo_producto', to='tecnicas.tecnica')),
+            ],
+        ),
+    ]

tecnicas/models/__init__.py

@@ -30,3 +30,4 @@ from .orden import Posicion
 from .participacion import Participacion
 
 from .lista_palabras import ListaPalabras
+from .grupo_producto import GrupoProducto

tecnicas/models/grupo_producto.py

@@ -0,0 +1,19 @@
+from django.db import models
+from tecnicas.models import Tecnica, Catador, Palabra, Producto
+
+
+class GrupoProducto(models.Model):
+    tecnica = models.ForeignKey(
+        Tecnica, on_delete=models.CASCADE, related_name="tecnica_grupo_producto")
+    
+    catador = models.ForeignKey(
+        Catador, on_delete=models.CASCADE, related_name="catador_grupo_producto")
+
+    productos = models.ManyToManyField(
+        Producto, related_name="grupo_producto")
+
+    palabras = models.ManyToManyField(
+        Palabra, related_name="grupo_producto")
+
+    def __str__(self):
+        return f"{self.tecnica.sesion_tecnica.codigo_sesion} - {self.catador.user.username}"

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

@@ -4,7 +4,7 @@ document.addEventListener("DOMContentLoaded", function () {
 
   btn.addEventListener("click", function () {
     // Try set the table in the page
-    let table = document.getElementById("convencional-table");
+    let table = document.getElementById("generic-donwload-table");
     if (!table) {
       const section = btn.closest("section");
       if (section) table = section.querySelector("table");

tecnicas/static/js/download-table-sort-csv.js

@@ -0,0 +1,79 @@
+document.addEventListener("DOMContentLoaded", function () {
+    const btn = document.getElementById("download-csv-btn");
+    if (!btn) return;
+
+    btn.addEventListener("click", function () {
+        // Try set the table in the page
+        let table = document.getElementById("generic-donwload-table");
+        if (!table) {
+            const section = btn.closest("section");
+            if (section) table = section.querySelector("table");
+        }
+        if (!table) {
+            console.warn("No se encontró la tabla para descargar.");
+            return;
+        }
+
+        // helper to trim and normalize cell text
+        const cellText = (cell) => {
+            if (!cell) return "";
+            return String(cell.textContent || "").trim();
+        };
+
+        // Collect headers
+        const headers = [];
+        const ths = table.querySelectorAll("thead th");
+        ths.forEach((th) => headers.push(cellText(th)));
+
+        // Collect rows
+        const rows = [];
+        const trs = table.querySelectorAll("tbody tr");
+        trs.forEach((tr) => {
+            const cols = [];
+            const tds = tr.querySelectorAll("td");
+            tds.forEach((td) => cols.push(cellText(td)));
+            rows.push(cols);
+        });
+
+        // Convert to CSV string (escape quotes, wrap in quotes if needed)
+        const escapeValue = (val) => {
+            if (val == null) return "";
+            let normalVal = val.replace(/[\u0300-\u036f]/g, "");
+            normalVal = normalVal.replace(/(\r\n|\n|\r|\s)/gm, '');
+            const needsQuotes = /[",\n,;]/.test(normalVal);
+            let v = normalVal.replace(/"/g, '""');
+            if (needsQuotes) v = `"${v}"`;
+            return v;
+        };
+
+        const lines = [];
+        if (headers.length) lines.push(headers.map(escapeValue).join(","));
+        rows.forEach((r) => lines.push(r.map(escapeValue).join(",")));
+
+        const csvContent = lines.join("\n");
+
+        // File name: data_{nombre_sesion or codigo_sesion}
+        const rawName = (btn.dataset.sessionName || "").trim();
+        const code = (btn.dataset.sessionCode || "").trim() || "session";
+        const namePart = rawName
+            ? rawName.replace(/[^a-zA-Z0-9-_áéíóúÁÉÍÓÚ ]/g, "").replace(/\s+/g, "_")
+            : code;
+        const fileName = `data_${namePart}.csv`;
+
+        // Create blob and force download
+        const blob = new Blob([csvContent], { type: "text/csv;charset=UTF-8;" });
+        if (navigator.msSaveBlob) {
+            navigator.msSaveBlob(blob, fileName);
+        } else {
+            const link = document.createElement("a");
+            const url = URL.createObjectURL(blob);
+            link.setAttribute("href", url);
+            link.setAttribute("download", fileName);
+            link.style.visibility = "hidden";
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            URL.revokeObjectURL(url);
+        }
+    });
+});

tecnicas/static/js/test-sort.js

@@ -0,0 +1,554 @@
+let dragged = null;
+
+const productsPlaceHolder = `
+    <p class="text-products text-center text-lg font-medium">
+        Agrupación de productos
+    </p>`;
+
+const wordsPlaceHolder = `
+    <p class="text-words text-center text-lg font-medium">
+        Lista de atributos
+    </p>`;
+
+const products = document.querySelectorAll(".draggable");
+const zonesDrop = document.querySelectorAll(".dropzone");
+
+const DATA_GRUPS = {};
+
+products.forEach(manageDragables);
+zonesDrop.forEach(manageDropZone);
+
+
+/*
+////
+//////
+//////// Add new grups
+//////
+////
+*/
+
+function addNewGrup() {
+    const container = document.getElementById("containers");
+    const newGrup = document.createElement("section");
+    const styles = "w-fit space-y-4 border rounded p-2 bg-surface-sweet";
+    newGrup.classList.add(...styles.split(" "));
+
+    const formWord = document.getElementById("form-word");
+    const formWordClone = formWord.cloneNode(true);
+    formWordClone.classList.remove("hidden");
+
+    newGrup.innerHTML = `
+        <div class="dropzone w-64 min-h-16 bg-surface-alter-card rounded p-2 flex items-center justify-center flex-wrap gap-2">
+            ${productsPlaceHolder}
+        </div>
+        ${formWordClone.outerHTML}
+        <div
+            class="words-container w-64 min-h-16 bg-surface-alter rounded p-2 flex items-center justify-center flex-wrap gap-2">
+            ${wordsPlaceHolder}
+        </div>
+        <div class="cts-container-question flex items-center justify-around gap-2">
+            <button class="cts-question cts-btn-general-compress flex-1 cts-btn-secondary btn-push">
+                ¿Remover este grupo?
+            </button>
+            <button class="cts-remove cts-btn-general-compress flex-1 cts-btn-primary btn-push hidden">
+                Remover
+            </button>
+            <button class="cts-no-remove cts-btn-general-compress flex-1 cts-btn-error btn-push hidden">
+                Conservar
+            </button>
+        </div>`;
+
+    manageDropZone(newGrup.querySelector(".dropzone"));
+    container.appendChild(newGrup);
+}
+
+
+/*
+////
+//////
+//////// Manage products' drags and remove drags
+//////
+////
+*/
+
+/**
+ * 
+ * @param {HTMLElement} zone 
+ */
+function manageDropZone(zone) {
+    /*
+    ////
+    ////// Trash Zone product
+    ////
+    */
+    if (zone.classList.contains("trash-products")) {
+        zone.addEventListener("dragover", (e) => e.preventDefault());
+
+        zone.addEventListener("drop", (event) => {
+            const codeDrag = dragged.dataset.code
+            const oldParent = dragged.parentNode;
+            const oldCodeZone = oldParent.getAttribute("id")
+
+            if (oldParent.classList.contains("original-products")) {
+                spanNotifaction("No puedes borrar este producto");
+                return
+            }
+
+            dragged.remove()
+            removeProduct(codeDrag, oldCodeZone)
+
+            spanNotifaction("Producto removido del grupo", false);
+            dragged = null
+
+            if (oldParent.classList.contains("dropzone") && oldParent.children.length === 0) {
+                oldParent.innerHTML = productsPlaceHolder;
+            }
+        })
+        return
+    }
+
+    /*
+    ////
+    ////// Identificate grups and creata dinamic data
+    ////
+    */
+
+    // Create id for grup
+    const idZone = generateSimpleID()
+
+    // Add products if there en the page
+    const products = []
+    const productsElements = zone.querySelectorAll(".draggable") || None;
+
+    if (productsElements) {
+        productsElements.forEach((proEle) => {
+            products.push({
+                id: proEle.dataset.idProduct,
+                code: proEle.dataset.code
+            })
+        })
+    }
+
+    const parentZone = zone.parentNode;
+    const wordsInGrup = parentZone.querySelectorAll(".item-word") || None
+
+    // Add words if there en the page
+    const words = []
+    if (wordsInGrup) {
+        wordsInGrup.forEach((wordElement) => {
+            words.push(wordElement.textContent)
+        })
+    }
+
+    DATA_GRUPS[idZone] = {
+        products: products,
+        words: words
+    }
+
+    /*
+    ////
+    ////// Drop Zone product
+    ////
+    */
+
+    zone.setAttribute("id", idZone)
+    zone.addEventListener("dragover", (e) => e.preventDefault());
+
+    zone.addEventListener("drop", () => {
+        const codeDrag = dragged.dataset.code
+        const zoneCode = zone.getAttribute("id")
+
+        // Check that new produck is not in currents products of the group
+        const obj = DATA_GRUPS[zoneCode].products.find((product) => product.code == codeDrag)
+        if (obj) {
+            spanNotifaction("Ese producto ya está en el grupo");
+            return
+        }
+
+        DATA_GRUPS[zoneCode].products.push({
+            id: dragged.dataset.idProduct,
+            code: dragged.dataset.code
+        })
+
+        const oldParent = dragged.parentNode;
+
+        const p = zone.querySelector("p");
+        if (p) {
+            p.remove();
+        }
+
+        // Move original or clone product in zone
+        if (oldParent.classList.contains("dropzone")) {
+            zone.appendChild(dragged);
+        } else {
+            const clone = dragged.cloneNode(true);
+            clone.classList.remove("opacity-50");
+            manageDragables(clone);
+            zone.appendChild(clone);
+        }
+
+        if (oldParent.classList.contains("dropzone")) {
+            if (oldParent.children.length === 0) oldParent.innerHTML = productsPlaceHolder;
+            const zoneCodeOld = oldParent.getAttribute("id")
+            removeProduct(codeDrag, zoneCodeOld)
+        }
+    });
+
+    // Add listeners to elements options and WordForm for the list words
+    addListenersButtonQuestionGrup(zone.parentNode)
+    manageFormWord(parentZone.querySelector("form"), parentZone.querySelector(".words-container"), idZone)
+
+    if (DATA_GRUPS[idZone].words.length) {
+        parentZone.querySelector(".words-container").innerHTML = "";
+        DATA_GRUPS[idZone].words.forEach((word) => {
+            const itemWord = getItemWord(word, idZone);
+            parentZone.querySelector(".words-container").appendChild(itemWord);
+        })
+    }
+}
+
+/*
+////
+//////
+//////// Management Drags and FormWord
+//////
+////
+*/
+
+/**
+ * 
+ * @param {HTMLElement} el 
+ */
+function manageDragables(el) {
+    el.addEventListener("dragstart", () => {
+        dragged = el;
+        setTimeout(() => el.classList.add("opacity-50"), 0);
+    });
+
+    el.addEventListener("dragend", () => {
+        dragged = null;
+        el.classList.remove("opacity-50");
+    });
+}
+
+/**
+ * 
+ * @param {HTMLFormElementt} form 
+ * @param {HTMLElement} containerWords
+ */
+function manageFormWord(form, containerWords, codeGrup) {
+    form.addEventListener("submit", (e) => {
+        e.preventDefault();
+
+        if (!form.reportValidity()) {
+            return;
+        }
+
+        const input = form.querySelector('input[type="text"]');
+
+        if (!input) return;
+
+        const name = input.value.trim();
+        if (!name) return;
+
+        if (DATA_GRUPS[codeGrup].words.includes(name)) {
+            input.value = "";
+            input.focus();
+            spanNotifaction("Esa palabra ya está en la lista");
+            return;
+        }
+
+        DATA_GRUPS[codeGrup].words.push(name)
+        const wordItem = getItemWord(name, codeGrup)
+
+        const p = containerWords.querySelector("p");
+        if (p) {
+            p.remove();
+        }
+
+        containerWords.appendChild(wordItem)
+
+        input.value = "";
+        input.focus();
+    });
+}
+
+/*
+////
+//////
+//////// Management Drags and FormWord
+//////
+////
+*/
+
+/**
+ * 
+ * @param {HTMLElement} grup 
+ */
+function removeGrup(grup) {
+    delete DATA_GRUPS[grup.querySelector(".dropzone").getAttribute("id")]
+    grup.remove()
+}
+
+function removeWord(code, wordName) {
+    const newWords = DATA_GRUPS[code].words.filter(word => word != wordName)
+    DATA_GRUPS[code].words = newWords
+    if (!newWords.length) {
+        const containerWords = document.getElementById(code).parentNode.querySelector(".words-container")
+        containerWords.innerHTML = wordsPlaceHolder;
+    }
+}
+
+function removeProduct(codeProduct, codeZone) {
+    const newProducts = DATA_GRUPS[codeZone].products.filter((product) => product.code != codeProduct)
+    DATA_GRUPS[codeZone].products = newProducts
+}
+
+function getItemWord(wordName, code) {
+    const STYLES_DIV = "cts-item-words bg-surface-ligt text-black rounded font-bold text-lg p-1 flex flex-wrap flex-row flex-1 min-w-fit justify-center items-center gap-3";
+    const STYLES_BTN = "cts-remove-word cts-btn-general-compress px-2 cts-btn-error"
+
+    const btn = document.createElement("button");
+    btn.setAttribute("data-code", code);
+    btn.setAttribute("data-word", wordName);
+    btn.classList.add(...STYLES_BTN.split(" "));
+    btn.textContent = "➖";
+
+    const span = document.createElement("span");
+    span.classList.add("item-word");
+    span.textContent = wordName;
+
+    const div = document.createElement("div");
+    div.setAttribute("id", `word-${code}-${wordName}`);
+    div.classList.add(...STYLES_DIV.split(" "));
+
+    div.appendChild(span);
+    div.appendChild(btn);
+
+    btn.addEventListener("click", (e) => {
+        removeWord(code, wordName)
+        div.remove()
+    })
+
+    return div;
+};
+
+/**
+ * 
+ * @param {HTMLElement} grupContainer 
+ */
+function addListenersButtonQuestionGrup(grupContainer) {
+    // Function hidden question
+    grupContainer.querySelector(".cts-question").addEventListener("click", (event) => {
+        hiddenQuestionRemoveGroup(grupContainer)
+    })
+
+    // Function cancel remove
+    grupContainer.querySelector(".cts-no-remove").addEventListener("click", (event) => {
+        hiddenQuestionRemoveGroup(grupContainer, false)
+    })
+
+    // Function remove grup
+    grupContainer.querySelector(".cts-remove").addEventListener("click", (event) => {
+        removeGrup(grupContainer)
+    })
+}
+
+/*
+////
+//////
+//////// Management Options Save and remove groups
+//////
+////
+*/
+
+/**
+ * 
+ * @param {HTMLDivElement} container 
+ * @param {boolean} hiddenQuestion 
+ */
+function hiddenQuestionRemoveGroup(container, hiddenQuestion = true) {
+    const question = container.querySelector(".cts-question")
+    const remove = container.querySelector(".cts-remove")
+    const noRemove = container.querySelector(".cts-no-remove")
+
+
+    if (hiddenQuestion) {
+        question.classList.add("hidden")
+        remove.classList.remove("hidden")
+        noRemove.classList.remove("hidden")
+    } else {
+        question.classList.remove("hidden")
+        remove.classList.add("hidden")
+        noRemove.classList.add("hidden")
+    }
+}
+
+function generateSimpleID() {
+    const first = Date.now().toString(35);
+    const second = Math.random().toString(36).slice(2);
+    return first + second;
+}
+
+function showOptionsSave() {
+    document.getElementById("question-save").classList.add("hidden");
+    document.getElementById("finish-session").classList.remove("hidden");
+    document.getElementById("cancel-save").classList.remove("hidden");
+}
+
+function showQuestionSave() {
+    document.getElementById("question-save").classList.remove("hidden");
+    document.getElementById("finish-session").classList.add("hidden");
+    document.getElementById("cancel-save").classList.add("hidden");
+}
+
+document
+    .getElementById("question-save")
+    .addEventListener("click", showOptionsSave);
+
+document
+    .getElementById("cancel-save")
+    .addEventListener("click", showQuestionSave);
+
+/*
+////
+//////
+//////// Save data
+//////
+////
+*/
+
+async function saveData() {
+    const keysDataGrups = Object.keys(DATA_GRUPS);
+    const allCodesProducts = new Set()
+
+    products.forEach((productElement) => {
+        allCodesProducts.add(productElement.getAttribute("data-code"))
+    })
+
+    if (keysDataGrups.length === 0) {
+        spanNotifaction("No hay grupos para guardar")
+        return false;
+    }
+
+    const data = []
+    let thereError = false;
+    const codesProducts = []
+
+    keysDataGrups.forEach((key) => {
+        if (thereError) return
+
+        const dataGrup = DATA_GRUPS[key];
+        if (!dataGrup) {
+            spanNotifaction("No hay datos para guardar")
+            thereError = true;
+            return
+        }
+
+        if (dataGrup.products.length === 0) {
+            spanNotifaction("Los grupos deben tener por lo menos un producto para guardar")
+            thereError = true;
+            return
+        }
+
+        if (dataGrup.words.length === 0) {
+            spanNotifaction("Los grupos deben tener por lo menos una palabra para guardar")
+            thereError = true;
+            return
+        }
+
+        const words = dataGrup.words;
+        const products = dataGrup.products;
+
+        codesProducts.push(...products.map((product) => product.code))
+
+        data.push({
+            words,
+            products
+        })
+    })
+
+    if (thereError) return false;
+
+    const currentCodesProducts = new Set(codesProducts)
+    const difference = symmetricDifference(currentCodesProducts, allCodesProducts)
+
+    if (difference.size > 0) {
+        spanNotifaction("Falta un producto que debe ser ordenado")
+        return false
+    }
+
+    const URL = "/cata/testers/api/rating-sort"
+    const csrfToken = document.querySelector('[name=csrfmiddlewaretoken]').value;
+
+    try {
+        const response = await fetch(URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-CSRFToken": csrfToken,
+            },
+            body: JSON.stringify(data),
+        })
+
+        if (!response.ok) {
+            spanNotifaction("Error en la respuesta del servidor")
+            return false;
+        }
+
+        const result = await response.json()
+
+        if (result.error) {
+            spanNotifaction(result.error)
+            return false
+        } else {
+            spanNotifaction(result.message, false)
+            return true
+        }
+    } catch (error) {
+        spanNotifaction("Error en proceso de guardar los datos")
+        return false
+    }
+}
+
+const buttonSaveData = document.getElementById("save-progress")
+buttonSaveData.addEventListener("click", saveData)
+
+function symmetricDifference(setA, setB) {
+    let _difference = new Set(setA);
+    for (let elem of setB) {
+        if (_difference.has(elem)) {
+            _difference.delete(elem);
+        } else {
+            _difference.add(elem);
+        }
+    }
+    return _difference;
+}
+
+/*
+////
+//////
+//////// Finish session
+//////
+////
+*/
+
+document
+    .getElementById("finish-session")
+    .addEventListener("click", finishSession);
+
+async function finishSession() {
+    const save = await saveData();
+    if (!save) {
+        spanNotifaction("Error al guardar los datos")
+        return
+    };
+
+    const FORM_ACTION = document.querySelector(".form-actions")
+
+    const inputAction = FORM_ACTION.querySelector(".action-input");
+    FORM_ACTION.action = "";
+    inputAction.value = "finish_session";
+    FORM_ACTION.submit();
+}

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

@@ -1,7 +1,7 @@
 {% load static %}
 <section>
     <div class="overflow-x-auto rounded-lg border border-surface-general">
-        <table id="convencional-table" class="min-w-max w-full text-sm text-center border-collapse">
+        <table id="generic-donwload-table" class="min-w-max w-full text-sm text-center border-collapse">
             <thead class="bg-surface-sweet text-black font-semibold">
                 <tr>
                     {% if sesion.tecnica.tipo_tecnica.nombre_tecnica != "rata" %}