Creacion de session sensorial escalas

tecnicas/admin.py

@@ -19,6 +19,8 @@ from .models import Etiqueta
 from .models import Escala
 from .models import EtiquetasEscala
 
+from .models import Producto
+
 # Register your models here.
 admin.site.register(CategoriaTecnica)
 admin.site.register(TipoEscala)
@@ -36,4 +38,6 @@ admin.site.register(EsAtributo)
 admin.site.register(Palabra)
 
 admin.site.register(Escala)
-admin.site.register(EtiquetasEscala)
+admin.site.register(EtiquetasEscala)
+
+admin.site.register(Producto)

tecnicas/controllers/__init__.py

@@ -5,3 +5,4 @@ from .ordenes_controller import OrdenesController
 from .palabras_controller import PalabrasController
 from .estilo_palabras_controller import EstiloPalabrasController
 from .palabras_controller import PalabrasController
+from .sesion_controller import SesionController

tecnicas/controllers/escala_controller.py

@@ -1,21 +1,22 @@
-from ..models import Etiqueta, EtiquetasEscala, Escala
+from ..models import Etiqueta, EtiquetasEscala, Escala, TipoEscala
 from django.db import DatabaseError
+from ..utils import controller_error
 
 
 class EscalaController():
     scale: Escala
-    tags: list[tuple[str, EtiquetasEscala]]
+    tags_relation: dict[str, EtiquetasEscala]
 
     def __init__(self, data):
         self.scale = Escala(
-            id_tipo_escala=data["scale"],
+            id_tipo_escala=TipoEscala.objects.get(id=data["id_scale"]),
             longitud=data["size"],
             tecnica=data["technique"]
         )
 
     def setScale(self, newData):
         self.scale = Escala(
-            id_tipo_escala=newData["scale"],
+            id_tipo_escala=TipoEscala.objects.get(id=newData["id_scale"]),
             longitud=newData["size"],
             tecnica=newData["technique"]
         )
@@ -23,76 +24,47 @@ class EscalaController():
     def saveScale(self):
         try:
             self.scale.save()
-        except Exception:
-            return False
-        return self.scale
+            return self.scale
+        except DatabaseError as error:
+            return controller_error("error al guardar la escala")
 
     def deleteScale(self):
         self.scale.delete()
 
-    def addAndSaveTags(self, tags: list):
+    def addAndSaveTags(self, tags: dict):
+        self.tags_relation = {}
         if self.scale.id_tipo_escala.nombre_escala == "cotinua":
-            if not self.realte_tags_type_cotinue(tags):
-                return False
+            ok_tags = self.realte_tags_type_cotinue(tags)
+            if ok_tags["error"]:
+                return ok_tags
+            return self.tags_relation
+
         elif self.scale.id_tipo_escala.nombre_escala == "estructurada":
-            if not self.realte_tags_type_structure(tags):
-                return False
-        return self.tags
+            ok_tags = self.realte_tags_type_structure(tags)
+            if ok_tags["error"]:
+                return ok_tags
+            return self.tags_relation
 
     def deleteRelationshipsWithLabels(self):
-        for tuple in self.tags:
-            relaTag = tuple[1]
-            relaTag.adelete()
-
-    def realte_tags_type_cotinue(self, tags: list):
-        try:
-            tag_start = Etiqueta.objects.get(id=tags["punto_inicial"])
-            start_point = EtiquetasEscala.objects.create(
-                id_escala=self.scale.id,
-                id_etiqueta=tag_start,
-                posicion=1
-            )
-
-            self.tags.append(("start", start_point))
-
-            tag_medium = Etiqueta.objects.get(id=tags["punto_medio"])
-            half_point = EtiquetasEscala.objects.create(
-                id_escala=self.scale.id,
-                id_etiqueta=tag_medium,
-                posicion=2
-            )
-
-            self.tags.append(("medium", half_point))
-
-            tag_end = Etiqueta.objects.get(id=tags["punto_final"])
-            end_point = EtiquetasEscala.objects.create(
-                id_escala=self.scale.id,
-                id_etiqueta=tag_end,
-                posicion=3
-            )
-
-            self.tags.append(("end", end_point))
-            return True
-        except DatabaseError as error:
-            self.deleteRelationshipsWithLabels()
-            return False
+        for name, tag in self.tags_relation.items():
+            tag.delete()
 
-    def realte_tags_type_structure(self, tags: dict):
+    def realteTags(self, tags: dict):
         try:
             index = 1
