Merge pull request #24 from CascoArcilla/bugsAndFixs

tecnicas/controllers/__init__.py

@@ -12,12 +12,6 @@ from .models_controller.posicion_controller import PosicionController
 from .models_controller.particiapacion_controller import ParticipacionController
 from .models_controller.dato_controller import DatoController
 
-from .views_controller.login_tester_controller import LoginTesterController
-from .views_controller.main_tester_form_controller import MainTesterFormController
-from .views_controller.api_rating_controller import ApiRatingController
-from .views_controller.tester_list_controller import TesterListController
-from .views_controller.list_sessions_tester_controller import ListSessionsTesterController
-
 from .views_controller.create_session.panel_basic_controller import PanelBasicController
 from .views_controller.create_session.panel_tags_controller import PanelTagsController
 from .views_controller.create_session.panel_codes_controller import PanelCodesController
@@ -28,4 +22,11 @@ from .views_controller.session_management.details_controller import DetallesCont
 from .views_controller.session_management.details_escala_controller import DetallesEscalasController
 from .views_controller.session_management.details_rata_controller import DetallesRATAController
 from .views_controller.session_management.monitor_controller import MonitorController
-from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController
+from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController
+
+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.api_rating_controller import ApiRatingController
+from .views_controller.tester_list_controller import TesterListController
+from .views_controller.list_sessions_tester_controller import ListSessionsTesterController

tecnicas/controllers/views_controller/{main_tester_form_controller.py → sessions_tester/init_session_tester_controller.py}

@@ -1,28 +1,98 @@
-from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
-from ...utils import controller_error, shuffleArray
 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.controllers import ParticipacionController
+from tecnicas.utils import controller_error, shuffleArray
 
 
-class MainTesterFormController():
+class InitSessionTesterController():
     tester: Catador
     session: SesionSensorial
     order: Orden | dict
