Guardado de calificaciones con sus respectivos valores en tecnica escalas

tecnicas/admin.py

@@ -1,29 +1,20 @@
 from django.contrib import admin
 
-from .models import CategoriaTecnica
-from .models import TipoTecnica
-from .models import TipoEscala
-from .models import EstiloPalabra
+from .models import CategoriaTecnica, TipoTecnica, TipoEscala, EstiloPalabra
 
-from .models import Catador
-from .models import Presentador
+from .models import Catador, Presentador
 
-from .models import Tecnica
-from .models import SesionSensorial
+from .models import Tecnica, SesionSensorial
 
-from .models import EsAtributo
-from .models import Palabra
+from .models import EsAtributo, Palabra
 
-from .models import Etiqueta
+from .models import Etiqueta, Escala, EtiquetasEscala
 
-from .models import Escala
-from .models import EtiquetasEscala
+from .models import Producto, Participacion
 
-from .models import Producto
-from .models import Participacion
+from .models import Orden, Posicion
 
-from .models import Orden
-from .models import Posicion
+from .models import Dato, ValorDecimal, ValorBooleano, Calificacion
 
 # Register your models here.
 admin.site.register(CategoriaTecnica)
@@ -49,3 +40,8 @@ admin.site.register(Participacion)
 
 admin.site.register(Orden)
 admin.site.register(Posicion)
+
+admin.site.register(Dato)
+admin.site.register(ValorDecimal)
+admin.site.register(ValorBooleano)
+admin.site.register(Calificacion)

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -1,7 +1,8 @@
-from ...models import Calificacion, Tecnica, Posicion, Producto, Catador
-from ...utils import controller_error, getId
 from django.core.exceptions import ValidationError
+from django.db import DatabaseError
 from collections import defaultdict
+from ...models import Calificacion, Tecnica, Posicion, Producto, Catador
+from ...utils import controller_error, getId
 
 
 class CalificacionController():
@@ -15,21 +16,30 @@ class CalificacionController():
 
         self.rating = Calificacion(**atributes)
 
-    def setRepetition(self, repetition):
+    def validateRating(self):
         try:
-            self.rating.full_clean()
-            if not repetition:
+            self.rating.clean()
+            return self.rating
+        except ValidationError as e:
+            return controller_error("No es posible validar la calificación")
+
+    def setRepetition(self, repetition: int = None) -> int | dict:
+        try:
+            if repetition is not None:
+                self.rating.num_repeticion = repetition
+            else:
                 self.rating.num_repeticion = self.rating.id_tecnica.repeticion
+
+            return self.rating.num_repeticion
         except ValidationError as e:
-            return controller_error(e.message)
+            return controller_error(e)
 
     def saveRating(self):
         try:
-            self.rating.full_clean()
             self.rating.save()
             return self.rating
         except ValidationError as e:
-            return controller_error(e.message)
+            return controller_error(e)
 
     @staticmethod
     def getRatingsByTechnique(technique: Tecnica):
@@ -120,9 +130,9 @@ class CalificacionController():
             ratings_dict[rat.id_producto.id].append(rat)
 
         for index, product in enumerate(check_products):
-            rating_of_product = ratings_dict.get(product.id, [])
+            ratings_of_product = ratings_dict.get(product.id, [])
 
-            if rating_of_product < num_words or len(rating_of_product) == 0:
+            if len(ratings_of_product) < num_words or len(ratings_of_product) == 0:
                 return positions[index]
 
         return controller_error("Sin productos por calificar")

tecnicas/controllers/models_controller/dato_controller.py

@@ -1,27 +1,68 @@
-from ...models import Calificacion, Dato, Palabra
+from ...models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano
 from ...utils import controller_error, getId
 from django.core.exceptions import ValidationError
 
 
 class DatoController():
-    def __init__(self, word: Palabra | int, rating: Calificacion | int):
+    def __init__(self, word: Palabra | int, rating: Calificacion | int, value_rating: int | bool):
         atributes = {
             "id_palabra_id": getId(word),
             "id_calificacion_id": getId(rating)
         }
 
         self.data = Dato(**atributes)