-            self.tags = []
+            self.tags_relation = {}
 
             for name, id_tag in tags.items():
                 tag = Etiqueta.objects.get(id=id_tag)
-                related_tag = EtiquetasEscala(
-                    id_escala=self.scale.id,
+                related_tag = EtiquetasEscala.objects.create(
+                    id_escala=self.scale,
                     id_etiqueta=tag,
                     posicion=index
                 )
-                self.tags.append((name, related_tag))
+                self.tags_relation[name] = related_tag
                 index += 1
 
-            return True
+            return self.tags_relation
         except DatabaseError as error:
             self.deleteRelationshipsWithLabels()
-            return False
+            return controller_error("error guardar relacion etiqueta escala")

tecnicas/controllers/estilo_palabras_controller.py

@@ -20,7 +20,7 @@ class EstiloPalabrasController():
                 id_tecnica=self.technique)
             return self.instanceStyle
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al registrar el estilo con tecnica")
 
     def relatedWords(self):
         if not self.list_words:
@@ -29,4 +29,4 @@ class EstiloPalabrasController():
             self.instanceStyle.palabras.add(*self.list_words)
             return self.instanceStyle.palabras
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al relacionar palabras con el estilo tecnica")

tecnicas/controllers/ordenes_controller.py

@@ -6,78 +6,71 @@ from django.db import DatabaseError
 class OrdenesController():
     products: list[Producto]
     technique: Tecnica
-    raw_list_orders: list[list[dict]]
+    raw_list_orders: list[dict]
     orders: list[Orden]
-    orders_save: list[Orden]
     positions: list[Posicion]
-    savePostions: list[Posicion]
 
-    def __init__(self, raw_orders: list[list[dict]], list_products: list[Producto], technique: Tecnica):
+    def __init__(self, raw_orders: list[dict], list_products: list[Producto], technique: Tecnica):
         self.products = list_products
         self.technique = technique
         self.raw_list_orders = raw_orders
 
-    def setOrders(self, new_raw_orders: list[list[dict]] = None):
-        self.orders = new_raw_orders or []
+    def serRawOrders(self, new_raw_orders: list[dict]):
+        self.raw_list_orders = new_raw_orders
 
-        for i in range(len(self.raw_list_orders)):
+    def setOrdersToSave(self):
+        self.orders = []
+        for raw in self.raw_list_orders:
             self.orders.append(Orden(id_tecnica=self.technique))
 
     def saveOrders(self):
         if not self.orders:
             return controller_error("no se han establecido las ordenes para guardar")
         try:
-            self.orders_save = Orden.objects.bulk_create(self.orders)
-            return self.orders_save
+            for order in self.orders:
+                order.save()
+            return self.orders
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al guardar las ordenes")
 
     def setPositions(self):
-        codes_ids = [(product.codigoProducto, product.id)
-                     for product in self.products]
+        codes_ids_products = {}
+        for product in self.products:
+            codes_ids_products[product.codigoProducto] = product.id
+        codes_expect = list(codes_ids_products.keys())
 
