Creacion de sesion con Sort y refactorizacion de codigo para crear sesiones

tecnicas/controllers/__init__.py

@@ -16,7 +16,12 @@ from .views_controller.create_session.panel_basic_controller import PanelBasicCo
 from .views_controller.create_session.panel_tags_controller import PanelTagsController
 from .views_controller.create_session.panel_codes_controller import PanelCodesController
 from .views_controller.create_session.panel_words_controller import PanelWordsController
-from .views_controller.create_session.panel_create_controller import PanelCreateController
+
+from .views_controller.create_session.panels_create.panel_create_escalas_controller import PanelCreateEscalasController
+from .views_controller.create_session.panels_create.panel_create_rata_controller import PanelCreateRataController
+from .views_controller.create_session.panels_create.panel_create_cata_controller import PanelCreateCataController
+from .views_controller.create_session.panels_create.panel_create_pf_controller import PanelCreatePFController
+from .views_controller.create_session.panels_create.panel_create_sort_controller import PanelCreateSortController
 
 from .views_controller.session_management.details_controller import DetallesController
 from .views_controller.session_management.details_escala_controller import DetallesEscalasController

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -1,4 +1,4 @@
-from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm, SesionBasicPFForm
+from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm, SesionBasicPFForm, SesionBasicSortForm
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
@@ -13,6 +13,7 @@ class PanelBasicController():
     url_panel_basic = "tecnicas/create_sesion/conf-panel-basic.html"
     url_panel_basic_cata = "tecnicas/create_sesion/panel-basic-cata.html"
     url_panel_basic_pf = "tecnicas/create_sesion/panel-basic-pf.html"
+    url_panel_basic_sort = "tecnicas/create_sesion/panel-basic-sort.html"
 
     url_next_panel_tags = "cata_system:panel_configuracion_tags"
     url_next_panel_codes = "cata_system:panel_configuracion_codes"
@@ -164,7 +165,6 @@ class PanelBasicController():
         form = SesionBasicPFForm(request.POST)
 
         if form.is_valid():
-            print(form.cleaned_data)
             values = {}
             for name, value in form.cleaned_data.items():
                 values[name] = value
