Merge pull request #21 from CascoArcilla/HU3

tecnicas/constants.py

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

tecnicas/controllers/__init__.py

@@ -18,4 +18,10 @@ from .views_controller.main_tester_form_controller import MainTesterFormControll
 from .views_controller.api_rating_controller import ApiRatingController
 from .views_controller.monitor_sesion_controller import MonitorSesionController
 from .views_controller.tester_list_controller import TesterListController
-from .views_controller.list_sessions_tester_controller import ListSessionsTesterController
+from .views_controller.list_sessions_tester_controller import ListSessionsTesterController
+
+from .views_controller.create_session.panel_basic_controller import PanelBasicController
+from .views_controller.create_session.panel_tags_controller import PanelTagsController
+from .views_controller.create_session.panel_codes_controller import PanelCodesController
+from .views_controller.create_session.panel_words_controller import PanelWordsController
+from .views_controller.create_session.panel_create_controller import PanelCreateController

tecnicas/controllers/models_controller/escala_controller.py

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

tecnicas/controllers/models_controller/ordenes_controller.py

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

tecnicas/controllers/models_controller/palabras_controller.py

@@ -17,7 +17,7 @@ class PalabrasController():
         self.words = []
         searched_words = list(Palabra.objects.filter(id__in=self.ids_words))
         if not len(searched_words):
-            return controller_error("no se han encontrado registros")
+            return controller_error("No se han encontrado registros")
         self.words = searched_words
         return self.words
 

tecnicas/controllers/models_controller/sesion_controller.py

@@ -18,9 +18,9 @@ class SesionController():
 
     def setSession(self):
         if not self.presenter:
-            return controller_error("se requiere presentador para crear sesion")
+            return controller_error("Se requiere presentador para crear sesión")
         elif not self.technique:
