Catador vista para plasmar datos en Sesion con tecnica escalas mandada

tecnicas/controllers/__init__.py

@@ -7,6 +7,11 @@ from .models_controller.estilo_palabras_controller import EstiloPalabrasControll
 from .models_controller.palabras_controller import PalabrasController
 from .models_controller.sesion_controller import SesionController
 from .models_controller.calificacion_controller import CalificacionController
+from .models_controller.catador_controller import CatadorController
+from .models_controller.posicion_controller import PosicionController
+from .models_controller.particiapacion_controller import ParticipacionController
+from .models_controller.dato_controller import DatoController
+
 from .views_controller.detalles_sesion_controller import DetallesSesionController
 from .views_controller.login_tester_controller import LoginTesterController
 from .views_controller.main_tester_form_controller import MainTesterFormController

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -1,4 +1,6 @@
-from ...models import Calificacion, Tecnica
+from ...models import Calificacion, Tecnica, Posicion, Producto, Catador
+from ...utils import controller_error
+from collections import defaultdict
 
 
 class CalificacionController():
@@ -17,3 +19,83 @@ class CalificacionController():
             data_rating[f"repeticion_{i+1}"] = response_data
 
         return data_rating
+
+    @staticmethod
+    def getRatings(
+            technique: Tecnica = None,
+            id_technique: int = None,
+            repetition: int = None,
+            product: Producto = None,
+            id_product: int = None,
+            tester: Catador = None,
+            id_tester: int = None,
+            user_tester: str = None,):
+        if repetition is None:
+            return controller_error("Es necesario especificar la repetición")
+
+        filters = {"num_repeticion": repetition}
+
+        if technique is not None:
+            filters["id_tecnica"] = technique
+        elif id_technique is not None:
+            filters["id_tecnica__id"] = id_technique
+        else:
+            return controller_error("Es necesario especificar la técnica")
+
+        if product is not None:
+            filters["id_producto"] = product
+        elif id_product is not None:
+            filters["id_producto__id"] = id_product
+
+        if tester is not None:
+            filters["id_catador"] = tester
+        elif id_tester is not None:
+            filters["id_catador__id"] = id_tester
+        elif user_tester is not None:
+            filters["id_catador__usuarioCatador"] = user_tester
+
+        ratings = list(Calificacion.objects.filter(**filters).select_related(
+            "id_producto",
+            "id_tecnica",
+            "id_catador",
+        ))
+
+        return ratings
+
+    @staticmethod
+    def checkProducsWithoutRating(
+            positions: list[Posicion] = None,
+            user_cata: str = None,
+            repetition: int = None,
+            technique: Tecnica = None,
+            id_technique: int = None,
+            num_words: int = None):
+        check_products = [position.id_producto for position in positions]
+
+        filters = {
+            "user_tester": user_cata,
+            "repetition": repetition
+        }
+
+        if technique is not None:
+            filters["technique"] = technique
+        elif id_technique is not None:
+            filters["id_technique"] = id_technique
+
+        ratings = CalificacionController.getRatings(**filters)
+
+        if len(ratings) == 0:
+            return positions
+
+        ratings_dict = defaultdict(list)
+
+        for rat in ratings:
+            ratings_dict[rat.id_producto.id].append(rat)
+
+        for index, product in enumerate(check_products):
+            rating_of_product = ratings_dict.get(product.id, [])
+
+            if rating_of_product < num_words or len(rating_of_product) == 0:
+                return positions[index]
+
+        return controller_error("Sin productos por calificar")

tecnicas/controllers/models_controller/catador_controller.py

@@ -0,0 +1,10 @@
+from ...models import Catador
+from ...utils import controller_error
+
+class CatadorController:
+    def getTesterByUsername(username:str):
+        try:
+            tester = Catador.objects.get(usuarioCatador=username)
+            return tester
+        except Catador.DoesNotExist:
+            return controller_error("No se encontró el Catador")

tecnicas/controllers/models_controller/dato_controller.py