-        codes_expect = [pair[0] for pair in codes_ids]
-
-        if len(self.orders_save) != len(self.raw_list_orders):
+        if len(self.orders) != len(self.raw_list_orders):
             return controller_error("el numero 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())
 
-        for index, raw_order in enumerate(self.raw_list_orders):
-            codes_raw_orders = [next(iter(position.values()))
-                                for position in raw_order]
-
-            if not set(codes_raw_orders) == set(codes_expect):
-                self.positions = []
+            if set(received_codes_order) != set(codes_expect):
                 return controller_error("las ordenes mandadas no contienen los productos esperados")
 
-            for data_position in raw_order:
-                code = data_position["code"]
-                position = data_position["position"]
-
-                locate_code_id = [
-                    code_id for code_id in codes_ids if code in code_id]
+            for name, position_index in order.items():
+                list_product_use = [product for product in self.products
+                                    if product.codigoProducto == name]
 
-                if not len(locate_code_id) == 1:
-                    return controller_error("no es posible asociar mas de un producto a un modelo posicion")
-                else:
-                    locate_code_id = locate_code_id[0]
+                if len(list_product_use) != 1:
+                    return controller_error("no pueden existir dos productos que ocupen la misma posicion de un orden")
 
+                product_use = list_product_use[0]
                 new_position = Posicion(
-                    id_producto=Producto.objects.get(id=locate_code_id[1]),
-                    id_orden=self.saveOrders[index],
-                    posicion=position,
+                    id_producto=product_use,
+                    id_orden=self.orders[index],
+                    posicion=position_index
                 )
-
                 self.positions.append(new_position)
-
         return self.positions
 
-    def savePostions(self):
+    def savePositions(self):
         if not self.positions:
             return controller_error("no se han establecido posiciones para guargar")
         try:
-            self.positions_save = Posicion.objects.bulk_create(self.positions)
-            return self.positions_save
+            for position in self.positions:
+                position.save()
+            return self.positions
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al guardar las posiciones")

tecnicas/controllers/palabras_controller.py

@@ -22,4 +22,4 @@ class PalabrasController():
             self.words = searched_words
             return self.words
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al guardar buscar palabras")

tecnicas/controllers/productos_controller.py

@@ -9,14 +9,11 @@ class ProductosController():
     technique: Tecnica
 
     def __init__(self, codes: list[str], technique: Tecnica):
-        for code in codes:
-            self.list_codes.append(code)
-
+        self.list_codes = codes
         self.technique = technique
 
-    def setListCodes(self, codes: list[str]):
-        for code in codes:
-            self.list_codes.append(code)
+    def setListCodes(self, new_codes: list[str]):
+        self.list_codes = new_codes
 
     def setTechnique(self, technique: Tecnica):
         self.technique = technique
@@ -35,7 +32,8 @@ class ProductosController():
             return controller_error("no se han establecido los productos para guardar")
 
         try:
-            self.products_save = Producto.objects.bulk_create(self.list_product)
-            return self.products_save
+            for product in self.list_product:
+                product.save()
+            return self.list_product
         except DatabaseError as error:
-            return controller_error(error)
+            return controller_error("error al guardar los productos")

tecnicas/controllers/sesion_controller.py

@@ -0,0 +1,41 @@
+from django.db import DatabaseError
+from ..models import Tecnica, Presentador, SesionSensorial
+from ..utils import controller_error
+
+
+class SesionController():
+    def __init__(self, name_session: str, technique: Tecnica, creator: Presentador):
+        self.name_session = name_session or None
+        self.technique = technique or None
+        self.presenter = creator or None
+
+    def setData(self, name_session: str, technique: Tecnica, creator: Presentador):
+        self.name_session = name_session
+        self.technique = technique
+        self.presenter = creator
+
+    def setSession(self):
+        if not self.presenter:
+            return controller_error("se requiere presentador para crear sesion")
+        elif not self.technique:
+            return controller_error("se requiere tecnica para crear sesion")
+
+        self.sensorial_session = SesionSensorial(
+            tecnica=self.technique,
+            creadoPor=self.presenter,
+        )
+
+        if self.name_session != "":
+            self.sensorial_session.nombre_sesion = self.name_session
+
+        return self.sensorial_session
+
+    def saveSession(self):
+        if not self.sensorial_session:
+            return controller_error("no se ha definido la sesion a guardar")
+
+        try:
+            self.sensorial_session.save()
+            return self.sensorial_session
+        except DatabaseError as error:
+            return controller_error("Error al crear la session sensorial")

tecnicas/controllers/tecnica_controller.py

@@ -1,4 +1,6 @@
 from ..models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
+from django.db import DatabaseError
+from ..utils import controller_error
 
 
 class TecnicaController():
@@ -26,9 +28,9 @@ class TecnicaController():
     def saveTechnique(self):
         try:
             self.technique.save()
-        except Exception:
-            return False
-        return self.technique
+            return self.technique
+        except DatabaseError:
+            return controller_error("No se ha podido guardar la tecnica")
 
     def deleteTechnique(self):
         self.technique.delete()

tecnicas/migrations/0013_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.1 on 2025-09-09 21:05
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0012_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='fechaCreacion',
+            field=models.DateTimeField(auto_created=True),
+        ),
+    ]

tecnicas/migrations/0014_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.2.1 on 2025-09-10 00:04
+
+import django.utils.timezone
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0013_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='fechaCreacion',
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+    ]

tecnicas/models/etiquetas_escala.py

@@ -1,11 +1,16 @@
 from django.db import models
-
 from .escala import Escala
 from .etiqueta import Etiqueta
 
+
 class EtiquetasEscala(models.Model):
-    id_escala = models.ForeignKey(Escala, on_delete=models.CASCADE, related_name="escalas_etiqutas_escala")
+    id_escala = models.ForeignKey(
+        Escala, on_delete=models.CASCADE, related_name="escalas_etiqutas_escala")
+
+    id_etiqueta = models.ForeignKey(
+        Etiqueta, on_delete=models.CASCADE, related_name="etiqueta_etiquetas_escala")
+
+    posicion = models.IntegerField()
 
