Se establce configracion de codigos y palabras para CATA

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -14,7 +14,7 @@ class PanelBasicController():
     url_panel_basic_cata = "tecnicas/create_sesion/panel-basic-cata.html"
 
     url_next_panel_scales = "cata_system:panel_configuracion_tags"
-    url_next_panel_cata = "cata_system:panel_configuracion_tags"
+    url_next_panel_cata = "cata_system:panel_configuracion_codes"
 
     url_select_technique = "cata_system:seleccion_tecnica"
 
@@ -125,7 +125,7 @@ class PanelBasicController():
             request, PanelBasicController.url_panel_basic_cata, view_context)
 
     @staticmethod
-    def controllPostRATA(request: HttpRequest, name_tecnica: str):
+    def controllPostCATA(request: HttpRequest, name_tecnica: str):
         form = SesionBasicCATAForm(request.POST)
 
         if form.is_valid():

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -7,15 +7,16 @@ import json
 
 
 class PanelCodesController():
+    url_current_panel = "tecnicas/create_sesion/configuracion-panel-codes.html"
+    url_next_panel = "cata_system:panel_configuracion_words"
+
     def __init__(self):
         pass
 
     @staticmethod
     def controllGetEscalas(request: HttpRequest, data):
-        (
-            num_products,
-            num_tester
-        ) = PanelCodesController.defineInfoConvencional(data)
+        num_products = data["numero_productos"]
+        num_tester = data["numero_catadores"]
 
         codes_products = generarCodigos(num_products)
 
@@ -27,14 +28,11 @@ class PanelCodesController():
             "use_technique": "escalas"
         }
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
     def controllPostEscalas(request: HttpRequest, data):
-        (
-            num_products,
-            num_tester
-        ) = PanelCodesController.defineInfoConvencional(data)
+        num_tester = data["numero_catadores"]
 
         sorts_code = json.loads(request.POST.get("sort_codes"))
         codes = []
@@ -60,11 +58,11 @@ class PanelCodesController():
 
             codes_sort["sort_codes"] = sorts_code
             request.session["form_codes"] = codes_sort
-            return redirect(reverse("cata_system:panel_configuracion_words"))
+            return redirect(reverse(PanelCodesController.url_next_panel))
         else:
             context_codes_form["error"] = "error en los datos recibidos"
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
     def controllGetRATA(request: HttpRequest, data):
@@ -78,10 +76,10 @@ class PanelCodesController():
             "use_technique": "rata"
         }
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllPostRATA(request: HttpRequest):
+    def controllPostRATA(request: HttpRequest, is_rata: True):
         codes = []
         context_codes_form = {}
 
@@ -93,22 +91,26 @@ class PanelCodesController():
 
         context_codes_form = {
             "form_codes": form_codes,
-            "use_technique": "rata"
+            "use_technique": "rata" if is_rata else "cata"
         }
 
         if form_codes.is_valid():
             request.session["form_codes"] = codes
-            return redirect(reverse("cata_system:panel_configuracion_words"))
+            return redirect(reverse(PanelCodesController.url_next_panel))
         else:
             context_codes_form["error"] = "error en los datos recibidos"
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def defineInfoConvencional(data):
+    def controllGetCATA(request: HttpRequest, data):
         num_products = data["numero_productos"]
-        num_tester = data["numero_catadores"]
-        return (
-            num_products,
-            num_tester
-        )
+        codes_products = generarCodigos(num_products)
+        form_codes = CodesForm(codes=codes_products)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "use_technique": "cata"
+        }
+
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

@@ -2,7 +2,7 @@ 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 EsVocabulario, Vocabulario
+from tecnicas.models import EsAtributo, EsVocabulario, Vocabulario, Tecnica, TipoTecnica, EstiloPalabra, Producto, Palabra, SesionSensorial
 from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
 from tecnicas.utils import deleteDataSession
 
@@ -190,9 +190,17 @@ class PanelCreateController():
                     data_basic = request.session["form_basic"]
                     data_basic["numero_catadores"] = 0
                     data_basic["numero_repeticiones"] = 1
-                    controllerTechnique = TecnicaController()
-                    controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
-                    technique = controllerTechnique.saveTechnique()
+
+                    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")
 
@@ -220,15 +228,18 @@ class PanelCreateController():
                     # ////////////////////////////////////////////// #
                     codes = request.session["form_codes"]
 