+        self.value_data = ValorDecimal(valor=value_rating)
 
-    def saveData(self):
+    def setRating(self, new_rating: Calificacion):
+        try:
+            self.data.id_calificacion = new_rating
+            return self.data.id_calificacion
+        except ValidationError as e:
+            return controller_error(e.message)
+
+    def validateRating(self):
         try:
             self.data.full_clean()
+            return self.data
+        except ValidationError as e:
+            return controller_error(e.message)
+
+    def saveData(self):
+        try:
             self.data.save()
             return self.data
         except ValidationError as e:
             return controller_error(e.message)
 
+    def setInstanceValue(self):
+        technique = self.data.id_calificacion.id_tecnica
+        
+        if technique.tipo_tecnica == "cata":
+            self.value_data = ValorBooleano(
+                id_dato=self.data,
+                valor=self.value_data.valor
+            )
+        else:
+            self.value_data = ValorDecimal(
+                id_dato=self.data,
+                valor=self.value_data.valor
+            )
+
+        return self.value_data
+
+    def saveValue(self):
+        try:
+            self.value_data.save()
+            return self.value_data
+        except ValidationError as e:
+            return controller_error(e.message)
+
     @staticmethod
     def getRerecordedData(ratings: list[Calificacion]):
+        '''
+        Get Datos' registers for each Calificacion.
+        Datos' registers no contain the value of rating.
+        '''
         if not ratings:
             return []
 

tecnicas/controllers/views_controller/api_rating_controller.py

@@ -1,8 +1,72 @@
-from ...models import Calificacion
 from ...controllers import CalificacionController, DatoController
+from ...utils import controller_error
 
 
 class ApiRatingController():
-    def __init__(self, _rating_controller: CalificacionController, _data_controller: DatoController):
-        self.rating_controller = _rating_controller
-        self.data_controller = _data_controller
+    def __init__(self, rating_controller: CalificacionController, data_controller: DatoController):
+        self.rating_controller = rating_controller
+        self.data_controller = data_controller
+
+    def setRating(self) -> int | dict:
+        repetition = self.rating_controller.setRepetition()
+        if isinstance(repetition, dict):
+            return controller_error(repetition["error"])
+        return repetition
+
+    def saveRating(self):
+        rating = self.rating_controller.saveRating()
+        if isinstance(rating, dict):
+            return controller_error(rating["error"])
+        return rating
+
+    def setRatingInData(self):
+        update_rating = self.data_controller.setRating(
+            self.rating_controller.rating)
+        if isinstance(update_rating, dict):
+            return controller_error(update_rating["error"])
+        return update_rating
+
+    def saveData(self):
+        data = self.data_controller.saveData()
+        if isinstance(data, dict):
+            return controller_error(data["error"])
+        return data
+
+    def setValueRating(self):
+        self.data_controller.setInstanceValue()
+
+    def saveValue(self):
+        value = self.data_controller.saveValue()
+        if isinstance(value, dict):
+            return controller_error(value["error"])
+
+    def logicView(self) -> dict:
+        validate = self.rating_controller.validateRating()
+        if isinstance(validate, dict):
+            return controller_error(validate["error"])
+
+        reptition = self.setRating()
+        if isinstance(reptition, dict):
+            return controller_error(reptition["error"])
+
+        rating = self.saveRating()
+        if isinstance(rating, dict):
+            return controller_error(rating["error"])
+
+        rating_data = self.setRatingInData()
+        if isinstance(rating_data, dict):
+            return controller_error(rating_data["error"])
+
+        data = self.saveData()
+        if isinstance(data, dict):
+            return controller_error(data["error"])
+
+        value = self.setValueRating()
+        if isinstance(value, dict):
+            return controller_error(value["error"])
+        
+        value_save = self.saveValue()
+        if isinstance(value_save, dict):
+            return controller_error(value_save["error"])
+
+        return {"message": "La calificación se ha guardado"}

tecnicas/models/dato_valor.py