-            return controller_error("se requiere tecnica para crear sesion")
+            return controller_error("Se requiere técnica para crear sesión")
 
         self.sensorial_session = SesionSensorial(
             tecnica=self.technique,
@@ -34,13 +34,13 @@ class SesionController():
 
     def saveSession(self):
         if not self.sensorial_session:
-            return controller_error("no se ha definido la sesion a guardar")
+            return controller_error("No se ha definido la sesión a guardar")
 
         try:
             self.sensorial_session.save()
             return self.sensorial_session
         except DatabaseError as error:
-            return controller_error("Error al crear la session sensorial")
+            return controller_error("Error al crear la sesión sensorial")
 
     @staticmethod
     def getSessionsSavesByCretor(user_name: str, page: int):
@@ -122,7 +122,7 @@ class SesionController():
 
             return number_sessions/9
         except Presentador.DoesNotExist:
-            return controller_error("presentador invalido")
+            return controller_error("Presentador invalido")
 
     @staticmethod
     def finishRepetion(session: SesionSensorial | str):

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -15,7 +15,7 @@ class TecnicaController():
 
     def setTechniqueFromBasicData(self, basic):
         self.technique = Tecnica(
-            tipo_tecnica=TipoTecnica.objects.get(id=basic["id_tecnica"]),
+            tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=basic["name_tecnica"]),
             id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
             repeticiones_max=basic["numero_repeticiones"] or 0,
             limite_catadores=basic["numero_catadores"],
@@ -30,7 +30,7 @@ class TecnicaController():
             self.technique.save()
             return self.technique
         except DatabaseError:
-            return controller_error("No se ha podido guardar la tecnica")
+            return controller_error("No se ha podido guardar la técnica")
 
     def deleteTechnique(self):
         self.technique.delete()

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -0,0 +1,42 @@
+from tecnicas.forms import SesionBasicForm
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+
+
+class PanelBasicController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGetEscalas(request: HttpRequest):
+        form_sesion = SesionBasicForm()
+        response = render(
+            request, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form_sesion})
+        return response
+
+    @staticmethod
+    def controllPostEscalas(request: HttpRequest, name_tecnica: str):
+        try:
+            form = SesionBasicForm(request.POST)
+
+            if form.is_valid():
+                values = {}
+                for name, value in form.cleaned_data.items():
+                    if name == "estilo_palabras" or name == "tipo_escala":
+                        values[name] = value.id
+                    else:
+                        values[name] = value
+
+                values["name_tecnica"] = name_tecnica
+                request.session['form_basic'] = values
+                response = redirect(
+                    reverse("cata_system:panel_configuracion_tags"))
+            else:
+                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                    "form_sesion": form, "error": "Información no valida"})
+        except KeyError:
+            response = redirect(reverse(
+                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

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

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

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

tecnicas/controllers/views_controller/create_session/panel_tags_controller.py

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

tecnicas/controllers/views_controller/create_session/panel_words_controller.py

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

tecnicas/forms/sesion_basic_form.py

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

tecnicas/forms/sesion_tags_form.py

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

tecnicas/static/js/panel-basic.js

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

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

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

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

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

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

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

tecnicas/utils/__init__.py

@@ -3,4 +3,5 @@ from .code_generate import generarCodigos
 from .personal_errors import general_error, controller_error
 from .shuffle_arrays import shuffleArray
 from .general_controllers import getId
-from .to_dict import defaultdict_to_dict
+from .to_dict import defaultdict_to_dict
+from .delete_data_session import deleteDataSession

tecnicas/utils/delete_data_session.py

@@ -0,0 +1,10 @@
+from django.http import HttpRequest
+from tecnicas.constants import FORMS_TO_CREATE_SESSION
+from .personal_errors import general_error
+
+
+def deleteDataSession(request: HttpRequest):
+    for key in FORMS_TO_CREATE_SESSION:
+        if key in request.session:
+            del request.session[key]
+    return True

tecnicas/views/sessions_config/configuration_panel_basic.py

@@ -1,52 +1,33 @@
-from django.shortcuts import render, redirect
-from django.http import HttpRequest
+from django.shortcuts import redirect
+from django.http import HttpRequest, JsonResponse
 from django.urls import reverse
-from ...forms import SesionBasicForm
-from ...models import TipoTecnica
+from tecnicas.controllers import PanelBasicController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelBasic(req: HttpRequest):
-    keys_forms = [
-        "form_basic",
-        "form_tags",
-        "form_codes",
-        "form_words"
-    ]
+    deleteDataSession(req)
+    
+    if req.method == "GET":
+        name_tecnica = req.GET["name_tecnica"]
 
-    for key in keys_forms:
-        if key in req.session:
-            del req.session[key]
-
-    if req.method == "POST":
-        try:
-            form = SesionBasicForm(req.POST)
-
-            if form.is_valid():
-                values = {}
-
-                for name, value in form.cleaned_data.items():
-                    if name == "estilo_palabras" or name == "tipo_escala":
-                        values[name] = value.id
-                    else:
-                        values[name] = value
-
-                req.session['form_basic'] = values
-                return redirect(reverse("cata_system:panel_configuracion_tags"))
-        except KeyError:
-            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+        if name_tecnica == "escalas":
+            response = PanelBasicController.controllGetEscalas(request=req)
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida o sin implementar")
 
-        return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form, "error": "Ha ocurrido un error al continuar al siguiente paso."})
-    elif req.method == "GET":
-        try:
-            id_tecnica = req.GET["id_tecnica"]
-            tecnica = TipoTecnica.objects.get(pk=id_tecnica)
-        except KeyError:
-            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=tecnica_no_establecida")
-        except (ValueError, TipoTecnica.DoesNotExist):
-            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=tecnica_no_establecida")
+        return response
+    elif req.method == "POST":
+        name_tecnica = req.GET["name_tecnica"]
 
-        if tecnica:
-            form_sesion = SesionBasicForm(id_tecnica_new=id_tecnica)
-            return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form_sesion})
+        if name_tecnica == "escalas":
+            response = PanelBasicController.controllPostEscalas(
+                request=req, name_tecnica=name_tecnica)
         else:
-            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=la_tecnica_no_existe")
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=¡Oh, vaya! Cambio de técnica repentino, vuelve a elegir otra vez")
+
+        return response
+    else:
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/configuration_panel_codes.py

@@ -1,59 +1,35 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse
-from ...utils import generarCodigos
-from ...forms import CodesForm
-import json
+from tecnicas.controllers import PanelCodesController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelCodes(req: HttpRequest):
-    if not req.session.get("form_basic") or not req.session.get("form_tags"):
-        req.session.flush()
+    if not req.session["form_basic"]:
+        deleteDataSession(req)
         return redirect(reverse("cata_system:seleccion_tecnica") +
                         "?error=datos del formulario requerido no encontrados")
-
+    
     data_basic = req.session["form_basic"]
 
-    num_products = data_basic["numero_productos"]
-    num_tester = data_basic["numero_catadores"]
-
     if req.method == "GET":
-        codes_products = generarCodigos(num_products)
-
-        form_codes = CodesForm(codes=codes_products)
-
-        context_codes_form = {
-            "form_codes": form_codes,
-            "num_tester": num_tester
-        }
-
-        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+        if data_basic["name_tecnica"] == "escalas":
+            response = PanelCodesController.controllGetEscalas(
+                req, data_basic)
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
+            
+        return response
     elif req.method == "POST":
-        sorts_code = json.loads(req.POST.get("sort_codes"))
-        codes = []
-        context_codes_form = {}
-
-        for name, value in req.POST.items():
-            if name.__contains__("producto_"):
-                codes.append(value)
-
-        form_codes = CodesForm(req.POST, codes=codes)
-
-        context_codes_form = {
-            "form_codes": form_codes,
-            "num_tester": num_tester,
-        }
-
-        if form_codes.is_valid():
-            codes_sort = {"product_codes": []}
-
-            for name, value in form_codes.cleaned_data.items():
-                codes_sort["product_codes"].append({name: value})
-
-            codes_sort["sort_codes"] = sorts_code
-            req.session["form_codes"] = codes_sort
-            return redirect(reverse("cata_system:panel_configuracion_words"))
+        if data_basic["name_tecnica"] == "escalas":
+            response = PanelCodesController.controllPostEscalas(
+                req, data_basic)
         else:
-            context_codes_form["error"] = "error en los datos recibidos"
-
-        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
+            
+        return response
+    else:
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/configuration_panel_tags.py

@@ -1,46 +1,34 @@
-from django.http import HttpRequest
-from django.shortcuts import redirect, render
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse
-from ...forms import SesionTagsForm, EtiquetaForm
-from ...models import TipoEscala
+from tecnicas.controllers import PanelTagsController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelTags(req: HttpRequest):
-    basic_data = req.session.get("form_basic", {})
-
-    if not basic_data:
-        return redirect(reverse('cata_system:panel_configuracion_basic'))
-
-    type_scale = TipoEscala.objects.get(pk=basic_data["tipo_escala"])
-    tamano_escala = basic_data["tamano_escala"]
-    form_new_etiqueta = EtiquetaForm()
+    if not req.session.get("form_basic"):
+        deleteDataSession(req)
+        return redirect(reverse('cata_system:panel_configuracion_basic') +
+                        "?error=datos requeridos no encontrados")
+    
+    basic_data = req.session.get("form_basic")
 
     if req.method == "GET":