-                    controllerProducts = ProductosController(
-                        codes=codes,
-                        technique=technique
-                    )
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
 
-                    controllerProducts.setProductsNoSave()
-                    saved_prodcuts = controllerProducts.saveProducts()
-                    if isinstance(saved_prodcuts, dict):
-                        raise ValueError(saved_prodcuts["error"])
+                    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)
 
                     # /////////////////////////////////////////////////////// #
                     #
@@ -236,24 +247,23 @@ class PanelCreateController():
                     #
                     # /////////////////////////////////////////////////////// #
                     style_words = technique.id_estilo.nombre_estilo
+
                     if style_words == "atributos":
-                        ids_words = request.session["form_words"]
-                        words_controller = PalabrasController(ids=ids_words)
+                        raw_ids_words = request.session["form_words"]
+                        ids_words = [int(id_w) for id_w in raw_ids_words]
 
-                        words_to_use = words_controller.setWords()
-                        if isinstance(words_to_use, dict):
-                            raise ValueError(words_to_use["error"])
+                        words = Palabra.objects.filter(id__in=ids_words)
 
-                        style_controller = EstiloPalabrasController(
-                            technique=technique, words=words_to_use)
+                        style_atribute = EsAtributo.objects.create(
+                            id_tecnica=technique
+                        )
 
-                        instace_style = style_controller.createAndSaveInstaceStyle()
-                        if isinstance(instace_style, dict):
-                            raise ValueError(instace_style["error"])
+                        if not style_atribute:
+                            raise ValueError(
+                                "Error al intentar relacionar las palabras con la técnica")
+
+                        style_atribute.palabras.set(words)
 
-                        words_using = style_controller.relatedWords()
-                        if isinstance(words_using, dict):
-                            raise ValueError(words_using["error"])
                     elif style_words == "vocabulario":
                         name_vocabulary = request.session["form_words"]
                         try:
@@ -266,6 +276,10 @@ class PanelCreateController():
                             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")
 
@@ -274,25 +288,20 @@ class PanelCreateController():
                     # Fourth step: Create session and relat with the technique #
                     #
                     # //////////////////////////////////////////////////////// #
