Switch para creacion de session con tecnica escalas

tecnicas/constants.py

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

tecnicas/controllers/__init__.py

@@ -23,3 +23,5 @@ from .views_controller.list_sessions_tester_controller import ListSessionsTester
 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

@@ -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

@@ -9,14 +9,14 @@ class PanelBasicController():
         pass
 
     @staticmethod
-    def controllGetConvencional(request: HttpRequest):
+    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 controllPostConvencional(request: HttpRequest, name_tecnica: str):
+    def controllPostEscalas(request: HttpRequest, name_tecnica: str):
         try:
             form = SesionBasicForm(request.POST)
 

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -11,7 +11,7 @@ class PanelCodesController():
         pass
 
     @staticmethod
-    def controllGetConvencional(request: HttpRequest, data):
+    def controllGetEscalas(request: HttpRequest, data):
         (
             num_products,
             num_tester
@@ -29,7 +29,7 @@ class PanelCodesController():
         return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
 
     @staticmethod
-    def controllPostConvencional(request: HttpRequest, data):
+    def controllPostEscalas(request: HttpRequest, data):
         (
             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

@@ -10,7 +10,7 @@ class PanelTagsController():
         pass
 
     @staticmethod
-    def controllGetConvencional(request: HttpRequest, data):
+    def controllGetEscalas(request: HttpRequest, data):
         (
             type_scale,
             tamano_escala,
@@ -28,7 +28,7 @@ class PanelTagsController():
         return render(request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
 
     @staticmethod
-    def controllPostConvencional(request: HttpRequest, data):
+    def controllPostEscalas(request: HttpRequest, data):
         (
             type_scale,
             tamano_escala,

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/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,27 +1,18 @@
-from django.shortcuts import render, redirect
+from django.shortcuts import redirect
 from django.http import HttpRequest, JsonResponse
 from django.urls import reverse
-from tecnicas.forms import SesionBasicForm
 from tecnicas.controllers import PanelBasicController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelBasic(req: HttpRequest):
-    keys_forms = [
-        "form_basic",
-        "form_tags",
-        "form_codes",
-        "form_words"
-    ]
-
-    for key in keys_forms:
-        if key in req.session:
-            del req.session[key]
-
+    deleteDataSession(req)
+    
     if req.method == "GET":
         name_tecnica = req.GET["name_tecnica"]
 
         if name_tecnica == "escalas":
-            response = PanelBasicController.controllGetConvencional(request=req)
+            response = PanelBasicController.controllGetEscalas(request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida o sin implementar")
@@ -31,7 +22,7 @@ def configurationPanelBasic(req: HttpRequest):
         name_tecnica = req.GET["name_tecnica"]
 
         if name_tecnica == "escalas":
-            response = PanelBasicController.controllPostConvencional(
+            response = PanelBasicController.controllPostEscalas(
                 request=req, name_tecnica=name_tecnica)
         else:
             response = redirect(

tecnicas/views/sessions_config/configuration_panel_codes.py

@@ -2,18 +2,20 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import redirect
 from django.urls import reverse
 from tecnicas.controllers import PanelCodesController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelCodes(req: HttpRequest):
-    data_basic = req.session["form_basic"]
-    if not data_basic:
-        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"]
 
     if req.method == "GET":
         if data_basic["name_tecnica"] == "escalas":
-            response = PanelCodesController.controllGetConvencional(
+            response = PanelCodesController.controllGetEscalas(
                 req, data_basic)
         else:
             response = redirect(
@@ -22,7 +24,7 @@ def configurationPanelCodes(req: HttpRequest):
         return response
     elif req.method == "POST":
         if data_basic["name_tecnica"] == "escalas":
-            response = PanelCodesController.controllPostConvencional(
+            response = PanelCodesController.controllPostEscalas(
                 req, data_basic)
         else:
             response = redirect(

tecnicas/views/sessions_config/configuration_panel_tags.py

@@ -2,16 +2,20 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import redirect
 from django.urls import reverse
 from tecnicas.controllers import PanelTagsController
+from tecnicas.utils import deleteDataSession
 
 
 def configurationPanelTags(req: HttpRequest):
+    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 not basic_data:
-        return redirect(reverse('cata_system:panel_configuracion_basic'))
 
     if req.method == "GET":
         if basic_data["name_tecnica"] == "escalas":
-            response = PanelTagsController.controllGetConvencional(
+            response = PanelTagsController.controllGetEscalas(
                 request=req, data=basic_data)
         else:
             response = redirect(
@@ -19,8 +23,12 @@ def configurationPanelTags(req: HttpRequest):
 
         return response
     elif req.method == "POST":
-        response = PanelTagsController.controllPostConvencional(
-            request=req, data=basic_data)
+        if basic_data["name_tecnica"] == "escalas":
+            response = PanelTagsController.controllPostEscalas(
+                request=req, data=basic_data)
+        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/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"})