-        form_etiqutas = SesionTagsForm(
-            longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
-
-        context_tags = {
-            "form_tags": form_etiqutas,
-            "form_new_tag": form_new_etiqueta
-        }
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelTagsController.controllGetEscalas(
+                request=req, data=basic_data)
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
 
-        return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+        return response
     elif req.method == "POST":
-        values = {}
-        form = SesionTagsForm(req.POST, longitud=tamano_escala,
-                              tipo_escala=type_scale.nombre_escala)
-
-        context_tags = {
-            "form_tags": form,
-            "form_new_tag": form_new_etiqueta
-        }
-
-        if form.is_valid():
-            for name, value in form.cleaned_data.items():
-                values[name] = value.id
-
-            req.session["form_tags"] = values
-            return redirect(reverse("cata_system:panel_configuracion_codes"))
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelTagsController.controllPostEscalas(
+                request=req, data=basic_data)
         else:
-            context_tags["error"] = "ha ocurrido un error"
-            return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
+        return response
+    else:
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/configuration_panel_words.py

@@ -1,44 +1,33 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse
-from ...models.palabra import Palabra
-from ...forms import WordForm
-
-import json
+from tecnicas.controllers import PanelWordsController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelWords(req: HttpRequest):
-    if not req.session.get("form_basic") or not req.session.get("form_tags") or not req.session.get("form_codes"):
-        req.session.flush()
+    if not req.session.get("form_basic"):
+        deleteDataSession(req)
         return redirect(reverse("cata_system:seleccion_tecnica") +
-                        "?error=datos del formulario requerido no encontrados")
+                        "?error=datos requeridos no encontrados")
 
-    form = WordForm()
-    context = {
-        "form_word": form
-    }
+    basic_data = req.session["form_basic"]
 
     if req.method == "GET":
-        return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
-    elif req.method == "POST":
-        if not req.POST.get("words"):
-            return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
-
-        words = json.loads(req.POST.get("words"))
-        context["words"] = words
-
-        ids_words = [word["id"] for word in words]
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelWordsController.controllGetEscalas(req)
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
 
