Merge pull request #29 from CascoArcilla/HU10

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -1,4 +1,4 @@
-from tecnicas.forms import SesionBasicForm
+from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
@@ -10,6 +10,14 @@ class PanelBasicController():
         "numero_repeticiones": 1
     }
 
+    url_panel_basic = "tecnicas/create_sesion/configuracion-panel-basic.html"
+    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_codes"
+
+    url_select_technique = "cata_system:seleccion_tecnica"
+
     def __init__(self):
         pass
 
@@ -23,7 +31,7 @@ class PanelBasicController():
         }
 
         response = render(
-            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
+            request, PanelBasicController.url_panel_basic, view_context)
         return response
 
     @staticmethod
@@ -44,11 +52,11 @@ class PanelBasicController():
                 response = redirect(
                     reverse("cata_system:panel_configuracion_tags"))
             else:
-                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                response = render(request, PanelBasicController.url_panel_basic, {
                     "form_sesion": form, "error": "Información no valida"})
         except KeyError:
             response = redirect(reverse(
-                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+                PanelBasicController.url_select_technique) + "?error=error en datos de configuracion")
 
         return response
 
@@ -63,7 +71,7 @@ class PanelBasicController():
         }
 
         response = render(
-            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
+            request, PanelBasicController.url_panel_basic, view_context)
         return response
 
     @staticmethod
@@ -88,7 +96,7 @@ class PanelBasicController():
                             key, f"Valor inválido para '{key}': se esperaba {expected}, se recibió {actual}")
 
                 if form.errors:
-                    response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                    response = render(request, PanelBasicController.url_panel_basic, {
                         "form_sesion": form, "error": "No puedes modificar el número de catadores o repeticiones"})
                 else:
                     values["name_tecnica"] = name_tecnica
@@ -96,10 +104,44 @@ class PanelBasicController():
                     response = redirect(
                         reverse("cata_system:panel_configuracion_tags"))
             else:
-                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                response = render(request, PanelBasicController.url_panel_basic, {
                     "form_sesion": form, "error": "Información no valida"})
         except KeyError:
             response = redirect(reverse(
-                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+                PanelBasicController.url_select_technique) + "?error=error en datos de configuracion")
+
+        return response
+
+    @staticmethod
+    def controllGetCATA(request: HttpRequest):
+        form_sesion = SesionBasicCATAForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "cata"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_cata, view_context)
+
+    @staticmethod
+    def controllPostCATA(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicCATAForm(request.POST)
+
+        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_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_cata))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic, {
+                "form_sesion": form, "error": "Información no valida"})
 
         return response

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(
+                        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/forms/__init__.py

@@ -1,7 +1,9 @@
-from .sesion_basic_form import SesionBasicForm
-from .sesion_tags_form import SesionTagsForm
+from .create_session.sesion_basic_form import SesionBasicForm
+from .create_session.sesiob_basic_cata_form import SesionBasicCATAForm
+from .create_session.sesion_tags_form import SesionTagsForm
+
 from .etiqueta_form import EtiquetaForm
 from .codes_form import CodesForm
 from .catador_form import CatadorForm
 from .word_form import WordForm
-from .vocabulary_select import VocabularioSelectForm
+from .vocabulary_select import VocabularioSelectForm

tecnicas/forms/create_session/sesiob_basic_cata_form.py

@@ -0,0 +1,27 @@
+from django import forms
+from tecnicas.models import EstiloPalabra
+
+
+class SesionBasicCATAForm(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)
+
+    instrucciones = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
+        "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
+        "placeholder": "Este campo es opcional"
+    }), required=False)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.fields['estilo_palabras'] = forms.ModelChoiceField(queryset=EstiloPalabra.objects.all(), widget=forms.RadioSelect(attrs={
+            "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
+        }), required=True, initial=EstiloPalabra.objects.first())

tecnicas/forms/{sesion_basic_form.py → create_session/sesion_basic_form.py}

@@ -1,7 +1,5 @@
 from django import forms
-from ..models import TipoEscala
-from ..models import TipoTecnica
-from ..models import EstiloPalabra
+from tecnicas.models import TipoEscala, EstiloPalabra
 
 
 class SesionBasicForm(forms.Form):

tecnicas/forms/{sesion_tags_form.py → create_session/sesion_tags_form.py}

@@ -1,5 +1,5 @@
 from django import forms
-from ..models import Etiqueta
+from tecnicas.models import Etiqueta
 
 
 class SesionTagsForm(forms.Form):

tecnicas/static/js/panel-basic-cata.js

