Se craa funcionalidad para guardar la relacion entre etiquetas y escala

tecnicas/admin.py

@@ -16,6 +16,9 @@ from .models import Palabra
 
 from .models import Etiqueta
 
+from .models import Escala
+from .models import EtiquetasEscala
+
 # Register your models here.
 admin.site.register(CategoriaTecnica)
 admin.site.register(TipoEscala)
@@ -30,4 +33,7 @@ admin.site.register(Tecnica)
 admin.site.register(SesionSensorial)
 
 admin.site.register(EsAtributo)
-admin.site.register(Palabra)
+admin.site.register(Palabra)
+
+admin.site.register(Escala)
+admin.site.register(EtiquetasEscala)

tecnicas/controllers/escala_controller.py

@@ -1,65 +1,98 @@
-from ..models import TipoEscala, Etiqueta, EtiquetasEscala, Escala, Tecnica
+from ..models import Etiqueta, EtiquetasEscala, Escala
+from django.db import DatabaseError
 
 
 class EscalaController():
-
     scale: Escala
+    tags: list[tuple[str, EtiquetasEscala]]
 
-    def __init__(self, scale):
-        self.scale = scale or None
+    def __init__(self, data):
+        self.scale = Escala(
+            id_tipo_escala=data["scale"],
+            longitud=data["size"],
+            tecnica=data["technique"]
+        )
 
-    def setAndSaveScale(self, type_scale: TipoEscala, size: int, technique: Tecnica):
-        self.scale = Escala.objects.create(
-            id_tipo_escala=type_scale,
-            longitud=size,
-            tecnica=technique
+    def setScale(self, newData):
+        self.scale = Escala(
+            id_tipo_escala=newData["scale"],
+            longitud=newData["size"],
+            tecnica=newData["technique"]
         )
 
-    def setScale(self, scale):
-        self.scale = scale
+    def saveScale(self):
+        try:
+            self.scale.save()
+        except Exception:
+            return False
+        return self.scale
 
-    def realte_tags_type_cotinue(self, tags: list):
-        tag = Etiqueta.objects.get(id=tags["punto_inicial"])
-        start_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=1
-        )
+    def deleteScale(self):
+        self.scale.delete()
 
-        tag = Etiqueta.objects.get(id=tags["punto_medio"])
-        half_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=2
-        )
+    def addAndSaveTags(self, tags: list):
+        if self.scale.id_tipo_escala.nombre_escala == "cotinua":
+            if not self.realte_tags_type_cotinue(tags):
+                return False
+        elif self.scale.id_tipo_escala.nombre_escala == "estructurada":
+            if not self.realte_tags_type_structure(tags):
+                return False
+        return self.tags
 
-        tag = Etiqueta.objects.get(id=tags["punto_final"])
-        end_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=3
-        )
+    def deleteRelationshipsWithLabels(self):
+        for tuple in self.tags:
+            relaTag = tuple[1]
+            relaTag.adelete()
 
-        self.tags = [
-            ("start", start_point),
-            ("medium", half_point),
-            ("end", end_point)
-        ]
+    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
+            )
 
-        return self.tags
+            self.tags.append(("start", start_point))
 
-    def realte_tags_type_structure(self, tags: dict):
-        index = 1
-        self.tags = []
+            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
+            )
 
-        for name, id_tag in tags.items():
-            tag = Etiqueta.objects.get(id=id_tag)
-            related_tag = EtiquetasEscala(
+            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,
-                posicion=index
+                id_etiqueta=tag_end,
+                posicion=3
             )
-            self.tags.append((name, related_tag))
-            index += 1
-            
-        return self.tags
+
+            self.tags.append(("end", end_point))
+            return True
+        except DatabaseError as error:
+            self.deleteRelationshipsWithLabels()
+            return False
+
+    def realte_tags_type_structure(self, tags: dict):
+        try:
+            index = 1
+            self.tags = []
+
+            for name, id_tag in tags.items():
+                tag = Etiqueta.objects.get(id=id_tag)
+                related_tag = EtiquetasEscala(
+                    id_escala=self.scale.id,
+                    id_etiqueta=tag,
+                    posicion=index
+                )
+                self.tags.append((name, related_tag))
+                index += 1
+
+            return True
+        except DatabaseError as error:
+            self.deleteRelationshipsWithLabels()
+            return False

tecnicas/controllers/tecnica_controller.py

@@ -23,6 +23,16 @@ class TecnicaController():
     def getDataTechnique(self):
         return self.technique.toDict()
 
+    def saveTechnique(self):
+        try:
+            self.technique.save()
+        except Exception:
+            return False
+        return self.technique
+
+    def deleteTechnique(self):
+        self.technique.delete()
+
     @staticmethod
     def getTypesTechnique():
         showTecnicas = {}

tecnicas/models/escala.py

@@ -9,4 +9,4 @@ class Escala(models.Model):
     tecnica = models.OneToOneField(Tecnica, on_delete=models.CASCADE, related_name="escala_tecnica")
 
     def __str__(self):
-        return self.longitud
+        return self.id_tipo_escala.nombre_escala

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
+        return self.tipo_tecnica.nombre_tecnica
 
     def toDict(self):
         return {

tecnicas/static/js/create-session.js

@@ -3,7 +3,7 @@ const formSubmit = document.querySelector(".ct-cretae-session-form");
 document.addEventListener("DOMContentLoaded", () => {
   setTimeout(() => {
     cretaeSession();
-  }, 1000);
+  }, 2000);
 });
 
 async function cretaeSession() {

tecnicas/views/create_session.py

@@ -2,8 +2,7 @@ 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
-from ..models import TipoTecnica, EstiloPalabra
+from ..controllers import TecnicaController, EscalaController
 
 
 def createSession(req: HttpRequest):
@@ -15,23 +14,37 @@ def createSession(req: HttpRequest):
                 req.session.flush()
                 return general_error("no se ha especificado informacion necesaria para la creacion de la sesion")
 
+            # ////////////////////////////////////////////////////// #
+            #
+            # First step: Create technique and scale with their tags #
+            #
+            # ////////////////////////////////////////////////////// #
             data_basic = req.session["form_basic"]
-            controllTechnique = TecnicaController()
-            controllTechnique.setTechniqueFromBasicData(basic=data_basic)
-            print(controllTechnique.getDataTechnique())
+            controllerTechnique = TecnicaController()
+            controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
 
-            return JsonResponse({"message": "sesion creada", "data": {"session_id": "asd548ad4a"}})
-        return general_error("ha orcurrido un error inesperado")
+            technique = controllerTechnique.saveTechnique()
+            if not technique:
+                return general_error("error al guardar la tecnica")
+
+            data_scale = {
+                "scale": data_basic["tipo_escala"],
+                "size": data_basic["tamano_escala"],
+                "technique": technique
+            }
+
+            controllerScale = EscalaController(data=data_scale)
 
+            scale = controllerScale.saveScale()
+            if not scale:
+                controllerTechnique.deleteTechnique()
+                return general_error("error al guardar la escala, datos agregados previeamante borrados")
 
-{
-    'id_tecnica': 1,
-    'nombre_sesion': '',
-    'numero_productos': 3,
-    'numero_catadores': 3,
-    'numero_repeticiones': 3,
-    'estilo_palabras': 1,
-    'tipo_escala': 2,
-    'tamano_escala': 9,
-    'instrucciones': ''
-}
+            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")
+
+            return JsonResponse({"message": "sesion creada", "data": {"session_id": "asd548ad4a"}})
+        return general_error("ha orcurrido un error inesperado")