@@ -189,4 +189,23 @@ class PanelBasicController():
         }
 
         return render(
-            request, PanelBasicController.url_panel_basic_pf, view_context)
+            request, PanelBasicController.url_panel_basic_sort, view_context)
+
+    @staticmethod
+    def controllPostSort(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicSortForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_sort, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -139,3 +139,27 @@ class PanelCodesController():
             context_codes_form["error"] = "error en los datos recibidos"
 
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
+
+    @staticmethod
+    def controllPostSort(request: HttpRequest):
+        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,
+            "use_technique": "sort"
+        }
+
+        if form_codes.is_valid():
+            request.session["form_codes"] = codes
+            return redirect(reverse(PanelCodesController.url_create_session))
+        else:
+            context_codes_form["error"] = "error en los datos recibidos"
+
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,71 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Panel Configuracion{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black">
+        <h1 class="text-center font-bold text-4xl">Panel de configuración</h1>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
+        <form method="post" action="" class="space-y-4">
+            {% csrf_token %}
+            <article>
+                <h2 class="text-2xl mb-2 font-bold">Información Basica</h2>
+                <section class="flex justify-center items-center">
+                    <label for="{{form_sesion.nombre_sesion.id_for_label}}"
+                        class="text-lg flex flex-col items-center px-2 w-full font-medium tracking-wide mb-4">
+                        <p class="tracking-normal text-xl font-bold">Nombre del proyecto:</p>
+                        {{ form_sesion.nombre_sesion }}
+                    </label>
+                </section>
+                <section class="flex flex-row flex-wrap justify-center gap-4">
+                    <label for="{{ form_sesion.numero_productos.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Productos:
+                        </p>
+                        {{ form_sesion.numero_productos }}
+                    </label>
+                    <label for="{{ form_sesion.numero_catadores.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Catadores:
+                        </p>
+                        {{ form_sesion.numero_catadores }}
+                    </label>
+                </section>
+                <section class="flex justify-center items-center mt-2">
+                    <label for="{{form_sesion.instrucciones.id_for_label}}"
+                        class="text-lg flex flex-col items-center px-2 w-full font-medium tracking-wide mb-4">
+                        <p class="tracking-normal text-base font-bold">Instrucciones para la sesión:</p>
+                        {{ form_sesion.instrucciones }}
+                    </label>
+                </section>
+            </article>
+
+            <article class="w-full flex max-sm:flex-col flex-wrap items-center justify-center gap-4">
+                <button type="submit" class="cts-btn-general cts-btn-primary btn-push flex-1/4 w-full">
+                    Continuar
+                </button>
+                <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1/4 w-full">
+                    <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
+                        Cancelar la creación
+                    </button>
+                </a>
+            </article>
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/panel-basic.js' %}"></script>
+{% endblock %}

tecnicas/views/sessions_config/configuration_panel_basic.py

@@ -20,8 +20,7 @@ def configurationPanelBasic(req: HttpRequest):
         elif name_tecnica == "perfil flash":
             response = PanelBasicController.controllGetPF(request=req)
         elif name_tecnica == "sort":
-            response = JsonResponse(
-                {"message": "Trabajando en la implementación"})
+            response = PanelBasicController.controllGetSort(request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida o sin implementar")
@@ -42,6 +41,9 @@ def configurationPanelBasic(req: HttpRequest):
         elif name_tecnica == "perfil flash":
             response = PanelBasicController.controllPostPF(
                 request=req, name_tecnica=name_tecnica)
+        elif name_tecnica == "sort":
+            response = PanelBasicController.controllPostSort(
+                request=req, name_tecnica=name_tecnica)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=¡Oh, vaya! Cambio de técnica repentino, vuelve a elegir otra vez")

tecnicas/views/sessions_config/configuration_panel_codes.py

@@ -18,7 +18,7 @@ def configurationPanelCodes(req: HttpRequest):
         if name_technique == "escalas":
             response = PanelCodesController.controllGetEscalas(
                 req, data_basic)
-        elif name_technique == "rata" or name_technique == "cata" or "perfil flash":
+        elif name_technique == "rata" or name_technique == "cata" or name_technique == "perfil flash" or name_technique == "sort":
             response = PanelCodesController.controllGetRATA(
                 request=req, data=data_basic, name_technique=name_technique)
         else:
@@ -38,6 +38,9 @@ def configurationPanelCodes(req: HttpRequest):
         elif name_technique == "perfil flash":
             response = PanelCodesController.controllPostPF(
                 request=req)
+        elif name_technique == "sort":
+            response = PanelCodesController.controllPostSort(
+                request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")

tecnicas/views/sessions_config/create_session.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.controllers import PanelCreateController
+from tecnicas.controllers import PanelCreateEscalasController, PanelCreateRataController, PanelCreateCataController, PanelCreatePFController, PanelCreateSortController
 from tecnicas.utils import deleteDataSession
 
 
@@ -15,8 +15,16 @@ def createSession(req: HttpRequest):
     name_technique = basic_data["name_tecnica"]
 
     if req.method == "GET":
-        if name_technique == "escalas" or name_technique == "rata" or name_technique == "cata" or name_technique == "perfil flash":
-            response = PanelCreateController.controllGetEscalas(req)
+        if name_technique == "escalas":
+            response = PanelCreateEscalasController.controllGet(req)
+        elif name_technique == "rata":
+            response = PanelCreateRataController.controllGet(req)
+        elif name_technique == "cata":
+            response = PanelCreateCataController.controllGet(req)
+        elif name_technique == "perfil flash":
+            response = PanelCreatePFController.controllGet(req)
+        elif name_technique == "sort":
+            response = PanelCreateSortController.controllGet(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
@@ -24,13 +32,15 @@ def createSession(req: HttpRequest):
         return response
     if req.method == "POST":
         if name_technique == "escalas":
-            response = PanelCreateController.controllPostEscalas(req)
+            response = PanelCreateEscalasController.controllPost(req)
         elif name_technique == "rata":
-            response = PanelCreateController.controllPostRATA(req)
+            response = PanelCreateRataController.controllPost(req)
         elif name_technique == "cata":
-            response = PanelCreateController.controllPostCATA(req)
+            response = PanelCreateCataController.controllPost(req)
         elif name_technique == "perfil flash":
-            response = PanelCreateController.controllPostPF(req)
+            response = PanelCreatePFController.controllPost(req)
+        elif name_technique == "sort":
+            response = PanelCreateSortController.controllPost(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")