@@ -0,0 +1,31 @@
+const descriptons = {
+  atributos:
+    "Con el estilo atributos elijes las palabras para evaluar los productos",
+  vocabulario:
+    "Los vocabularios son un conjunto de palabras específicas para evaluar aspectos de un producto",
+};
+
+const helpStyleWords = document.querySelector(".cts-help-style-words");
+let radiosStyleWords;
+
+function initRadiosStyleWords() {
+  radiosStyleWords = document.getElementsByName("estilo_palabras");
+
+  for (let index = 0; index < radiosStyleWords.length; index++) {
+    const radio = radiosStyleWords[index];
+
+    if (radio.checked) {
+      const radioOption = radio.parentElement.textContent.trim();
+      const textHelp = descriptons[radioOption];
+      helpStyleWords.textContent = textHelp;
+    }
+
+    radio.parentElement.addEventListener("click", (e) => {
+      const radioOption = radio.parentElement.textContent.trim();
+      const textHelp = descriptons[radioOption];
+      helpStyleWords.textContent = textHelp;
+    });
+  }
+}
+
+initRadiosStyleWords();

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/templates/tecnicas/create_sesion/panel-basic-cata.html

@@ -0,0 +1,85 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Panel Configuracion{% endblock %}
+
+{% block content %}
+<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 %}
+        {% 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="space-y-4">
+            {% csrf_token %}
+            <article class="space-y-4">
+                <h2 class="text-2xl font-bold">Información Basica</h2>
+
+                <section class="flex justify-center items-center">
+                    <label for="{{form_sesion.nombre_sesion.id_for_label}}"
+                        class="text-lg flex flex-col items-center px-2 w-fit font-medium tracking-wide mb-4">
+                        <p class="tracking-normal text-xl font-bold">Ingrese el nombre de la sesion si lo desea:</p>
+                        {{ form_sesion.nombre_sesion }}
+                    </label>
+                </section>
+
+                <section class="flex justify-center items-center">
+                    <label for="{{ form_sesion.numero_productos.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Productos:
+                        </p>
+                        {{ form_sesion.numero_productos }}
+                    </label>
+                </section>
+
+                <section class="flex justify-center items-center">
+                    <label for="{{form_sesion.instrucciones.id_for_label}}"
+                        class="text-lg flex flex-col items-center px-2 w-fit font-medium tracking-wide mb-4">
+                        <p class="tracking-normal text-base font-bold">Ingrese las instrucciones para la tecnica:</p>
+                        {{ form_sesion.instrucciones }}
+                    </label>
+                </section>
+            </article>
+
+            <article class="cs-escalas-radio flex flex-col gap-4">
+                <h2 class="text-2xl font-bold">Selecciona estilo para las palabras</h2>
+                <section class="flex flex-row gap-4 justify-around flex-wrap">
+                    {% for estilo in form_sesion.estilo_palabras %}
+                    <label for="{{estilo.id_for_label}}"
+                        class="ct-radio-estilo uppercase text-lg tracking-wider font-bold p-2 px-4 rounded-xl cts-btn-secondary btn-push">
+                        {{ estilo.tag }}
+                        {{ estilo.choice_label }}
+                    </label>
+                    {% endfor %}
+                </section>
+                <section class="w-full flex justify-center items-center">
+                    <p
+                        class="cts-help-style-words max-w-2xl text-lg font-medium tracking-wide bg-surface-card text-center py-1 px-4 rounded-xl">
+                    </p>
+                </section>
+            </article>
+
+            <article class="w-full flex max-sm:flex-col flex-wrap items-center justify-center gap-4">
+                <button type="submit" class="cts-btn-general cts-btn-primary btn-push flex-1/4 w-full">
+                    Continuar
+                </button>
+                <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1/4 w-full">
+                    <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
+                        Cancelar la creación
+                    </button>
+                </a>
+            </article>
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/panel-basic-cata.js' %}"></script>
+{% endblock %}

tecnicas/views/sessions_config/configuration_panel_basic.py

@@ -15,6 +15,8 @@ def configurationPanelBasic(req: HttpRequest):
             response = PanelBasicController.controllGetEscalas(request=req)
         elif name_tecnica == "rata":
             response = PanelBasicController.controllGetRATA(request=req)
+        elif name_tecnica == "cata":
+            response = PanelBasicController.controllGetCATA(request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida o sin implementar")
@@ -29,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

@@ -12,9 +12,10 @@ def createSession(req: HttpRequest):
                         "?error=datos requeridos no encontrados")
 
     basic_data = req.session["form_basic"]
+    name_technique = basic_data["name_tecnica"]
 
     if req.method == "GET":
-        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
+        if name_technique == "escalas" or name_technique == "rata" or name_technique == "cata":
             response = PanelCreateController.controllGetEscalas(req)
         else:
             response = redirect(
@@ -22,10 +23,12 @@ def createSession(req: HttpRequest):
 
         return response
     if req.method == "POST":
-        if basic_data["name_tecnica"] == "escalas":
+        if name_technique == "escalas":
             response = PanelCreateController.controllPostEscalas(req)
-        elif basic_data["name_tecnica"] == "rata":
+        elif name_technique == "rata":
             response = PanelCreateController.controllPostRATA(req)
+        elif name_technique == "cata":
+            response = PanelCreateController.controllPostCATA(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")