-
-    def __init__(self, code_session: str, user_tester: str):
-        try:
-            self.tester = Catador.objects.get(user__username=user_tester)
-            self.session = SesionSensorial.objects.get(
-                codigo_sesion=code_session)
-        except (Catador.DoesNotExist, SesionSensorial.DoesNotExist):
-            return controller_error("Parámetros inexistentes")
+    current_direction = "tecnicas/forms_tester/init_session.html"
+    escalas_direction = "cata_system:session_convencional"
+
+    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
+        self.tester = user_tester
+        self.session = sensorial_session
+
+    def controllGetEscalas(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        order = self.checkAndAssignOrder()
+        if isinstance(order, dict):
+            context["error"] = order["error"]
+            return render(request, self.current_direction, context)
+
+        is_end = self.isEndedSessionEscalas()
+
+        request.session["id_order"] = order.id
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        return render(request, self.current_direction, context)
+
+    def controllPostEscalas(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        if request.POST["action"] == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            is_end = self.isEndedSessionEscalas()
+            if is_end:
+                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+                return render(request, self.current_direction, context)
+            
+            update_participation = ParticipacionController.enterSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                return render(request, self.current_direction, context)
+
+            request.session["id_participation"] = update_participation.id
+            return redirect(reverse(self.escalas_direction, kwargs=parameters))
+        elif request.POST["action"] == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return render(request, self.current_direction, context)
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)
+
+    def controllGetRATA(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        is_end = self.isEndedSessionEscalas()
+
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        return render(request, self.current_direction, context)
 
     def assignOrder(self):
         with transaction.atomic():
             orders_without_tester = list(Orden.objects.select_for_update().filter(
                 id_tecnica=self.session.tecnica, id_catador=None))
 
-            print(orders_without_tester)
-
             if not orders_without_tester:
                 return controller_error("Las ordenes se han acabado")
 
@@ -44,15 +114,16 @@ class MainTesterFormController():
                 return create
         return self.order_to_assign
 
-    def isEndedSession(self, repetition: int):
+    def isEndedSessionEscalas(self):
         try:
             participation = Participacion.objects.get(
                 catador=self.tester, tecnica=self.session.tecnica)
+            self.session.refresh_from_db()
 
             # ////////////////////////////////////////////////////////////// #
             #
-            # Si numero_calificaciones_esperadas = num_productos * num_palabras
-            # Es igual a numero_calificaciones_actuales en la repetcion R
+            # numero_calificaciones_esperadas = num_productos * num_palabras
+            # Si numero_calificaciones_esperadas ss igual a numero_calificaciones_actuales en la repetcion R
             # Ha terminado la repeticion
             #
             # ////////////////////////////////////////////////////////////// #
@@ -61,7 +132,8 @@ class MainTesterFormController():
                 num_products = Producto.objects.filter(
                     id_tecnica=self.session.tecnica).count()
 
-                style_words = self.session.tecnica.id_estilo
+                technique = self.session.tecnica
+                style_words = technique.id_estilo.nombre_estilo
 
                 num_words: int
 
@@ -72,12 +144,14 @@ class MainTesterFormController():
                     num_words = EsVocabulario.objects.get(
                         id_tecnica=self.session.tecnica).id_vocabulario.palabras.count()
 
+                expected_ratings_repetition = num_products * num_words
+
                 num_ratings_now = Calificacion.objects.filter(
-                    id_tecnica=self.session.tecnica, id_catador=self.tester, num_repeticion=repetition).count()
+                    id_tecnica=technique, id_catador=self.tester, num_repeticion=technique.repeticion).count()
 
-                expected_ratings_repetition = num_products * num_words
+                is_end = num_ratings_now >= expected_ratings_repetition
 
-                return num_ratings_now >= expected_ratings_repetition
+                return is_end
             else:
                 return participation.finalizado
         except Participacion.DoesNotExist:

tecnicas/controllers/views_controller/{login_tester_controller.py → sessions_tester/login_session_tester_controller.py}

@@ -6,7 +6,7 @@ from tecnicas.models import Catador, SesionSensorial, Participacion
 from tecnicas.utils import controller_error
 
 
-class LoginTesterController():
+class LoginSessionTesterController():
     tester: Catador
     session: SesionSensorial
     taster_participation: Participacion

tecnicas/templates/tecnicas/components/item_session_tester.html

@@ -10,7 +10,7 @@
 
         <article class="text-sm space-y-1">
             <p><span class="font-semibold">Código:</span> {{ session.codigo_sesion }}</p>
-            <p><span class="font-semibold">Técnica:</span> {{ session.tecnica.tipo_tecnica }}</p>
+            <p class="uppercase"><span class="font-semibold">Técnica:</span> {{ session.tecnica.tipo_tecnica }}</p>
             <p><span class="font-semibold">Fecha:</span> {{ session.fechaCreacion }}</p>
             <p>
                 <span class="font-semibold">Finazliado:</span>

tecnicas/templates/tecnicas/forms_tester/init_session.html

@@ -19,30 +19,15 @@
         </article>
 
         {% 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>
+        {% include "../components/error-message.html" with message=error %}
         {% endif %}
-
         {% if message %}
-        <hr>
-
-        <article class="bg-surface-alter-card p-4 rounded-xl max-w-2xl">
-            <p class="block text-xl antialiased font-bold text-center">
-                {{ message }}
-            </p>
-        </article>
+        {% include "../components/error-message.html" with message=message %}
         {% endif %}
-
         <hr>
 
         <article
             class="rounded-xl grid grid-cols-1 gap-3 text-center *:bg-surface-card *:flex *:flex-wrap *:items-center *:justify-center *:gap-x-2 *:p-4 *:rounded-2xl">
-            {% if session %}
             <section>
                 <p class="text-xl font-bold">
                     Código:
@@ -68,16 +53,22 @@
                 </p>
             </section>
 
+            {% if type_technique == "escalas" or type_technique == "rata" or type_technique == "cata" %}
             <section>
                 <p class="text-xl font-medium">
                     Esta sesión usa el estilo de palabras
                     “<span class="uppercase">{{ session.tecnica.id_estilo }}</span>”
                 </p>
             </section>
+            {% endif %}
 
             <section>
                 <p class="text-xl font-medium">
+                    {% if type_technique == "escalas" %}
                     Repetición número {{ session.tecnica.repeticion }}
+                    {% else %}
+                    Única repetición
+                    {% endif %}
                 </p>
             </section>
 
@@ -86,13 +77,6 @@
                     {{ session.tecnica.instrucciones }}
                 </p>
             </section>
-            {% else %}
-            <section>
-                <p class="text-xl font-medium">
-                    Ha ocurrido un error en renderizar esta vista
-                </p>
-            </section>
-            {% endif %}
         </article>
 
         <hr>

tecnicas/views/tester_forms/init_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 tecnicas.controllers import MainTesterFormController, ParticipacionController
+from tecnicas.controllers import InitSessionTesterController, ParticipacionController
 from tecnicas.models import SesionSensorial
 
 
@@ -12,50 +12,35 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
         "session": session
     }
 
-    view_controller = MainTesterFormController(
-        code_sesion, req.user.username)
-
+    type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
     template_url = "tecnicas/forms_tester/init_session.html"
 
-    if req.method == "GET":
-        order = view_controller.checkAndAssignOrder()
-
-        if isinstance(order, dict):
-            context["error"] = order["error"]
-            return render(req, template_url, context)
-
-        is_end = view_controller.isEndedSession(
-            repetition=session.tecnica.repeticion)
-
-        req.session["id_order"] = order.id
-        context["has_ended"] = is_end
+    view_controller = InitSessionTesterController(
+        sensorial_session=session, user_tester=req.user.user_catador)
 
-        if is_end:
-            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+    if req.method == "GET":
+        if type_technique == "escalas":
+            response = view_controller.controllGetEscalas(request=req)
+        elif type_technique == "rata":
+            response = view_controller.controllGetRATA(request=req)
+        else:
+            context = {
+                "error": "La técnica usada en esta sesión o ha sido implementada para ingresar a ella"
+            }
+            response = render(
+                req, template_url, context)
 
-        return render(req, template_url, context)
+        return response
     elif req.method == "POST":
-        if req.POST["action"] == "start_posting":
-            parameters = {
-                "code_sesion": code_sesion
+        if type_technique == "escalas" or type_technique == "rata":
+            response = view_controller.controllPostEscalas(request=req)
+        else:
+            context = {
+                "error": "Esta opción aun no esta disponible para la técnica usada por la sesión"
             }
+            response = render(
+                req, template_url, context)
 
-            update_participation = ParticipacionController.enterSession(
-                tester=req.user.user_catador, session=session)
-            if isinstance(update_participation, dict):
-                context["error"] = update_participation["error"]
-                return render(req, template_url, context)
-
-            req.session["id_participation"] = update_participation.id
-            return redirect(reverse("cata_system:session_convencional", kwargs=parameters))
-        elif req.POST["action"] == "exit_session":
-            response = ParticipacionController.outSession(
-                tester=req.user.user_catador, session=session)
-            if isinstance(response, dict):
-                context["error"] = response["error"]
-            return render(req, template_url, context)
-        else:
-            context["error"] = "Acción sin especificar"
-            return render(req, template_url, context)
+        return response
     else:
         return JsonResponse({"error": "metodo no permitido"})

tecnicas/views/tester_forms/login_session.py

@@ -2,7 +2,7 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from tecnicas.utils import general_error
-from tecnicas.controllers import LoginTesterController
+from tecnicas.controllers import LoginSessionTesterController
 
 
 def loginSessionTester(req: HttpRequest):
@@ -14,7 +14,7 @@ def loginSessionTester(req: HttpRequest):
         if not tester_user or not session_code:
             return general_error("Se esperan credenciales")
 
-        login_controller = LoginTesterController()
+        login_controller = LoginSessionTesterController()
 
         existCredentials = login_controller.existCredential(
             tester_user, session_code)
@@ -28,12 +28,12 @@ def loginSessionTester(req: HttpRequest):
         type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
 
         if type_technique == "escalas":
-            response = login_controller.validateEntryEscalas()
+            response = login_controller.validateEntryEscalas(request=req)
         elif type_technique == "rata":
-            response = login_controller.validateEntryRATA()
+            response = login_controller.validateEntryRATA(request=req)
         else:
             context = {
-                "error": "La técnica usada en esta sesión o ha sido implementada para ingresar a ella"
+                "error": "La técnica usada en esta sesión es invalida o no ha sido implementada para ingresar a ella"
             }
             response = render(
                 req, "tecnicas/forms_tester/login_session.html", context)