@@ -0,0 +1,16 @@
+from ...models import Calificacion, Dato
+from ...utils import controller_error
+
+
+class DatoController():
+    @staticmethod
+    def getRerecordedData(ratings: list[Calificacion]):
+        if not ratings:
+            return []
+        
+        ids_ratings = [rat.id for rat in ratings]
+
+        recoreded_data = list(Dato.objects.filter(
+            id_calificacion_id__in=ids_ratings))
+        
+        return recoreded_data

tecnicas/controllers/models_controller/escala_controller.py

@@ -1,4 +1,4 @@
-from ...models import Etiqueta, EtiquetasEscala, Escala, TipoEscala
+from ...models import Etiqueta, EtiquetasEscala, Escala, TipoEscala, Tecnica
 from django.db import DatabaseError
 from ...utils import controller_error
 
@@ -68,3 +68,31 @@ class EscalaController():
         except DatabaseError as error:
             self.deleteRelationshipsWithLabels()
             return controller_error("error guardar relacion etiqueta escala")
+
+    @staticmethod
+    def getScaleByTechnique(technique: Tecnica = None, id_technique: int = None):
+        if technique is not None:
+            scale = Escala.objects.select_related("id_tipo_escala").only(
+                "id_tipo_escala", "longitud").get(tecnica=technique)
+            return scale
+
+        if id_technique is not None:
+            scale = Escala.objects.select_related("id_tipo_escala").only(
+                "id_tipo_escala", "longitud").get(tecnica_id=id_technique)
+            return scale
+
+    @staticmethod
+    def getRelatedTagsInScale(scale: Escala = None, id_scale: int = None):
+        if scale is not None:
+            scale_tags = list(EtiquetasEscala.objects.filter(
+                id_escala=scale).select_related("id_etiqueta"))
+            if len(scale_tags) == 0:
+                return controller_error("Imposible obtener las etiquetas")
+            return scale_tags
+
+        if id_scale is not None:
+            scale_tags = list(EtiquetasEscala.objects.filter(
+                id_escala_id=scale).select_related("id_etiqueta"))
+            if len(scale_tags) == 0:
+                return controller_error("Imposible obtener las etiquetas")
+            return scale_tags

tecnicas/controllers/models_controller/ordenes_controller.py

@@ -74,3 +74,11 @@ class OrdenesController():
             return self.positions
         except DatabaseError as error:
             return controller_error("error al guardar las posiciones")
+
+    @staticmethod
+    def getOrderById(id: int):
+        try:
+            order = Orden.objects.get(id=id)
+            return order
+        except Orden.DoesNotExist:
+            return controller_error("No existe orden")

tecnicas/controllers/models_controller/palabras_controller.py

@@ -1,4 +1,4 @@
-from ...models import Palabra, Tecnica, EsAtributo
+from ...models import Palabra, Tecnica, EsAtributo, EsVocabulario, Dato
 from django.db import DatabaseError
 from ...utils import controller_error
 
@@ -15,17 +15,33 @@ class PalabrasController():
 
     def setWords(self):
         self.words = []
-        try:
-            searched_words = Palabra.objects.filter(id__in=self.ids_words)
-            if not len(searched_words):
-                return controller_error("no se han encontrado registros")
-            self.words = searched_words
-            return self.words
-        except DatabaseError as error:
-            return controller_error("error al guardar buscar palabras")
+        searched_words = list(Palabra.objects.filter(id__in=self.ids_words))
+        if not len(searched_words):
+            return controller_error("no se han encontrado registros")
+        return self.words
 
     @staticmethod
     def getWordsInTechnique(technique: Tecnica):
