Refactorizacion al guardar datos, correccion de algunos errores

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -6,49 +6,22 @@ from tecnicas.utils import controller_error, getId
 
 class CalificacionController():
     def __init__(self, product: Producto | int, technique: Tecnica | int, tester: Catador | int):
+        technique = Tecnica.objects.only(
+            "repeticion").get(id=getId(technique))
+
         atributes = {
-            "num_repeticion": 0,
-            "id_tecnica_id": getId(technique),
+            "num_repeticion": technique.repeticion,
+            "id_tecnica": technique,
             "id_producto_id": getId(product),
             "id_catador_id": getId(tester),
         }
 
-        self.rating = Calificacion(**atributes)
-
-    def validateRating(self):
-        try:
-            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)
-
-    def saveRating(self):
-        try:
-            self.rating.save()
-            return self.rating
-        except ValidationError as e:
-            return controller_error(e)
+        (self.rating, created) = Calificacion.objects.get_or_create(**atributes)
 
     @staticmethod
     def getRatingsByTechnique(technique: Tecnica):
         repetition = technique.repeticion
-
-        if not repetition:
-            return controller_error("Sin datos calificados aún")
-
         ratings = list(Calificacion.objects.filter(id_tecnica=technique))
-
         return ratings
 
     @staticmethod
@@ -94,39 +67,53 @@ class CalificacionController():
         return ratings
 
     @staticmethod
-    def checkProducsWithoutRating(
+    def checkPositionWithoutRating(
             positions: list[Posicion] = None,
-            user_cata: str = None,
+            user_cata: Catador | str = None,
             repetition: int = None,
-            technique: Tecnica = None,
-            id_technique: int = None,
+            technique: Tecnica | int = None,
             num_words: int = None):
-        check_products = [position.id_producto for position in positions]
+        end_rating = False
+
+        # Obtener lista con codigos de productos
+        check_products = [
+            position.id_producto.codigoProducto for position in positions]
 
         filters = {
-            "user_tester": user_cata,
-            "repetition": repetition
+            "num_repeticion": repetition,
+            "id_tecnica": getId(technique)
         }
 
-        if technique is not None:
-            filters["technique"] = technique
-        elif id_technique is not None:
-            filters["id_technique"] = id_technique
+        if isinstance(user_cata, Catador):
+            filters["id_catador"] = user_cata
+        else:
+            filters["id_catador"] = Catador.objects.get(
+                user__username=user_cata)
 
-        ratings = CalificacionController.getRatings(**filters)
+        ratings = list(Calificacion.objects.filter(**filters).select_related(
+            "id_producto",
+            "id_tecnica",
+            "id_catador",
+        ))
 
+        # Si no hay calificaciones regresar las posiciones
         if len(ratings) == 0:
-            return positions
+            return (positions, end_rating)
 
-        ratings_dict = defaultdict(list)
+        rating_products = [
+            rating.id_producto.codigoProducto for rating in ratings]
 
-        for rat in ratings:
-            ratings_dict[rat.id_producto.id].append(rat)
+        for index, rating in enumerate(ratings):
+            data_rating = rating.dato_calificacion.all()
 
-        for index, product in enumerate(check_products):
-            ratings_of_product = ratings_dict.get(product.id, [])
+            if len(data_rating) < num_words or len(data_rating) == 0:
+                return (positions[index], end_rating)
 
-            if len(ratings_of_product) < num_words or len(ratings_of_product) == 0:
-                return positions[index]
-
-        return controller_error("Sin productos por calificar")
+        next_product = list(set(check_products) - set(rating_products))
+        if len(next_product) != 0:
+            next_position = [
+                position for position in positions if position.id_producto.codigoProducto == next_product[0]][0]
+            return (next_position, end_rating)
+        else:
+            end_rating = True
+            return (positions[-1], end_rating)

tecnicas/controllers/models_controller/dato_controller.py

@@ -12,7 +12,11 @@ class DatoController():
         }
 
         self.data = Dato(**atributes)
-        self.value_data = ValorDecimal(valor=value_rating)
+
+        if isinstance(value_rating, bool):
+            self.value_data = ValorBooleano(valor=value_rating)
+        else:
+            self.value_data = ValorDecimal(valor=value_rating)
 
     def setRating(self, new_rating: Calificacion):
         try:
@@ -35,19 +39,14 @@ class DatoController():
         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
-            )
+    def setValue(self, new_value=None):
+        if new_value:
+            if isinstance(new_value, bool):
+                self.value_data = ValorBooleano(valor=new_value)
+            else:
+                self.value_data = ValorDecimal(valor=new_value)
         else:
-            self.value_data = ValorDecimal(
-                id_dato=self.data,
-                valor=self.value_data.valor
-            )
+            self.value_data.id_dato = self.data
 
         return self.value_data
 
@@ -88,7 +87,7 @@ class DatoController():
                 repeticion=F("id_dato__id_calificacion__num_repeticion"),
                 producto_code=F(
                     "id_dato__id_calificacion__id_producto__codigoProducto"),
-                usuarioCatador=F(
+                usuario_catador=F(
                     "id_dato__id_calificacion__id_catador__user__username"),
                 dato_valor=F("valor")
             )

tecnicas/controllers/views_controller/api_rating_controller.py

@@ -7,65 +7,18 @@ class ApiRatingController():
         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 controllPostScales(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"])
+        self.data_controller.setRating(
+            new_rating=self.rating_controller.rating
+        )
 
-        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()
+        data = self.data_controller.saveData()
         if isinstance(data, dict):
             return controller_error(data["error"])
 
-        value = self.setValueRating()
-        if isinstance(value, dict):
-            return controller_error(value["error"])
+        self.data_controller.setValue()
         
-        value_save = self.saveValue()
+        value_save = self.data_controller.saveValue()
         if isinstance(value_save, dict):
             return controller_error(value_save["error"])
 

tecnicas/controllers/views_controller/session_management/details_escala_controller.py

@@ -14,8 +14,8 @@ Encabezados de como deben de aparecer los datos juntos
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Participacion
-from tecnicas.controllers import DatoController, CalificacionController, PalabrasController, ParticipacionController
+from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion
+from tecnicas.controllers import DatoController, PalabrasController, ParticipacionController
 from .details_controller import DetallesController
 from tecnicas.utils import defaultdict_to_dict, controller_error
 from collections import defaultdict
@@ -52,10 +52,10 @@ class DetallesEscalasController(DetallesController):
         # Se recuperan las calificaciones
         ratings_for_repetition = []
 
-        ratings = CalificacionController.getRatingsByTechnique(
-            technique=self.session.tecnica)
+        ratings = list(Calificacion.objects.filter(
+            id_tecnica=self.session.tecnica))
 
-        if isinstance(ratings, dict) or not ratings:
+        if not ratings:
             self.context["calificaciones"] = ratings_for_repetition
             self.context["existen_calificaciones"] = False
             return self.context
@@ -67,7 +67,7 @@ class DetallesEscalasController(DetallesController):
             lambda: defaultdict(lambda: defaultdict(list)))
 
         for item in data:
-            user = item["usuarioCatador"]
+            user = item["usuario_catador"]
             rep = item["repeticion"]
             prod = item["producto_code"]
 
@@ -95,12 +95,13 @@ class DetallesEscalasController(DetallesController):
             return self.getResponse(error="La sesión ya está activada", request=request)
         elif technique.repeticion >= technique.repeticiones_max:
             return self.getResponse(error="Se ha alcanzado el número de repeticiones máxima", request=request)
-        
-        there_participacions = Participacion.objects.filter(tecnica=technique).exists()
+
+        there_participacions = Participacion.objects.filter(
+            tecnica=technique).exists()
 
         if there_participacions:
             (is_update_participations,
-            message) = ParticipacionController.outAllInSession(self.session)
+             message) = ParticipacionController.outAllInSession(self.session)
             if not is_update_participations:
                 return self.getResponse(error=message, request=request)
 

tecnicas/controllers/views_controller/sessions_tester/convencional_scales_controller.py

@@ -1,13 +1,14 @@
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Catador, Participacion, Producto
+from tecnicas.models import SesionSensorial, Catador, Participacion, Producto, Calificacion, Palabra
 from tecnicas.controllers import PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
 
 
 class ConvencionalScalesController:
     context = {}
     current_directory = "tecnicas/forms_tester/convencional.html"
+    previus_directory = "cata_system:catador_init_session"
 
     def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
         self.tester = user_tester
@@ -18,68 +19,70 @@ class ConvencionalScalesController:
         self.participation = Participacion.objects.get(
             tecnica=technique, catador=request.user.user_catador)
 
-        self.context["session"] = self.session
+        ctx = self.context
+        ctx["session"] = self.session
 