-    id_etiqueta = models.ForeignKey(Etiqueta, on_delete=models.CASCADE, related_name="etiqueta_etiquetas_escala")
-    
-    posicion = models.IntegerField()
+    def __str__(self):
+        return f"Escala {self.id_escala.id}, {self.id_etiqueta.valor_etiqueta}, posicion {self.posicion}"

tecnicas/models/orden.py

@@ -8,7 +8,13 @@ class Orden(models.Model):
     id_tecnica = models.ForeignKey(Tecnica, on_delete=models.CASCADE, related_name="orden_tecnica")
     id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="orden_catador", null=True)
 
+    def __str__(self):
+        return f"Orden ID: {self.id}"
+
 class Posicion(models.Model):
     id_producto = models.ForeignKey(Producto, on_delete=models.CASCADE, related_name="posicion_producto")
     id_orden = models.ForeignKey(Orden, on_delete=models.CASCADE, related_name="posicion_orden")
-    posicion = models.IntegerField()
+    posicion = models.IntegerField()
+
+    def __str__(self):
+        return f"Posicion ID: {self.id}"

tecnicas/models/sesion_sensorial.py

@@ -1,16 +1,20 @@
-import shortuuid
 from django.db import models
-
+from django.utils import timezone
 from .presentador import Presentador
 from .tecnica import Tecnica
+import shortuuid
+
 
 class SesionSensorial(models.Model):
-    codigo_sesion =  models.CharField(primary_key=True, default=shortuuid.uuid, editable=False, max_length=22)
+    codigo_sesion = models.CharField(
+        primary_key=True, default=shortuuid.uuid, editable=False, max_length=22)
     nombre_sesion = models.CharField(max_length=255, null=True)
-    fechaCreacion = models.DateTimeField("date published")
+    fechaCreacion = models.DateTimeField(default=timezone.now)
     activo = models.BooleanField(default=False)
-    creadoPor = models.ForeignKey(Presentador, on_delete=models.CASCADE, related_name="presentador_sesion")
-    tecnica = models.OneToOneField(Tecnica, on_delete=models.CASCADE, related_name="sesion_tecnica")
+    creadoPor = models.ForeignKey(
+        Presentador, on_delete=models.CASCADE, related_name="presentador_sesion")
+    tecnica = models.OneToOneField(
+        Tecnica, on_delete=models.CASCADE, related_name="sesion_tecnica")
 
     def __str__(self):
-        return self.codigo_sesion
+        return self.codigo_sesion

tecnicas/models/tecnica.py

@@ -15,7 +15,7 @@ class Tecnica(models.Model):
         EstiloPalabra, on_delete=models.CASCADE, related_name="estilo_tecnica")
 
     def __str__(self):
-        return self.tipo_tecnica.nombre_tecnica
+        return f"{self.id} : {self.tipo_tecnica.nombre_tecnica} : {self.id_estilo.nombre_estilo}"
 
     def toDict(self):
         return {

tecnicas/static/js/create-session.js

@@ -1,9 +1,7 @@
 const formSubmit = document.querySelector(".ct-cretae-session-form");
 
 document.addEventListener("DOMContentLoaded", () => {
-  setTimeout(() => {
-    cretaeSession();
-  }, 2000);
+  cretaeSession();
 });
 
 async function cretaeSession() {
@@ -27,18 +25,34 @@ async function cretaeSession() {
     }
 
     const data = jsonResponse["data"];
-    renderElementsResponse({ sessionId: data["session_id"] });
+    renderElementsResponse({
+      sessionId: data["codigo_sesion"],
+      nameSession: data["nombre_sesion"],
+    });
   } catch (error) {
     renderElementsResponse({ error: jsonResponse.error });
   }
 }
 