-                    session_controller = SesionController(
+                    session = SesionSensorial.objects.create(
                         name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
                         technique=technique,
                         creator=request.user.user_presentador
                     )
 
-                    setting_session = session_controller.setSession()
-                    if isinstance(setting_session, dict):
-                        raise ValueError(setting_session["error"])
-
-                    saved_session = session_controller.saveSession()
-                    if isinstance(saved_session, dict):
-                        raise ValueError(saved_session["error"])
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
 
                     context = {
                         "message": "sesión creada",
                         "data": {
-                            "codigo_sesion": saved_session.codigo_sesion,
-                            "nombre_sesion": saved_session.nombre_sesion
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
                         }
                     }
 
@@ -308,3 +317,130 @@ class PanelCreateController():
                 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(
+                        name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        technique=technique,
+                        creator=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/templates/tecnicas/create_sesion/configuracion-panel-codes.html

@@ -7,13 +7,18 @@
 <article class="cts-container-main">
     <article class="cts-wrap-content text-black">
         <h1 class="text-center font-bold text-4xl">Panel de configuración</h1>
+
         {% if error %}
-        <p class="text-2xl">{{ error }}</p>
+        {% include "./components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "./components/error-message.html" with message=message %}
         {% endif %}
+
         <form method="post" action="" class="ct-codes-form flex flex-col gap-5">
             {% csrf_token %}
             <h2 class="text-2xl mb-2 font-bold">Codificar productos</h2>
-            <hr>
+
             <article class="w-full flex flex-col justify-center items-center gap-5">
                 <p class="text-center font-bold tracking-wide text-xl bg-surface-card px-3 py-3 pb-4 rounded max-w-4xl">
                     Puede dejar los campos como están para usar los códigos predefinidos.
@@ -47,7 +52,6 @@
             </article>
             {% endif %}
 
-            <hr>
             <article class="flex flex-col items-center gap-4">
                 <section class="flex w-full max-sm:flex-col flex-wrap gap-4 max-w-2xl">
                     <button type="submit" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full">

tecnicas/views/sessions_config/configuration_panel_basic.py

@@ -31,6 +31,9 @@ def configurationPanelBasic(req: HttpRequest):
         elif name_tecnica == "rata":
             response = PanelBasicController.controllPostRATA(
                 request=req, name_tecnica=name_tecnica)
+        elif name_tecnica == "cata":
+            response = PanelBasicController.controllPostCATA(
+                request=req, name_tecnica=name_tecnica)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=¡Oh, vaya! Cambio de técnica repentino, vuelve a elegir otra vez")

tecnicas/views/sessions_config/configuration_panel_codes.py

@@ -12,25 +12,32 @@ def configurationPanelCodes(req: HttpRequest):
                         "?error=datos del formulario requerido no encontrados")
 
     data_basic = req.session["form_basic"]
+    name_technique = data_basic["name_tecnica"]
 
     if req.method == "GET":
-        if data_basic["name_tecnica"] == "escalas":
+        if name_technique == "escalas":
             response = PanelCodesController.controllGetEscalas(
                 req, data_basic)
-        elif data_basic["name_tecnica"] == "rata":
+        elif name_technique == "rata":
             response = PanelCodesController.controllGetRATA(
                 req, data_basic)
+        elif name_technique == "cata":
+            response = PanelCodesController.controllGetCATA(
+                req, data_basic)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
 
         return response
     elif req.method == "POST":
-        if data_basic["name_tecnica"] == "escalas":
+        if name_technique == "escalas":
             response = PanelCodesController.controllPostEscalas(
                 req, data_basic)
-        elif data_basic["name_tecnica"] == "rata":
+        elif name_technique == "rata":
             response = PanelCodesController.controllPostRATA(request=req)
+        elif name_technique == "cata":
+            response = PanelCodesController.controllPostRATA(
+                request=req, is_rata=False)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")

tecnicas/views/sessions_config/configuration_panel_words.py

@@ -13,14 +13,19 @@ def configurationPanelWords(req: HttpRequest):
                         "?error=datos requeridos no encontrados")
 
     basic_data = req.session["form_basic"]
-    style_words = EstiloPalabra.objects.get(id=basic_data["estilo_palabras"])
+    name_technique = basic_data["name_tecnica"]
+    style_words = EstiloPalabra.objects.get(
+        id=basic_data["estilo_palabras"]).nombre_estilo
 
     if req.method == "GET":
-        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
-            if style_words.nombre_estilo == "atributos":
-                response = PanelWordsController.controllGetEscalasAtributes(req)
-            elif style_words.nombre_estilo == "vocabulario":
-                response = PanelWordsController.controllGetEscalasVocabulary(req)
+        if name_technique == "escalas" or name_technique == "rata" or name_technique == "cata":
+            print()
+            if style_words == "atributos":
+                response = PanelWordsController.controllGetEscalasAtributes(
+                    req)
+            elif style_words == "vocabulario":
+                response = PanelWordsController.controllGetEscalasVocabulary(
+                    req)
             else:
                 response = redirect(
                     reverse("cata_system:seleccion_tecnica") + "?error=Estilo de palabras no valida")
@@ -28,12 +33,15 @@ def configurationPanelWords(req: HttpRequest):
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
         return response
+
     elif req.method == "POST":
-        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
-            if style_words.nombre_estilo == "atributos":
-                response = PanelWordsController.controllPostEscalasAtributes(req)
-            elif style_words.nombre_estilo == "vocabulario":
-                response = PanelWordsController.controllPostEscalasVocabulary(req)
+        if name_technique == "escalas" or name_technique == "rata" or name_technique == "cata":
+            if style_words == "atributos":
+                response = PanelWordsController.controllPostEscalasAtributes(
+                    req)
+            elif style_words == "vocabulario":
+                response = PanelWordsController.controllPostEscalasVocabulary(
+                    req)
             else:
                 response = redirect(
                     reverse("cata_system:seleccion_tecnica") + "?error=Estilo de palabras no valida")
@@ -42,5 +50,6 @@ def configurationPanelWords(req: HttpRequest):
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
 
         return response
+
     else:
         return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/create_session.py

@@ -26,6 +26,8 @@ def createSession(req: HttpRequest):
             response = PanelCreateController.controllPostEscalas(req)
         elif basic_data["name_tecnica"] == "rata":
             response = PanelCreateController.controllPostRATA(req)
+        elif basic_data["name_tecnica"] == "cata":
+            response = PanelCreateController.controllPostCATA(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")