-        es_atributo = EsAtributo.objects.get(id_tecnica=technique)
-        words = es_atributo.palabras.all()
-        return words
+        if technique.id_estilo.nombre_estilo == "atributos":
+            es_atribute = EsAtributo.objects.get(id_tecnica=technique)
+            words = list(es_atribute.palabras.all())
+            return words
+        elif technique.id_estilo.nombre_estilo == "vocabulario":
+            try:
+                palabras = Palabra.objects.filter(
+                    vocabulario__esvocabulario__id_tecnica=technique
+                )
+                return list(palabras.distinct()) if palabras.exists() else controller_error("Técnica sin palabras con vocabulario")
+            except Exception as e:
+                return controller_error("Técnica sin palabras con vocabulario")
+
+    @staticmethod
+    def getWordsWithoutData(recoreded_data: list[Dato], words: list[Palabra]):
+        qualified_words = [data.id_palabra for data in recoreded_data]
+
+        if set(qualified_words) == set(words):
+            return controller_error("No hay palabras por usar")
+
+        words_without_use = list(set(words).difference(set(qualified_words)))
+
+        return words_without_use

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -0,0 +1,36 @@
+from ...models import Participacion
+from ...utils import controller_error
+
+
+class ParticipacionController():
+    @staticmethod
+    def enterSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.finalizado = False
+            participation.activo = True
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")
+        
+    @staticmethod
+    def finishSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.finalizado = True
+            participation.activo = False
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")
+        
+    @staticmethod
+    def outSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.activo = False
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")

tecnicas/controllers/models_controller/posicion_controller.py

@@ -0,0 +1,20 @@
+from ...utils import controller_error
+from ...models import Orden, Posicion
+
+
+class PosicionController():
+    @staticmethod
+    def getPostionsInOrder(order: Orden = None, id_order: id = None):
+        if order is not None:
+            positions = list(Posicion.objects.filter(id_orden=order))
+            if not positions:
+                return controller_error("No existe orden")
+            return positions
+
+        if id_order is not None:
+            positions = list(Posicion.objects.filter(id_orden_id=id_order))
+            if not positions:
+                return controller_error("No existe orden")
+            return positions
+
+        return controller_error("No se define búsqueda")

tecnicas/controllers/models_controller/productos_controller.py

@@ -37,3 +37,17 @@ class ProductosController():
             return self.list_product
         except DatabaseError as error:
             return controller_error("error al guardar los productos")
+
+    @staticmethod
+    def getProductsByTechniqe(technique: Tecnica = None, id_technique: int = None):
+        if technique is not None:
+            products = list(Producto.objects.filter(id_tecnica=technique))
+            if not products:
+                return controller_error("No existen productos en esta técnica")
+            return products
+        
+        if id_technique is not None:
+            products = list(Producto.objects.filter(id_tecnica_id=id_technique))
+            if not products:
+                return controller_error("No existen productos en esta técnica")
+            return products

tecnicas/controllers/views_controller/login_tester_controller.py

@@ -18,7 +18,7 @@ class LoginTesterController():
             self.session = SesionSensorial.objects.get(
                 codigo_sesion=code_session)
 
-            return True
+            return (self.tester, self.session)
         except (Catador.DoesNotExist, SesionSensorial.DoesNotExist):
             return controller_error("Credenciales inválidas")
 

tecnicas/controllers/views_controller/main_tester_form_controller.py

@@ -1,4 +1,4 @@
-from ...models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, Vocabulario, EsVocabulario
+from ...models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
 from ...utils import controller_error, shuffleArray
 from django.db import transaction
 
@@ -18,10 +18,10 @@ class MainTesterFormController():
 
     def assignOrder(self):
         with transaction.atomic():
-            orders_without_tester = Orden.objects.select_for_update().filter(
-                id_tecnica=self.session.tecnica, id_catador=None)
+            orders_without_tester = list(Orden.objects.select_for_update().filter(
+                id_tecnica=self.session.tecnica, id_catador=None))
 
-            if not len(orders_without_tester):
+            if not orders_without_tester:
                 return controller_error("Las ordenes se han acabado")
 
             shuffle_orders = shuffleArray(orders_without_tester)
@@ -44,24 +44,14 @@ class MainTesterFormController():
         except Orden.DoesNotExist:
             return controller_error("Catador sin orden")
 
-    def endedToFalseAndActiveTester(self, id_participation: int):
-        try:
-            self.participation = Participacion.objects.get(id=id_participation)
-            self.participation.finalizado = False
-            self.participation.activo = True
-            self.participation.save()
-            return self.participation
-        except Participacion.DoesNotExist:
-            return controller_error("No se ha encontrado la participación")
-
-    def isEndedSession(self, id_participation: int):
+    def isEndedSession(self, id_participation: int, repetition: int):
         if not self.order or not id_participation:
             return controller_error("Se requieren datos para comprobar la finalización")
 
         try:
-            self.participation = Participacion.objects.get(id=id_participation)
+            participation = Participacion.objects.get(id=id_participation)
 
-            if self.participation.finalizado:
+            if participation.finalizado:
                 num_products = Producto.objects.filter(
                     id_tecnica=self.session.tecnica).count()
 
@@ -79,12 +69,12 @@ class MainTesterFormController():
                     num_words = e_vocabulary.id_vocabulario.palabras.count()
 
                 num_ratings_now = Calificacion.objects.filter(
-                    id_tecnica=self.session.tecnica, id_catador=self.tester).count()
+                    id_tecnica=self.session.tecnica, id_catador=self.tester, num_repeticion=repetition).count()
 
                 num_ratings_max_by_tester = num_products * num_words
 
                 return not num_ratings_now <= num_ratings_max_by_tester
             else:
-                return self.participation.finalizado
+                return participation.finalizado
         except Participacion.DoesNotExist:
             return controller_error("No se ha encontrado la participación")

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -1,4 +1,4 @@
-{% extends 'tecnicas/layouts/base.html' %}
+    {% extends 'tecnicas/layouts/base.html' %}
 
 {% block title %}Convencional{% endblock %}
 
@@ -11,11 +11,39 @@
             </h1>
         </header>
 
+        {% if error %}
+        <hr>
+
+        <article class="bg-red-600 p-4 text-white rounded-xl ct-notification-error">
+            <p class="block font-sans text-white text-xl antialiased font-bold uppercase tracking-wider text-center">
+                {{ error }}
+            </p>
+        </article>
+        {% endif %}
+
         <article>
             <p class="text-lg font-medium text-center bg-gray-200 p-4 rounded">
                 {{ session.tecnica.instrucciones }}
             </p>
         </article>
+
+        <article>
+            <p class="text-lg font-medium text-center bg-gray-200 p-4 rounded">
+                {{ scale }}
+            </p>
+        </article>
+
+        <article>
+            <p class="text-lg font-medium text-center bg-gray-200 p-4 rounded">
+                {{ tags }}
+            </p>
+        </article>
+
+        <article>
+            <p class="text-lg font-medium text-center bg-gray-200 p-4 rounded">
+                {{ words }}
+            </p>
+        </article>
     </article>
 </article>
 {% endblock %}

tecnicas/views/login_tester.py

@@ -21,6 +21,8 @@ def testerLogin(req: HttpRequest):
         if isinstance(existCredentials, dict):
             context = {"error": existCredentials["error"]}
             return render(req, "tecnicas/cata-login.html", context)
+        
+        session = existCredentials[1]
 
         taster_participation = login_controller.validateEntry()
         if isinstance(taster_participation, dict):
@@ -29,6 +31,7 @@ def testerLogin(req: HttpRequest):
 
         req.session["cata_username"] = tester_user
         req.session["code_session"] = session_code
+        req.session["id_techniqe"] = session.tecnica.id
         req.session["id_participation"] = taster_participation.id
 
         req.session.set_expiry(20*60)

tecnicas/views/tester_forms/convencional_scales.py

@@ -1,17 +1,101 @@
-from django.http import HttpRequest, JsonResponse
+from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
-from ...controllers import SesionController
+from ...controllers import SesionController, PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+
+'''
+ **** Esta vista para sesion con tecnica convencional de escalas, al entrar debe:
+ **** ****
+ * Obtner los productos que se evaluan en la tecnica
+ * Ordenar los productos segun la Poscion en que se encuentre en el Orden ya establecidos
+ * Obtner las palabras para evaluar
+    - Revisar que estilo usan
+    - Obtner las palabras si el estilo es atributos
+    - Obtner las palabras si el estilo es Vocabulario
+    - El Catador plasma sus resultados para las palabras sin importar el estilo
+ * Comprobar que productos se han calificado
+    - Revisar el numero de palabras
+    - Comenzar con el primer producto e ir revisando uno a uno
+        - Revisar el numero de calificaciones del producto
+        - Numero de calificaciones del producto == 0
+            - Continuar con la evaluacion o comezar con este producto
+        - Numero de calificaciones del producto < numero de palabras
+            - Continuar con la evaluacion
+        - Numero de calificacion == numero de palabras
+            - Pasar con el siguiente producto
+ * Si no quedan mas productos por revisar
+    - Participacion.finalizado = True
+    - Participacion.activo = False
+    - Redirigir a "catador_main"
+ * Optner la siguiente palabra sin calificar
+    - Obtener las calificaiones de producto
+    - Obtener los datos de las calificaciones
+    - Comprobar que palabras no estan tienen dato
+    - Mandar palabras para el usuario
+ * Obtener informacion de la escala para mandar
+'''
 
 
 def convencionalScales(req: HttpRequest):
     if not "id_order" in req.session:
-        return redirect(reverse("cata_system:panel_configuracion_words"))
+        return redirect(reverse("cata_system:catador_main"))
 
     session = SesionController.getSessionByCode(req.session["code_session"])
+    technique = session.tecnica
 
     context = {
         "session": session
     }
 
-    return render(req, "tecnicas/forms_tester/convencional.html", context)
+    if req.method == "GET":
+        positions = PosicionController.getPostionsInOrder(
+            id_order=req.session["id_order"])
+
+        sorted_positions = sorted(positions, key=lambda posi: posi.posicion)
+
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        next_position = CalificacionController.checkProducsWithoutRating(
+            positions=sorted_positions,
+            user_cata=req.session["cata_username"],
+            id_technique=req.session["id_techniqe"],
+            repetition=session.tecnica.repecion,
+            technique=technique,
+            num_words=len(words)
+        )
+
+        if isinstance(next_position, dict):
+            updated_participation = ParticipacionController.finishSession(
+                req.session["id_participation"])
+            return redirect(reverse("cata_system:catador_main"))
+
+        if isinstance(next_position, list):
+            next_position = next_position[0]
+
+        ratings_product = CalificacionController.getRatings(
+            technique=technique,
+            product=next_position.id_producto,
+            repetition=technique.repecion,
+            user_tester=req.session["cata_username"]
+        )
+
+        if isinstance(ratings_product, dict):
+            context["error"] = ratings_product["error"]
+            return render(req, "tecnicas/forms_tester/convencional.html", context)
+        elif not ratings_product:
+            context["words"] = words
+        else:
+            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
+
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        context["scale"] = scale
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        context["tags"] = use_tags
+
+        return render(req, "tecnicas/forms_tester/convencional.html", context)

tecnicas/views/tester_forms/main_tester_form.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from ...controllers import SesionController, MainTesterFormController
+from ...controllers import SesionController, MainTesterFormController, ParticipacionController
 
 
 def mainTesterForm(req: HttpRequest):
@@ -20,7 +20,7 @@ def mainTesterForm(req: HttpRequest):
 
         if not isinstance(order, dict):
             req.session["id_order"] = order.id
-            if view_controller.isEndedSession(req.session["id_participation"]):
+            if view_controller.isEndedSession(id_participation=req.session["id_participation"], repetition=session.tecnica.repecion):
                 context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
                 context["has_ended"] = True
 
@@ -28,19 +28,21 @@ def mainTesterForm(req: HttpRequest):
     elif req.method == "POST":
         if req.POST["action"] == "start_posting":
             if "id_order" in req.session:
-                update_participation = view_controller.endedToFalseAndActiveTester(req.session["id_participation"])
+                update_participation = ParticipacionController.enterSession(
+                    id_participation=req.session["id_participation"])
                 if isinstance(update_participation, dict):
                     context["error"] = update_participation["error"]
                     return render(req, "tecnicas/forms_tester/main_tester.html", context)
-                
+
                 return redirect(reverse("cata_system:session_convencional"))
 
             order = view_controller.assignOrder()
             if isinstance(order, dict):
                 context["error"] = order["error"]
                 return render(req, "tecnicas/forms_tester/main_tester.html", context)
-            
-            update_participation = view_controller.endedToFalseAndActiveTester(req.session["id_participation"])
+
+            update_participation = ParticipacionController.enterSession(
+                id_participation=req.session["id_participation"])
             if isinstance(update_participation, dict):
                 context["error"] = update_participation["error"]
                 return render(req, "tecnicas/forms_tester/main_tester.html", context)