Ingreso a sesion con tecnica RATA

tecnicas/controllers/__init__.py

@@ -26,6 +26,7 @@ from .views_controller.session_management.monitor_escalas_controller import Moni
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.init_session_tester_controller import InitSessionTesterController
+from .views_controller.sessions_tester.convencional_scales_controller import ConvencionalScalesController
 
 from .views_controller.api_rating_controller import ApiRatingController
 from .views_controller.tester_list_controller import TesterListController

tecnicas/controllers/views_controller/api_rating_controller.py

@@ -40,7 +40,7 @@ class ApiRatingController():
         if isinstance(value, dict):
             return controller_error(value["error"])
 
-    def logicView(self) -> dict:
+    def controllPostScales(self) -> dict:
         validate = self.rating_controller.validateRating()
         if isinstance(validate, dict):
             return controller_error(validate["error"])

tecnicas/controllers/views_controller/session_management/details_escala_controller.py

@@ -14,7 +14,7 @@ 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, Tecnica
+from tecnicas.models import SesionSensorial, Presentador, Participacion
 from tecnicas.controllers import DatoController, CalificacionController, PalabrasController, ParticipacionController
 from .details_controller import DetallesController
 from tecnicas.utils import defaultdict_to_dict, controller_error
@@ -85,23 +85,25 @@ class DetallesEscalasController(DetallesController):
 
         return self.context
 
-    def startRepetition(self, presenter: Presentador):
+    def startRepetition(self, presenter: Presentador, request: HttpRequest):
         creator = presenter
         technique = self.session.tecnica
 
         if creator.user.username != self.session.creadoPor.user.username:
-            return self.getResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición")
+            return self.getResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición", request=request)
         elif self.session.activo:
-            return self.getResponse(error="La sesión ya está activada")
+            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")
+            return self.getResponse(error="Se ha alcanzado el número de repeticiones máxima", request=request)
+        
+        there_participacions = Participacion.objects.filter(tecnica=technique).exists()
 
-        (is_update_participations,
-         message) = ParticipacionController.outAllInSession(self.session)
+        if there_participacions:
+            (is_update_participations,
+            message) = ParticipacionController.outAllInSession(self.session)
+            if not is_update_participations:
+                return self.getResponse(error=message, request=request)
 
-        if not is_update_participations:
-            return self.getResponse(error=message)
-        
         self.session.activo = True
         technique.repeticion = technique.repeticion + 1
 

tecnicas/controllers/views_controller/sessions_tester/convencional_scales_controller.py

@@ -0,0 +1,149 @@
+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.controllers import PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+
+
+class ConvencionalScalesController:
+    context = {}
+    current_directory = "tecnicas/forms_tester/convencional.html"
+
+    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
+        self.tester = user_tester
+        self.session = sensorial_session
+
+    def controllGetEscalas(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        self.context["session"] = self.session
+
+        positions = PosicionController.getPostionsInOrder(
+            id_order=request.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=request.user.username,
+            id_technique=technique.id,
+            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
+            }
+            return redirect(reverse('cata_system:catador_init_session', kwargs=params))
+
+        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
+        )
+
+        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
+        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
+
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        self.context["scale"] = scale
+        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        self.context["tags"] = use_tags
+
+        print(self.context)
+        return render(request, self.current_directory, self.context)
+
+    def controllGetRATA(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        self.context["session"] = self.session
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        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)
+
+            # Sin calificaciones mandamos el producto actual y todas la palabras
+            if not ratings_product:
+                self.context["product"] = product_in
+                self.context["words"] = words
+                break
+
+            # Obtener los datos asociados parala calificacion para ver que palabras quedan por calificar
+            recoreded_data = DatoController.getRerecordedData(ratings=ratings_product)
+
+            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
+                break
+            else:
+                words_to_use = PalabrasController.getWordsWithoutData(
+                    recoreded_data=recoreded_data, words=words)
+
+                # 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
+                    break
+
+        # Si no hay producto que falta por calificar finalizar sesion para el Catador
+        if "product" not in self.context:
+            updated_participation = ParticipacionController.finishSession(
+                self.participation)
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse('cata_system:catador_init_session', kwargs=params))
+
+        # Agregar informacion de la escala
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        self.context["scale"] = scale
+        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        self.context["tags"] = use_tags
+
+        return render(request, self.current_directory, self.context)

tecnicas/controllers/views_controller/sessions_tester/init_session_tester_controller.py

@@ -37,6 +37,9 @@ class InitSessionTesterController():
         if is_end:
             context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
 
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
         return render(request, self.current_direction, context)
 
     def controllPostEscalas(self, request: HttpRequest):

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_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.usuarioCatador}"
+        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}"

tecnicas/static/js/created-scale.js