-        positions = PosicionController.getPostionsInOrder(
+        # Obtener posiciones y palabras de la técnica
+        positions_in_order = PosicionController.getPostionsInOrder(
             id_order=request.session["id_order"])
-
-        sorted_positions = sorted(positions, key=lambda posi: posi.posicion)
-
+        aligned_positions_in_order = sorted(
+            positions_in_order, key=lambda p: p.posicion)
         words = PalabrasController.getWordsInTechnique(technique=technique)
 
-        next_position = CalificacionController.checkProducsWithoutRating(
-            positions=sorted_positions,
-            user_cata=request.user.username,
-            id_technique=technique.id,
+        # Comprobar siguiente posición sin calificar
+        (next_position, end_products) = CalificacionController.checkPositionWithoutRating(
+            positions=aligned_positions_in_order,
+            user_cata=request.user.user_catador,
             repetition=technique.repeticion,
             technique=technique,
             num_words=len(words)
         )
 
-        if isinstance(next_position, dict):
-            updated_participation = ParticipacionController.finishSession(
-                self.participation)
-            params = {
-                "code_sesion": self.session.codigo_sesion
-            }
+        # Si no hay productos se finaliza la sesion
+        if end_products:
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
             return redirect(reverse('cata_system:catador_init_session', kwargs=params))
 
+        # Si devuelve una lista, tomar el primer elemento
         if isinstance(next_position, list):
             next_position = next_position[0]
 
-        self.context["product"] = next_position.id_producto
-
-        ratings_product = CalificacionController.getRatings(
-            technique=technique,
-            product=next_position.id_producto,
-            repetition=technique.repeticion,
-            user_tester=request.user.username
-        )
+        # Producto a calificar ahora
+        product = next_position.id_producto
+        ctx["product"] = product
+
+        # Revisar las palabras para calificar
+        try:
+            rating = Calificacion.objects.get(
+                num_repeticion=technique.repeticion,
+                id_producto=product,
+                id_tecnica=technique,
+                id_catador=self.tester
+            )
+            there_rating = True
+        except Calificacion.DoesNotExist:
+            there_rating = False
 
-        if isinstance(ratings_product, dict):
-            self.context["error"] = ratings_product["error"]
-            return render(request, self.current_directory, self.context)
-        elif not ratings_product:
-            self.context["words"] = words
+        # Si no hay calificaciones previas, usar todas las palabras
+        if not there_rating:
+            ctx["words"] = words
         else:
-            recoreded_data = DatoController.getRerecordedData(
-                ratings=ratings_product)
-            if not recoreded_data:
-                self.context["words"] = words
-            else:
-                words_to_use = PalabrasController.getWordsWithoutData(
-                    recoreded_data=recoreded_data, words=words)
-                self.context["words"] = words_to_use
+            ratings_product = rating.dato_calificacion.all()
+            # Filtrar palabras que faltan
+            words_to_use = PalabrasController.getWordsWithoutData(
+                recoreded_data=ratings_product,
+                words=words
+            )
+            ctx["words"] = words_to_use
 
+        # Escala y etiquetas relacionadas
         scale = EscalaController.getScaleByTechnique(technique=technique)
-        self.context["scale"] = scale
-        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+        ctx["scale"] = scale
+        ctx["type_scale"] = scale.id_tipo_escala.nombre_escala
+        ctx["tags"] = EscalaController.getRelatedTagsInScale(scale=scale)
 
-        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
-        self.context["tags"] = use_tags
-
-        print(self.context)
-        return render(request, self.current_directory, self.context)
+        return render(request, self.current_directory, ctx)
 
     def controllGetRATA(self, request: HttpRequest):
         technique = self.session.tecnica
@@ -92,32 +95,35 @@ class ConvencionalScalesController:
 
         words = PalabrasController.getWordsInTechnique(technique=technique)
 
-        # Revisamos el producto que le falten calificaciones
-        for product_in in products_in_technique:
-            ratings_product = CalificacionController.getRatings(
-                technique=technique,
-                product=product_in,
-                repetition=technique.repeticion,
-                user_tester=request.user.username
-            )
-
-            if isinstance(ratings_product, dict):
-                self.context["error"] = ratings_product.get("error")
-                return render(request, self.current_directory, self.context)
+        use_product: Producto = None
+        use_words: list[Palabra] = None
 
-            # Sin calificaciones mandamos el producto actual y todas la palabras
-            if not ratings_product:
-                self.context["product"] = product_in
-                self.context["words"] = words
+        # Revisamos el producto que le falten calificaciones
+        for current_product in products_in_technique:
+            try:
+                rating = Calificacion.objects.get(
+                    num_repeticion=technique.repeticion,
+                    id_producto=current_product,
+                    id_tecnica=technique,
+                    id_catador=self.tester
+                )
+                there_rating = True
+            except Calificacion.DoesNotExist:
+                there_rating = False
+
+            # Si no hay calificacion mandamos el producto actual y todas la palabras
+            if not there_rating:
+                use_product = current_product
+                use_words = words
                 break
 
-            # Obtener los datos asociados parala calificacion para ver que palabras quedan por calificar
-            recoreded_data = DatoController.getRerecordedData(ratings=ratings_product)
+            # Obtener los datos asociados para la calificacion para ver que palabras quedan por calificar
+            recoreded_data = rating.dato_calificacion.all()
 
             if not recoreded_data:
                 # Si no hay datos entonces devolver el producto con todas las palabras
-                self.context["product"] = product_in
-                self.context["words"] = words
+                use_product = current_product
+                use_words = words
                 break
             else:
                 words_to_use = PalabrasController.getWordsWithoutData(
@@ -125,18 +131,21 @@ class ConvencionalScalesController:
 
                 # Si quedan palabras por calificar mandar las palabras con el producto
                 if not isinstance(words_to_use, dict) and words_to_use:
-                    self.context["product"] = product_in
-                    self.context["words"] = words_to_use
+                    use_product = current_product
+                    use_words = words_to_use
                     break
 
         # Si no hay producto que falta por calificar finalizar sesion para el Catador
-        if "product" not in self.context:
+        if not use_product:
             updated_participation = ParticipacionController.finishSession(
                 self.participation)
             params = {
                 "code_sesion": self.session.codigo_sesion
             }
-            return redirect(reverse('cata_system:catador_init_session', kwargs=params))
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["product"] = use_product
+        self.context["words"] = use_words
 
         # Agregar informacion de la escala
         scale = EscalaController.getScaleByTechnique(technique=technique)

tecnicas/controllers/views_controller/sessions_tester/init_session_tester_controller.py

@@ -2,7 +2,7 @@ from django.db import transaction
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
+from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario, Dato
 from tecnicas.controllers import ParticipacionController
 from tecnicas.utils import controller_error, shuffleArray
 
@@ -125,8 +125,8 @@ class InitSessionTesterController():
 
             # ////////////////////////////////////////////////////////////// #
             #
-            # numero_calificaciones_esperadas = num_productos * num_palabras
-            # Si numero_calificaciones_esperadas ss igual a numero_calificaciones_actuales en la repetcion R
+            # numero_datos_esperadas = num_productos * num_palabras
+            # Si numero_datos_esperadas es igual a numero_datos_actuales en la repetcion R
             # Ha terminado la repeticion
             #
             # ////////////////////////////////////////////////////////////// #
@@ -149,8 +149,11 @@ class InitSessionTesterController():
 
                 expected_ratings_repetition = num_products * num_words
 
-                num_ratings_now = Calificacion.objects.filter(
-                    id_tecnica=technique, id_catador=self.tester, num_repeticion=technique.repeticion).count()
+                num_ratings_now = Dato.objects.filter(
+                    id_calificacion__id_catador=self.tester,
+                    id_calificacion__id_tecnica=technique,
+                    id_calificacion__num_repeticion=technique.repeticion
+                ).count()
 
                 is_end = num_ratings_now >= expected_ratings_repetition
 

tecnicas/models/calificacion.py

@@ -8,4 +8,7 @@ class Calificacion(models.Model):
     num_repeticion = models.IntegerField()
     id_producto = models.ForeignKey(Producto, on_delete=models.CASCADE, related_name="calificacion_producto")
     id_tecnica = models.ForeignKey(Tecnica, on_delete=models.CASCADE, related_name="calificacion_tecnica")
-    id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="calificacion_catador")
+    id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="calificacion_catador")
+
+    def __str__(self):
+        return f"{self.id} - {self.id_tecnica.sesion_tecnica} - {self.num_repeticion} - {self.id_catador.user.username}"

tecnicas/models/dato.py

@@ -11,4 +11,4 @@ class Dato(models.Model):
         Calificacion, on_delete=models.CASCADE, related_name="dato_calificacion")
 
     def __str__(self):
-        return f"{self.id_calificacion.id_tecnica.sesion_tecnica} - {self.id_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.user.username}"
+        return f"{self.id_calificacion.id_tecnica.sesion_tecnica}- {self.id_calificacion.num_repeticion} - {self.id_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.user.username}"

tecnicas/models/dato_valor.py

@@ -9,7 +9,7 @@ class ValorDecimal(models.Model):
     valor = models.FloatField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.user.username}"
 
 
 class ValorBooleano(models.Model):
@@ -18,4 +18,4 @@ class ValorBooleano(models.Model):
     valor = models.BooleanField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.user.username}"