@@ -7,11 +7,11 @@ class ValorDecimal(models.Model):
     valor = models.FloatField()
 
     def __str__(self):
-        return self.valor
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor}"
 
 class ValorBooleano(models.Model):
     id_dato = models.OneToOneField(Dato, on_delete=models.CASCADE, related_name="dato_boolean")
     valor = models.BooleanField()
 
     def __str__(self):
-        return self.valor
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor}"

tecnicas/static/js/created-scale.js

@@ -55,8 +55,10 @@ async function sendRating(word) {
 
   const idWord = formRatingWord.querySelector(".id-word").textContent;
 
-  dataForm.set("info-product", { code: codeProduct, id: idProduct });
-  dataForm.set("info-word", { name: word, id: idWord });
+  dataForm.set("code-product", codeProduct);
+  dataForm.set("id-product", idProduct);
+  dataForm.set("name-word", word);
+  dataForm.set("id-word", idWord);
 
   try {
     const respone = await fetch(url, {

tecnicas/views/apis/rating_word.py

@@ -29,26 +29,34 @@
 '''
 from django.http import HttpRequest, JsonResponse
 from ...controllers import ApiRatingController, CalificacionController, DatoController
+from ...utils import general_error
+import json
 
 
 def reatingWord(req:  HttpRequest):
     if req.method == "POST":
-        if not req.POST["rating-word"] or not req.POST["info-product"] or not req.POST["info-word"]:
+        if not req.POST["rating-word"] or not req.POST["id-word"] or not req.POST["id-product"]:
             return JsonResponse({"error": "No se mandó información necesaria para la calificación"})
 
-        received_rating = req.POST["rating-word"]
-        received_word = req.POST["info-word"]
-        received_product = req.POST["info-word"]
+        received_rating = json.loads(req.POST.get("rating-word"))
+        received_id_word = json.loads(req.POST.get("id-word"))
+        received_id_product = json.loads(req.POST.get("id-product"))
 
         view_controller = ApiRatingController(
-            CalificacionController(technique=req.session["id_techniqe"], product=received_product.id)
+            rating_controller=CalificacionController(
+                technique=req.session["id_techniqe"],
+                product=received_id_product,
+                tester=req.session["id_cata"]
+            ),
+            data_controller=DatoController(
+                word=received_id_word,
+                rating=0,
+                value_rating=received_rating
             )
+        )
 
-        return JsonResponse({
-            "message": "Ok",
-            "data": {
-                "word": word,
-                "rating": rating,
-                "cata_ser": req.session["cata_username"]
-            }
-        })
+        response_data = view_controller.logicView()
+
+        return JsonResponse(response_data)
+    else:
+        return general_error("No puede usar este método aquí")

tecnicas/views/login_tester.py

@@ -22,6 +22,7 @@ def testerLogin(req: HttpRequest):
             context = {"error": existCredentials["error"]}
             return render(req, "tecnicas/cata-login.html", context)
         
+        tester = existCredentials[0]
         session = existCredentials[1]
 
         taster_participation = login_controller.validateEntry()
@@ -30,6 +31,7 @@ def testerLogin(req: HttpRequest):
             return render(req, "tecnicas/cata-login.html", context)
 
         req.session["cata_username"] = tester_user
+        req.session["id_cata"] = tester.id
         req.session["code_session"] = session_code
         req.session["id_techniqe"] = session.tecnica.id
         req.session["id_participation"] = taster_participation.id

tecnicas/views/tester_forms/convencional_scales.py

@@ -115,9 +115,9 @@ def convencionalScales(req: HttpRequest):
             recoreded_data = DatoController.getRerecordedData(ratings=ratings_product)
             if not recoreded_data:
                 context["words"] = words
-            
-            words_to_use = PalabrasController.getWordsWithoutData(recoreded_data=recoreded_data, words=words)
-            context["words"] = words_to_use
+            else:
+                words_to_use = PalabrasController.getWordsWithoutData(recoreded_data=recoreded_data, words=words)
+                context["words"] = words_to_use
 
         scale = EscalaController.getScaleByTechnique(technique=technique)
         context["scale"] = scale