-        if len(ids_words) != len(set(ids_words)):
-            context["error"] = "existen palabras duplicadas"
-            return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
-
-        exist_words = Palabra.objects.filter(
-            id__in=ids_words).count() == len(ids_words)
-
-        if not exist_words:
-            context["error"] = "algunas palabras no existen"
-            return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
-
-        req.session["form_words"] = ids_words
-        return redirect(reverse("cata_system:creando_sesion"))
+        return response
+    elif req.method == "POST":
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelWordsController.controllPostEscalas(req)
+        else:
+            response = redirect(
+                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

@@ -1,170 +1,34 @@
 from django.http import HttpRequest, JsonResponse
-from django.shortcuts import render
-from ...utils import general_error
-from ...controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
-from ...models import Presentador
-from django.db import transaction
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.controllers import PanelCreateController
+from tecnicas.utils import deleteDataSession
 
 
 def createSession(req: HttpRequest):
-    if req.method == "GET":
-        return render(req, 'tecnicas/create_sesion/creando_sesion.html')
-    if req.method == "POST":
-        if req.POST.get('action') == 'create_session':
-            if not req.session.get("form_basic") or not req.session.get("form_tags") or not req.session.get("form_codes") or not req.session.get("form_words"):
-                req.session.flush()
-                return general_error("no se ha especificado informacion necesaria para la creacion de la sesion")
-
-            with transaction.atomic():
-                # ////////////////////////////////////////////////////// #
-                #
-                # First step: Create technique and scale with their tags #
-                #
-                # ////////////////////////////////////////////////////// #
-                data_basic = req.session["form_basic"]
-                controllerTechnique = TecnicaController()
-                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
-
-                technique = controllerTechnique.saveTechnique()
-                if not technique:
-                    return general_error("error al guardar la tecnica")
-
-                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):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(scale["error"])
-
-                dict_tags = req.session["form_tags"]
-                saved_related_tags = controllerScale.realteTags(dict_tags)
-                if "error" in saved_related_tags:
-                    return general_error(saved_related_tags["error"])
-
-                # ////////////////////////////////////////////////////////// #
-                #
-                # Second step: Create orders, productos and set the position #
-                #
-                # ////////////////////////////////////////////////////////// #
-                data_codes = req.session["form_codes"]
-
-                list_codes_dict = data_codes["product_codes"]
-
-                codes = []
-                for product in list_codes_dict:
-                    code = next(iter(product.values()))
-                    codes.append(code)
-
-                controllerProducts = ProductosController(
-                    codes=codes,
-                    technique=technique
-                )
-
-                controllerProducts.setProductsNoSave()
-                saved_prodcuts = controllerProducts.saveProducts()
-                if isinstance(saved_prodcuts, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(saved_prodcuts["error"])
-
-                raw_sort_codes = data_codes["sort_codes"]
-                controllerOrdes = OrdenesController(
-                    raw_orders=raw_sort_codes,
-                    list_products=saved_prodcuts,
-                    technique=technique
-                )
-
-                controllerOrdes.setOrdersToSave()
-                saved_orders = controllerOrdes.saveOrders()
-                if isinstance(saved_orders, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(saved_orders["error"])
+    if not req.session.get("form_basic"):
+        deleteDataSession(req)
+        return redirect(reverse("cata_system:seleccion_tecnica") +
+                        "?error=datos requeridos no encontrados")
 
-                seded_positions = controllerOrdes.setPositions()
-                if isinstance(seded_positions, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(seded_positions["error"])
+    basic_data = req.session["form_basic"]
 
-                saved_postions = controllerOrdes.savePositions()
-                if isinstance(saved_postions, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(saved_prodcuts["error"])
-
-                # /////////////////////////////////////////////////////// #
-                #
-                # Third step: Create relations technique with Words Style #
-                #
-                # /////////////////////////////////////////////////////// #
-                ids_words = req.session["form_words"]
-                words_controller = PalabrasController(ids=ids_words)
-
-                words_to_use = words_controller.setWords()
-                if isinstance(words_to_use, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(words_to_use["error"])
-
-                style_controller = EstiloPalabrasController(
-                    technique=technique, words=words_to_use)
-
-                instace_style = style_controller.createAndSaveInstaceStyle()
-                if isinstance(instace_style, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(instace_style["error"])
-
-                words_using = style_controller.relatedWords()
-                if isinstance(words_using, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(words_using["error"])
-
-                # //////////////////////////////////////////////////////// #
-                #
-                # Fourth step: Create session and relat with the technique #
-                #
-                # //////////////////////////////////////////////////////// #
-                session_controller = SesionController(
-                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                    technique=technique,
-                    creator=req.user.user_presentador
-                )
-
-                setting_session = session_controller.setSession()
-                if isinstance(setting_session, dict):
-                    controllerTechnique.deleteTechnique()
-                    return general_error(setting_session["error"])
-
-                saved_session = session_controller.saveSession()
-                if isinstance(saved_session, dict):
-                    return general_error(saved_session["error"])
-
-                context = {
-                    "message": "sesion creada",
-                    "data": {
-                        "codigo_sesion": saved_session.codigo_sesion,
-                        "nombre_sesion": saved_session.nombre_sesion
-                    }
-                }
-
-                # /////////////////////////////// #
-                #
-                # Final step: Delete session keys #
-                #
-                # /////////////////////////////// #
-
-                keys_forms = [
-                    "form_basic",
-                    "form_tags",
-                    "form_codes",
-                    "form_words"
-                ]
-
-                for key in keys_forms:
-                    if key in req.session:
-                        del req.session[key]
-
-                return JsonResponse(context)
-        return general_error("ha orcurrido un error inesperado")
+    if req.method == "GET":
+        if basic_data["name_tecnica"] == "escalas":
+            response = render(
+                req, 'tecnicas/create_sesion/creando_sesion.html')
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
+
+        return response
+    if req.method == "POST":
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelCreateController.controllPostEscalas(req)
+        else:
+            response = redirect(
+                reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
+
+        return response
+    else:
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/seleccion_tecnica.py

@@ -1,7 +1,6 @@
 from django.shortcuts import render
 from django.http import HttpRequest
-
-from ...controllers  import TecnicaController
+from tecnicas.controllers  import TecnicaController
 
 def selecionTecnica(req:HttpRequest):
     tipos = TecnicaController.getTypesTechnique()