@@ -54,11 +54,13 @@ async function sendRating(word) {
     .querySelector(".id-product").textContent;
 
   const idWord = formRatingWord.querySelector(".id-word").textContent;
+  const idTechnique =  document.querySelector(".ct-input-id-tech").value
 
   dataForm.set("code-product", codeProduct);
   dataForm.set("id-product", idProduct);
   dataForm.set("name-word", word);
   dataForm.set("id-word", idWord);
+  dataForm.set("id-technique", idTechnique);
 
   try {
     const respone = await fetch(url, {

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -53,6 +53,10 @@
             </form>
         </article>
 
+        <section class="hidden">
+            <input type="hidden" value="{{ session.tecnica.id }}" name="id-tecnica" class="ct-input-id-tech">
+        </section>
+
         {% if error %}
         <hr>
         <article class="bg-red-600 p-4 text-white rounded-xl ct-notification-error">
@@ -97,15 +101,17 @@
 
         <article
             class="scales-container [&>*:not(:last-child)]:mb-5 min-lg:grid min-lg:items-start grid-cols-2 gap-3 justify-center items-center">
-            {% if type_scale == "continua" %}
-                {% for word in words %}
-                    {% include "../components/form-scale-continue.html" with word=word tags=tags scale=scale %}
-                {% endfor %}
-            {% elif type_scale == "estructurada" %}
-                {% for word in words %}
-                    {% include "../components/form-scale-structure.html" with word=word tags=tags scale=scale %}
-                {% endfor %}
-            {% endif %}
+            {% with path_con="../components/form-scale-continue.html" path_str="../components/form-scale-structure.html" %}
+                {% if type_scale == "continua" %}
+                    {% for word in words %}
+                        {% include path_con with word=word tags=tags scale=scale id_tecnica=session.tecnica.id %}
+                    {% endfor %}
+                {% elif type_scale == "estructurada" %}
+                    {% for word in words %}
+                        {% include path_str with word=word tags=tags scale=scale %}
+                    {% endfor %}
+                {% endif %}
+            {% endwith %}
         </article>
     </article>
 </article>

tecnicas/utils/general_controllers.py

@@ -17,7 +17,7 @@ def getId(value: object | int) -> int | None:
 def noValidTechnique(params: dict, query_params: dict, name_view: str):
     if query_params:
         query_string = urlencode(query_params)
-        url_redireccion = f"{reverse({name_view}, kwargs=params)}?{query_string}"
+        url_redireccion = f"{reverse(name_view, kwargs=params)}?{query_string}"
     else:
-        url_redireccion = f"{reverse({name_view}, kwargs=params)}"
+        url_redireccion = f"{reverse(name_view, kwargs=params)}"
     return redirect(url_redireccion)

tecnicas/views/apis/rating_word.py

@@ -28,8 +28,8 @@
  * Calquier otro metodo que se maneje mandar un error
 '''
 from django.http import HttpRequest, JsonResponse
-from ...controllers import ApiRatingController, CalificacionController, DatoController
-from ...utils import general_error
+from tecnicas.controllers import ApiRatingController, CalificacionController, DatoController
+from tecnicas.utils import general_error
 import json
 
 
@@ -41,10 +41,11 @@ def reatingWord(req:  HttpRequest):
         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"))
+        id_technique = json.loads(req.POST.get("id-technique"))
 
         view_controller = ApiRatingController(
             rating_controller=CalificacionController(
-                technique=req.session["id_technique"],
+                technique=id_technique,
                 product=received_id_product,
                 tester=req.user.user_catador
             ),
@@ -55,7 +56,7 @@ def reatingWord(req:  HttpRequest):
             )
         )
 
-        response_data = view_controller.logicView()
+        response_data = view_controller.controllPostScales()
 
         return JsonResponse(response_data)
     else:

tecnicas/views/sessions_management/session_details.py

@@ -42,7 +42,7 @@ def sessionDetails(req: HttpRequest, session_code: str):
 
             if req.POST["action"] == "start_session":
                 response = controller_view.startRepetition(
-                    presenter=req.user.user_presentador)
+                    presenter=req.user.user_presentador, request=req)
             elif req.POST.get("action") == "delete_session":
                 controller_view.deleteSesorialSession()
                 response = redirect(

tecnicas/views/tester_forms/convencional_scales.py

@@ -55,85 +55,26 @@
             - Cata segmento en el que se divide debe tener la etiqueda correspondiente por debajo
 '''
 from django.http import HttpRequest
-from django.shortcuts import redirect, render
-from django.urls import reverse
-from urllib.parse import urlencode
-from tecnicas.models import Participacion
-from tecnicas.controllers import SesionController, PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+from tecnicas.controllers import SesionController, ConvencionalScalesController
+from tecnicas.utils import noValidTechnique
 
 
 def convencionalScales(req: HttpRequest, code_sesion: str):
-    if not "id_order" in req.session:
-        return redirect(reverse("cata_system:catador_main"))
-
     session = SesionController.getSessionByCode(code_sesion)
-    technique = session.tecnica
-    participation = Participacion.objects.get(
-        tecnica=technique, catador=req.user.user_catador)
-
-    context = {
-        "session": session
-    }
-
-    req.session["id_technique"] = session.tecnica.id
+    type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
 
     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.user.username,
-            id_technique=session.tecnica.id,
-            repetition=session.tecnica.repeticion,
-            technique=technique,
-            num_words=len(words)
-        )
-
-        if isinstance(next_position, dict):
-            updated_participation = ParticipacionController.finishSession(
-                participation)
-            params = {
-                "code_sesion": code_sesion
-            }
-            return redirect(reverse('cata_system:catador_init_session', kwargs=params))
-
-        if isinstance(next_position, list):
-            next_position = next_position[0]
-
-        context["product"] = next_position.id_producto
-
-        ratings_product = CalificacionController.getRatings(
-            technique=technique,
-            product=next_position.id_producto,
-            repetition=technique.repeticion,
-            user_tester=req.user.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
+        view_controller = ConvencionalScalesController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        if type_technique == "escalas":
+            respose = view_controller.controllGetEscalas(request=req)
+        elif type_technique == "rata":
+            respose = view_controller.controllGetRATA(request=req)
         else:
-            recoreded_data = DatoController.getRerecordedData(
-                ratings=ratings_product)
-            if not recoreded_data:
-                context["words"] = words
-            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
-        context["type_scale"] = scale.id_tipo_escala.nombre_escala
-
-        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
-        context["tags"] = use_tags
+            respose = noValidTechnique(
+                name_view='cata_system:catador_init_session',
+                params={"code_sesion": session.codigo_sesion},
+                query_params={"error": "No es posible poder usar esta técnica"}
+            )
 
-        return render(req, "tecnicas/forms_tester/convencional.html", context)
+        return respose