-function renderElementsResponse({ sessionId = "No id", error = false }) {
+function renderElementsResponse({
+  sessionId = "No id",
+  error = false,
+  nameSession = "",
+}) {
   const container = document.querySelector(".ct-message-create");
   const loadElement = document.querySelector(".ct-load-create");
 
-  const p = document.createElement("p");
-  p.classList.add("text-2xl", "text-white", "text-center", "font-bold");
+  const message = document.createElement("p");
+  message.classList.add("text-2xl", "text-white", "text-center", "font-bold");
+
+  const nameSessionP = document.createElement("p");
+  nameSessionP.classList.add(
+    "text-lg",
+    "text-white",
+    "text-center",
+    "font-bold"
+  );
+
   const idSession = document.createElement("p");
   idSession.classList.add("text-lg", "text-white", "text-center", "font-bold");
   const pHelp = document.createElement("p");
@@ -47,12 +61,12 @@ function renderElementsResponse({ sessionId = "No id", error = false }) {
   // Mostrar el error que ha ocurrido //
   // ******************************** //
   if (error) {
-    p.textContent = "No se ha podido completar la creacion de la sesion";
+    message.textContent = "No se ha podido completar la creacion de la sesion";
     idSession.textContent = `Error: ${error}`;
   } else {
-    p.textContent = "La session se ha creado";
-
+    message.textContent = "La session se ha creado";
     idSession.innerHTML = `El ID de la seesion es:<br><strong class="border-b border-white">${sessionId}</strong>`;
+    nameSessionP.textContent = `Nombre de sesion: ${nameSession}`;
 
     pHelp.classList.add("text-lg", "text-white", "text-center");
     pHelp.textContent =
@@ -84,7 +98,7 @@ function renderElementsResponse({ sessionId = "No id", error = false }) {
   ];
 
   const aIndex = document.createElement("a");
-  aIndex.href = "{% url 'cata_system:index' %}";
+  aIndex.href = "/cata";
   aIndex.textContent = "Volver al inicio";
 
   aIndex.classList.add(
@@ -96,7 +110,7 @@ function renderElementsResponse({ sessionId = "No id", error = false }) {
   );
 
   const aMonitor = document.createElement("a");
-  aMonitor.href = "{% url 'cata_system:index' %}";
+  aMonitor.href = "/cata";
   aMonitor.textContent = "Monitorear la sesion";
 
   aMonitor.classList.add(
@@ -117,7 +131,10 @@ function renderElementsResponse({ sessionId = "No id", error = false }) {
 
   container.innerHTML = "";
 
-  container.appendChild(p);
+  container.appendChild(message);
+  if (nameSession != "") {
+    container.appendChild(nameSessionP);
+  }
   container.appendChild(idSession);
   container.appendChild(pHelp);
   container.appendChild(divBtns);

tecnicas/static/js/panel-codes.js

@@ -9,10 +9,20 @@ let sortData;
 initIU();
 
 function submitData(e) {
+  const submitData = [];
+
+  sortData.forEach((order) => {
+    const simplePosition = {};
+    order.forEach((dataPosition) => {
+      simplePosition[dataPosition["code"]] = dataPosition["position"];
+    });
+    submitData.push(simplePosition);
+  });
+  
   const codesInput = document.createElement("input");
   codesInput.type = "hidden";
   codesInput.name = "sort_codes";
-  codesInput.value = JSON.stringify(sortData);
+  codesInput.value = JSON.stringify(submitData);
   this.appendChild(codesInput);
 }
 
@@ -110,6 +120,9 @@ function shuffle(arr) {
   return arrSuffle;
 }
 
+/**
+ * Render the UI with permutations
+ */
 function addIUPermutations() {
   const container = document.getElementsByClassName("ct-orden-list")[0];
   const itemsChild = [];

tecnicas/views/configuration_panel_basic.py

@@ -6,8 +6,17 @@ from ..models import TipoTecnica
 
 
 def configurationPanelBasic(req: HttpRequest):
-    req.session.flush()
-    
+    keys_forms = [
+        "form_basic",
+        "form_tags",
+        "form_codes",
+        "form_words"
+    ]
+
+    for key in keys_forms:
+        if key in req.session:
+            del req.session[key]
+
     if req.method == "POST":
         try:
             form = SesionBasicForm(req.POST)

tecnicas/views/configuration_panel_tags.py

@@ -4,31 +4,34 @@ from django.urls import reverse
 from ..forms import SesionTagsForm, EtiquetaForm
 from ..models import TipoEscala
 
+
 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 req.method == "GET":
-        form_etiqutas = SesionTagsForm(longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
+        form_etiqutas = SesionTagsForm(
+            longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
 
         context_tags = {
-            "form_tags":form_etiqutas,
+            "form_tags": form_etiqutas,
             "form_new_tag": form_new_etiqueta
         }
 
         return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
     elif req.method == "POST":
         values = {}
-        form = SesionTagsForm(req.POST, longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
+        form = SesionTagsForm(req.POST, longitud=tamano_escala,
+                              tipo_escala=type_scale.nombre_escala)
 
         context_tags = {
-            "form_tags":form,
+            "form_tags": form,
             "form_new_tag": form_new_etiqueta
         }
 
@@ -40,4 +43,4 @@ def configurationPanelTags(req: HttpRequest):
             return redirect(reverse("cata_system:panel_configuracion_codes"))
         else:
             context_tags["error"] = "ha ocurrido un error"
-            return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+            return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)

tecnicas/views/create_session.py

@@ -2,7 +2,8 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from ..utils import general_error
-from ..controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController
+from ..controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
+from ..models import Presentador
 
 
 def createSession(req: HttpRequest):
@@ -10,7 +11,7 @@ def createSession(req: HttpRequest):
         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["form_words"]:
+            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")
 
@@ -28,7 +29,7 @@ def createSession(req: HttpRequest):
                 return general_error("error al guardar la tecnica")
 
             data_scale = {
-                "scale": data_basic["tipo_escala"],
+                "id_scale": data_basic["tipo_escala"],
                 "size": data_basic["tamano_escala"],
                 "technique": technique
             }
@@ -36,15 +37,14 @@ def createSession(req: HttpRequest):
             controllerScale = EscalaController(data=data_scale)
 
             scale = controllerScale.saveScale()
-            if not scale:
+            if isinstance(scale, dict):
                 controllerTechnique.deleteTechnique()
-                return general_error("error al guardar la escala, datos agregados previeamante borrados")
+                return general_error(scale["error"])
 
-            list_tags = req.session["form_tags"]
-
-            saved_tags = controllerScale.addAndSaveTags(list_tags)
-            if not saved_tags:
-                return general_error("error al guardar asociar escalas, datos agregados previeamante borrados")
+            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"])
 
             # ////////////////////////////////////////////////////////// #
             #
@@ -53,8 +53,10 @@ def createSession(req: HttpRequest):
             # ////////////////////////////////////////////////////////// #
             data_codes = req.session["form_codes"]
 
+            list_codes_dict = data_codes["product_codes"]
+
             codes = []
-            for product in data_codes["product_codes"]:
+            for product in list_codes_dict:
                 code = next(iter(product.values()))
                 codes.append(code)
 
@@ -65,8 +67,9 @@ def createSession(req: HttpRequest):
 
             controllerProducts.setProductsNoSave()
             saved_prodcuts = controllerProducts.saveProducts()
-            if saved_prodcuts["error"]:
-                return general_error(saved_tags["error"])
+            if isinstance(saved_prodcuts, dict):
+                controllerTechnique.deleteTechnique()
+                return general_error(saved_prodcuts["error"])
 
             raw_sort_codes = data_codes["sort_codes"]
             controllerOrdes = OrdenesController(
@@ -75,17 +78,20 @@ def createSession(req: HttpRequest):
                 technique=technique
             )
 
-            controllerOrdes.setOrders()
+            controllerOrdes.setOrdersToSave()
             saved_orders = controllerOrdes.saveOrders()
-            if saved_orders["error"]:
+            if isinstance(saved_orders, dict):
+                controllerTechnique.deleteTechnique()
                 return general_error(saved_orders["error"])
 
             seded_positions = controllerOrdes.setPositions()
-            if seded_positions["error"]:
+            if isinstance(seded_positions, dict):
+                controllerTechnique.deleteTechnique()
                 return general_error(seded_positions["error"])
 
-            saved_postions = controllerOrdes.savePostions()
-            if saved_prodcuts["error"]:
+            saved_postions = controllerOrdes.savePositions()
+            if isinstance(saved_postions, dict):
+                controllerTechnique.deleteTechnique()
                 return general_error(saved_prodcuts["error"])
 
             # /////////////////////////////////////////////////////// #
@@ -97,19 +103,61 @@ def createSession(req: HttpRequest):
             words_controller = PalabrasController(ids=ids_words)
 
             words_to_use = words_controller.setWords()
-            if words_to_use["error"]:
+            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 instace_style["error"]:
+            if isinstance(instace_style, dict):
+                controllerTechnique.deleteTechnique()
                 return general_error(instace_style["error"])
 
             words_using = style_controller.relatedWords()
-            if words_using["error"]:
+            if isinstance(words_using, dict):
+                controllerTechnique.deleteTechnique()
                 return general_error("error")
-                
-            return JsonResponse({"message": "sesion creada", "data": {"session_id": "asd548ad4a"}})
+
+            # //////////////////////////////////////////////////////// #
+            #
+            # 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=Presentador.objects.get(nombre_usuario="aguBido")
+            )
+
+            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
+                }
+            }
+
+            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")