Se establece el switch para sesion con tecnica RATA, inicio de sesion

tecnicas/controllers/__init__.py

@@ -12,11 +12,9 @@ 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
 from .views_controller.api_rating_controller import ApiRatingController
-from .views_controller.monitor_sesion_controller import MonitorSesionController
 from .views_controller.tester_list_controller import TesterListController
 from .views_controller.list_sessions_tester_controller import ListSessionsTesterController
 
@@ -25,3 +23,9 @@ from .views_controller.create_session.panel_tags_controller import PanelTagsCont
 from .views_controller.create_session.panel_codes_controller import PanelCodesController
 from .views_controller.create_session.panel_words_controller import PanelWordsController
 from .views_controller.create_session.panel_create_controller import PanelCreateController
+
+from .views_controller.session_management.details_controller import DetallesController
+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

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -1,8 +1,7 @@
 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
+from tecnicas.models import Calificacion, Tecnica, Posicion, Producto, Catador
+from tecnicas.utils import controller_error, getId
 
 
 class CalificacionController():
@@ -46,7 +45,7 @@ class CalificacionController():
         repetition = technique.repeticion
 
         if not repetition:
-            return {"error": "sin datos calficados aun"}
+            return controller_error("Sin datos calificados aún")
 
         ratings = list(Calificacion.objects.filter(id_tecnica=technique))
 

tecnicas/controllers/views_controller/main_tester_form_controller.py

@@ -20,7 +20,7 @@ class MainTesterFormController():
         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:
@@ -34,13 +34,15 @@ class MainTesterFormController():
 
             return self.order_to_assign
 
-    def checkAssignOrder(self):
+    def checkAndAssignOrder(self):
         try:
-            self.order = Orden.objects.get(
+            self.order_to_assign = Orden.objects.get(
                 id_tecnica=self.session.tecnica, id_catador=self.tester)
-            return self.order
         except Orden.DoesNotExist:
-            return controller_error("Catador sin orden")
+            create = self.assignOrder()
+            if isinstance(create, dict):
+                return create
+        return self.order_to_assign
 
     def isEndedSession(self, repetition: int):
         try:

tecnicas/controllers/views_controller/session_management/details_controller.py

@@ -0,0 +1,13 @@
+from tecnicas.models import SesionSensorial, Presentador, Tecnica
+from tecnicas.utils import controller_error
+
+
+class DetallesController():
+    url_template = "tecnicas/manage_sesions/detalles-sesion.html"
+
+    def __init__(self, session: SesionSensorial):
+        self.session = session
+
+    def deleteSesorialSession(self):
+        technique = Tecnica.objects.get(id=self.session.tecnica.id)
+        technique.delete()

tecnicas/controllers/views_controller/{detalles_sesion_controller.py → session_management/details_escala_controller.py}

@@ -11,29 +11,42 @@ Encabezados de como deben de aparecer los datos juntos
 | Repeticion | Codigo Producto | Catador | P1 | P2 | P3 | Pn |
 
 '''
-
-from ...models import SesionSensorial, Presentador, Tecnica
-from .. import CalificacionController, PalabrasController
-from ...utils import controller_error
+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.controllers import DatoController, CalificacionController, PalabrasController
+from .details_controller import DetallesController
+from tecnicas.utils import defaultdict_to_dict, controller_error
 from collections import defaultdict
-from tecnicas.controllers import DatoController
-from tecnicas.utils import defaultdict_to_dict
 
 
-class DetallesSesionController():
-    def __init__(self, session_code: str):
-        self.session = SesionSensorial.objects.get(codigo_sesion=session_code)
+class DetallesEscalasController(DetallesController):
+    url_template = "tecnicas/manage_sesions/detalles-sesion.html"
 
-    def getContextForView(self):
-        self.context = {}
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
 
-        self.context["sesion"] = self.session
+    def getResponse(self, request: HttpRequest, error: str = "", message: str = ""):
+        context = self.getContext()
+
+        if error != "" or error:
+            context["error"] = error
+        if message != "" or message:
+            context["message"] = message
+            
+        return render(
+            request, self.url_template, context)
 
+    def getContext(self):
+        self.context = {
+            "use_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+        self.context["sesion"] = self.session
         self.words = PalabrasController.getWordsInTechnique(
             self.session.tecnica)
         self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
-    def getContextWithData(self):
         ratings_for_repetition = []
 
         ratings = CalificacionController.getRatingsByTechnique(
@@ -66,34 +79,25 @@ class DetallesSesionController():
 
         return self.context
 
-    def deleteSesorialSession(self):
-        technique = Tecnica.objects.get(id=self.session.tecnica.id)
-        technique.delete()
-
-    @staticmethod
-    def startRepetition(session_code: str, username: str):
-        try:
-            creator = Presentador.objects.get(user__username=username)
-            session = SesionSensorial.objects.get(codigo_sesion=session_code)
-            technique = Tecnica.objects.get(id=session.tecnica.id)
-        except Presentador.DoesNotExist:
-            return controller_error("no existe presentador")
-        except SesionSensorial.DoesNotExist:
-            return controller_error("no existe sesión sensorial")
-        except Tecnica.DoesNotExist:
-            return controller_error("Ha ocurrido un error al recuperar la técnica")
-
-        if creator.user.username != session.creadoPor.user.username:
-            return controller_error("solo el presentador que crea la sesión puede iniciar la repetición")
-        elif session.activo:
-            return controller_error("la sesión ya está activada")
+    def startRepetition(self, presenter: Presentador):
+        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")
+        elif self.session.activo:
+            return self.getResponse(error="La sesión ya está activada")
         elif technique.repeticion == technique.repeticiones_max:
-            return controller_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")
 
-        session.activo = True
+        self.session.activo = True
         technique.repeticion = technique.repeticion + 1
 
         technique.save()
-        session.save()
+        self.session.save()
 
-        return session
+        parameters = {
+            "session_code": self.session.codigo_sesion
+        }
+        return redirect(
+            reverse("cata_system:monitor_sesion", kwargs=parameters))

tecnicas/controllers/views_controller/session_management/details_rata_controller.py

@@ -0,0 +1,56 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import PalabrasController, DatoController, CalificacionController
+from tecnicas.utils import defaultdict_to_dict
+from .details_controller import DetallesController
+from collections import defaultdict
+
+
+class DetallesRATAController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+
+    def getResponse(self, request: HttpRequest, error: str = ""):
+        context = self.getContext()
+        if error != "" or error:
+            context["error"] = error
+        return render(
+            request, self.url_template, context)
+
+    def getContext(self):
+        self.context = {}
+        self.context["sesion"] = self.session
+        self.words = PalabrasController.getWordsInTechnique(
+            self.session.tecnica)
+        self.context["palabras"] = [word.nombre_palabra for word in self.words]
+
+        ratings_for_repetition = []
+
+        ratings = CalificacionController.getRatingsByTechnique(
+            technique=self.session.tecnica)
+
+        if isinstance(ratings, dict) or not ratings:
+            self.context["calificaciones"] = ratings_for_repetition
+            self.context["existen_calificaciones"] = False
+            return self.context
+
+        data = DatoController.getWordValuesForConvecional(
+            ratings=ratings, technique=self.session.tecnica)
+
+        ratings_for_repetition = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(list)))
+
+        for item in data:
+            user = item["usuarioCatador"]
+            rep = item["repeticion"]
+            prod = item["producto_code"]
+
+            ratings_for_repetition[rep][user][prod].append({
+                "nombre_palabra": item["nombre_palabra"],
+                "dato_valor": item["dato_valor"]
+            })
+
+        self.context["calificaciones"] = defaultdict_to_dict(
+            ratings_for_repetition)
+        self.context["existen_calificaciones"] = True

tecnicas/controllers/views_controller/session_management/monitor_controller.py

@@ -0,0 +1,10 @@
+from tecnicas.models import SesionSensorial
+
+
+class MonitorController():
+    def __init__(self, session: SesionSensorial):
+        self.sensorial_session = session
+
+    def updataSession(self):
+        self.sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=self.sensorial_session.codigo_sesion)

tecnicas/controllers/views_controller/{monitor_sesion_controller.py → session_management/monitor_escalas_controller.py}

@@ -1,61 +1,72 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
 from tecnicas.models import SesionSensorial, EsAtributo, EsVocabulario, Producto, Calificacion
 from tecnicas.controllers import ParticipacionController, SesionController
 from tecnicas.utils import controller_error
+from .monitor_controller import MonitorController
 
 
-class MonitorSesionController():
-    def __init__(self, session_code: str):
-        self.code_session = session_code
+class MonitorEscalasController(MonitorController):
+    url_view = "tecnicas/manage_sesions/monitor-sesion.html"
 
-    def defineSession(self):
-        self.session = SesionSensorial.objects.get(
-            codigo_sesion=self.code_session)
+    def __init__(self, session: SesionController):
+        super().__init__(session)
 
-    def monitorView(self):
-        try:
-            self.sensorial_session = SesionSensorial.objects.select_related(
-                "tecnica"
-            ).only(
-                "nombre_sesion",
-                "tecnica__limite_catadores",
-            ).get(codigo_sesion=self.code_session)
+    def controlGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
+        self.setContext()
 
-            self.participations = ParticipacionController.getParticipationsInTechinique(
-                self.sensorial_session.tecnica)
-        except SesionSensorial.DoesNotExist as error:
-            return controller_error("No existe Sesión sensorial")
+        if error != "" or error:
+            self.context["error"] = error
+        if message != "" or message:
+            self.context["message"] = message
 
-        context = {
+        return render(request, self.url_view, self.context)
+
+    def controlPostResponseFinishSession(self, request: HttpRequest):
+        self.setContext()
+        (is_all_end, message) = self.checkAllParticipantsEnded()
+        if not is_all_end:
+            self.context["error"] = message
+            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+        response = self.finishSession()
+        if isinstance(response, dict):
+            self.context["error"] = response["error"]
+            return render(request, "tecnicas/manage_sesions/monitor-sesion.html", self.context)
+        self.context["message"] = message
+        return redirect(reverse("cata_system:detalles_sesion", kwargs={"session_code": self.sensorial_session.codigo_sesion}))
+
+    def setContext(self):
+        self.participations = ParticipacionController.getParticipationsInTechinique(
+            self.sensorial_session.tecnica)
+
+        self.context = {
+            "code_session": self.sensorial_session.codigo_sesion,
             "session_name": self.sensorial_session.nombre_sesion,
             "max_testers": self.sensorial_session.tecnica.limite_catadores,
             "current_testers": len(self.participations),
             "active_testers": len([part for part in self.participations if part.activo]),
-            "participations": self.participations
+            "participations": self.participations,
+            "use_technique": self.sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
         }
 
-        return context
-
     def getExpectedRatings(self):
         num_products = Producto.objects.filter(
-            id_tecnica=self.session.tecnica).count()
-
-        style_words = self.session.tecnica.id_estilo
-
+            id_tecnica=self.sensorial_session.tecnica).count()
+        style_words = self.sensorial_session.tecnica.id_estilo
         num_words: int
 
         if style_words.nombre_estilo == "atributos":
             num_words = EsAtributo.objects.get(
-                id_tecnica=self.session.tecnica).palabras.count()
+                id_tecnica=self.sensorial_session.tecnica).palabras.count()
         elif style_words.nombre_estilo == "vocabulario":
             num_words = EsVocabulario.objects.get(
-                id_tecnica=self.session.tecnica).id_vocabulario.palabras.count()
+                id_tecnica=self.sensorial_session.tecnica).id_vocabulario.palabras.count()
 
         return num_products * num_words
 
     def checkAllParticipantsEnded(self):
-        self.defineSession()
-
-        technique = self.session.tecnica
+        technique = self.sensorial_session.tecnica
 
         expected_ratings_repetition = self.getExpectedRatings()
 
@@ -75,8 +86,8 @@ class MonitorSesionController():
         return (True, "Puedes finalizar la sesión")
 
     def finishSession(self):
-        response = SesionController.finishRepetion(self.session)
+        response = SesionController.finishRepetion(self.sensorial_session)
         if isinstance(response, dict):
             return controller_error(response["error"])
-        self.defineSession()
-        return self.session
+        self.updataSession()
+        return self.sensorial_session

tecnicas/templates/tecnicas/main-panel.html

@@ -33,6 +33,10 @@
             </section>
         </header>
 
+        {% if error %}
+        {% include "./components/error-message.html" with message=error %}
+        {% endif %}
+
         <article class="w-full flex flex-col gap-7 items-center min-sm:mt-7 mt-4 bg-surface-card rounded-lg shadow-lg">
             <article
                 class="w-5xl max-lg:w-3xl max-md:w-auto p-8 flex flex-col justify-around items-center gap-4 flex-wrap text-3xl max-sm:text-2xl">

tecnicas/templates/tecnicas/manage_sesions/detalles-sesion.html

@@ -5,7 +5,7 @@
 
 {% block content %}
 <article class="cts-container-main">
-    <article class="cts-wrap-content relative">
+    <article class="cts-wrap-content relative max-w-4xl">
         <header class="text-center flex-row max-sm:flex-col w-full flex justify-around items-center flex-wrap gap-10">
             <h1 class="text-black rounded-xl font-bold text-2xl bg-surface-card shadow-lg p-4 flex-1">
                 Detalles de la sesión
@@ -17,28 +17,20 @@
             </a>
         </header>
 
-        {% if error %}
-        <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 %}
-
         {% if message %}
-        <article class="bg-green-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">
-                {{ message }}
-            </p>
-        </article>
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
         {% endif %}
 
         <p class="text-black font-bold text-2xl border-b-2">
             Información general
         </p>
         <article
-            class="text-black rounded-xl grid grid-cols-2 max-sm:grid-cols-1 gap-3 max-sm:gap-1 *:bg-surface-card *:flex *:flex-wrap *:items-center *:justify-center *:max-sm:justify-normal *:gap-x-2 *:p-4 *:rounded-2xl text-xl max-sm:text-base">
-            <section class="col-span-2 max-sm:col-span-1">
+            class="text-black rounded-xl grid grid-cols-2 max-sm:grid-cols-1 gap-3 max-sm:gap-1  text-xl max-sm:text-base">
+            <section
+                class="col-span-2 max-sm:col-span-1 bg-surface-ligt flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Código:
                 </p>
@@ -47,7 +39,8 @@
                 </p>
             </section>
 
-            <section class="col-span-2 max-sm:col-span-1">
+            <section
+                class="col-span-2 max-sm:col-span-1 bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Nombre:
                 </p>
@@ -60,7 +53,8 @@
                 </p>
             </section>
 
-            <section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Fecha creación:
                 </p>
@@ -69,7 +63,8 @@
                 </p>
             </section>
 
-            <section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Estado:
                 </p>
@@ -82,7 +77,8 @@
                 </p>
             </section>
 
-            <section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Estilo palabras:
                 </p>
@@ -91,7 +87,18 @@
                 </p>
             </section>
 
-            <section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
+                <p class="font-bold">
+                    Tipo Escala:
+                </p>
+                <p class="font-sans text-lg max-sm:text-base font-normal uppercase">
+                    {{ sesion.tecnica.escala_tecnica }}
+                </p>
+            </section>
+
+            <section
+                class="bg-surface-ligt flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Técnica:
                 </p>
@@ -100,7 +107,18 @@
                 </p>
             </section>
 
-            <section>
+            {% if use_technique == "escalas" %}
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
+                <p class="font-bold">
+                    Catadores Max:
+                </p>
+                <p class="font-sans text-lg max-sm:text-base font-normal">
+                    {{ sesion.tecnica.limite_catadores }}
+                </p>
+            </section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Rep. Hechas:
                 </p>
@@ -108,8 +126,8 @@
                     {{ sesion.tecnica.repeticion }}
                 </p>
             </section>
-
-            <section>
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Rep. Max:
                 </p>
@@ -117,8 +135,23 @@
                     {{ sesion.tecnica.repeticiones_max }}
                 </p>
             </section>
+            {% else %}
+            <section
+                class="bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
+                <p class="font-sans">
+                    Pueden ingresar tantos catadores como se desee
+                </p>
+            </section>
+            <section
+                class="col-span-2 max-sm:col-span-1 bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
+                <p class="font-sans">
+                    La técnica usada solo puede realizarse una vez, hay una única repetición
+                </p>
+            </section>
+            {% endif %}
 
-            <section class="col-span-2 max-sm:col-span-1">
+            <section
+                class="col-span-2 max-sm:col-span-1 bg-surface-card flex flex-wrap items-center justify-center max-sm:justify-normal gap-x-2 p-4 rounded-2xl">
                 <p class="font-bold">
                     Instrucciones:
                 </p>
@@ -192,8 +225,7 @@
                         ¿Estás seguro de continuar?
                     </p>
                     <div class="flex max-sm:flex-col gap-4 justify-center">
-                        <button class="cts-btn-general cts-btn-error btn-push"
-                        onclick="deleteSession()">
+                        <button class="cts-btn-general cts-btn-error btn-push" onclick="deleteSession()">
                             Estoy seguro
                         </button>
                         <button class="cts-btn-general cts-btn-primary btn-push"

tecnicas/templates/tecnicas/manage_sesions/monitor-sesion.html

@@ -10,14 +10,6 @@
             <h1 class="text-3xl font-bold text-black">Sesión sensorial en curso</h1>
         </header>
 
-        {% if error %}
-        <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 %}
-
         <section class="flex flex-col sm:flex-row justify-between items-center gap-10">
             <p class="text-xl text-center bg-surface-card p-4 text-black rounded-lg shadow-lg">
                 Código de sesión:<br>
@@ -41,6 +33,10 @@
             {% csrf_token %}
         </form>
 
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+
         {% if message %}
         {% include "../components/error-message.html" with message=message %}
         {% endif %}
@@ -63,12 +59,20 @@
                     <h2 class="text-xl font-semibold">Participantes</h2>
                 </div>
                 <section class="flex flex-wrap justify-around items-center">
+                    {% if use_technique == "escalas" %}
                     <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">
                         <span class="font-semibold">Máximo:</span>
                         <span>{{ max_testers }}</span>
                     </div>
+                    {% endif %}
                     <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">
-                        <span class="font-semibold">Actuales:</span>
+                        <span class="font-semibold">
+                            {% if use_technique == "escalas" %}
+                            Actuales:
+                            {% else %}
+                            Total:
+                            {% endif %}
+                        </span>
                         <span>{{ current_testers }}</span>
                     </div>
                     <div class="flex flex-col sm:flex-row sm:items-center sm:gap-2">

tecnicas/templates/tecnicas/manage_sesions/sesiones-panel.html

@@ -19,10 +19,14 @@
             </div>
         </header>
 
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
         {% if error %}
         {% include "../components/error-message.html" with message=error %}
         {% else %}
-        
+
         <section class="grid grid-cols-3 max-lg:grid-cols-2 max-sm:grid-cols-1 w-full gap-4 justify-center">
             {% for sesion in sessions %}
             {% include "../components/item_session.html" with sesion=sesion %}
@@ -39,13 +43,13 @@
                 </a>
                 {% endif %}
                 <button class="join-item btn bg-btn-secondary">Page {{ num_page }}</button>
-                {% if not last_page %} 
-                <a href="{% url 'cata_system:panel_sesiones' page=num_page|add:1 %}"class="w-fit">
+                {% if not last_page %}
+                <a href="{% url 'cata_system:panel_sesiones' page=num_page|add:1 %}" class="w-fit">
                     <button class="join-item btn bg-btn-secondary py-1">
                         <img class="h-full" src="{% static 'img/greater-than.svg' %}" alt="mayor que">
                     </button>
-                    </a>
-                    {% endif %}
+                </a>
+                {% endif %}
             </div>
         </section>
         {% endif %}

tecnicas/utils/__init__.py

@@ -3,5 +3,6 @@ from .code_generate import generarCodigos
 from .personal_errors import general_error, controller_error
 from .shuffle_arrays import shuffleArray
 from .general_controllers import getId
+from .general_controllers import noValidTechnique
 from .to_dict import defaultdict_to_dict
 from .delete_data_session import deleteDataSession

tecnicas/utils/general_controllers.py

@@ -1,3 +1,8 @@
+from django.shortcuts import redirect
+from django.urls import reverse
+from urllib.parse import urlencode
+
+
 def getId(value: object | int) -> int | None:
     if isinstance(value, int):
         return value
@@ -7,3 +12,12 @@ def getId(value: object | int) -> int | None:
         return value.pk
 
     return 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}"
+    else:
+        url_redireccion = f"{reverse({name_view}, kwargs=params)}"
+    return redirect(url_redireccion)

tecnicas/views/sessions_management/session_details.py

@@ -1,33 +1,58 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse
-from ...controllers import DetallesSesionController
+from tecnicas.models import SesionSensorial
+from tecnicas.utils import noValidTechnique
+from ...controllers import DetallesEscalasController
 
 
 def sessionDetails(req: HttpRequest, session_code: str):
-    controller_view = DetallesSesionController(session_code)
-    context = controller_view.getContextForView()
-
     if req.method == "GET":
-        context = controller_view.getContextWithData()
-        return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
+        if "message" in req.GET:
+            message = req.GET.get("message")
+        else:
+            message = ""
+
+        sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=session_code)
+        use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
+
+        if use_techinique == "escalas" or use_techinique == "rata":
+            controller_view = DetallesEscalasController(
+                session=sensorial_session)
+            response = controller_view.getResponse(
+                request=req, message=message)
+        else:
+            response = noValidTechnique(
+                params={"page": 1},
+                query_params={
+                    "message": "Al parecer la sesión usa una técnica que aun no se ha implementado para ver detalles"
+                },
+                name_view="cata_system:panel_sesiones"
+            )
+
+        return response
     elif req.method == "POST":
-        if req.POST["action"] == "start_session":
-            response = DetallesSesionController.startRepetition(
-                session_code=session_code, username=req.user.username)
-            if isinstance(response, dict):
-                context = controller_view.getContextWithData()
-                context["error"] = response["error"]
-                return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
-
-            parameters = {
-                "session_code": controller_view.session.codigo_sesion
-            }
-
-            return redirect(reverse("cata_system:monitor_sesion", kwargs=parameters))
-        elif req.POST.get("action") == "delete_session":
-            controller_view.deleteSesorialSession()
-            return redirect(reverse("cata_system:panel_sesiones", kwargs={"page": 1}))
+        sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=session_code)
+        use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
+
+        if use_techinique == "escalas" or use_techinique == "rata":
+            controller_view = DetallesEscalasController(sensorial_session)
+
+            if req.POST["action"] == "start_session":
+                response = controller_view.startRepetition(
+                    presenter=req.user.user_presentador)
+            elif req.POST.get("action") == "delete_session":
+                controller_view.deleteSesorialSession()
+                response = redirect(
+                    reverse("cata_system:panel_sesiones", kwargs={"page": 1}))
+            else:
+                response = controller_view.getResponse(
+                    error="No se reconoce la acción a realizar")
         else:
-            context["error"] = "no se reconoce la accion a realizar"
-            return render(req, "tecnicas/manage_sesions/detalles-sesion.html", context)
+            response = noValidTechnique()
+
+        return response
+    else:
+        return JsonResponse({"error": "Método no permitido"})

tecnicas/views/sessions_management/session_monitor.py

@@ -7,38 +7,57 @@ Para finalizar la sesion se debe realizar lo siguiente
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.controllers import MonitorSesionController
-from tecnicas.utils import general_error
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import MonitorEscalasController
+from tecnicas.utils import noValidTechnique
 
 
 def sessionMonitor(req: HttpRequest, session_code: str):
-    controll_view = MonitorSesionController(session_code)
-    context = controll_view.monitorView()
-
     if req.method == "GET":
-        if "error" in context:
-            return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
+        sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=session_code)
+        use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
 
-        context["code_session"] = session_code
-        return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
+        if use_techinique == "escalas" or use_techinique == "rata":
+            controll_view = MonitorEscalasController(sensorial_session)
+            response = controll_view.controlGetResponse(request=req)
+        else:
+            response = noValidTechnique(
+                params={
+                    "session_code": session_code,
+                },
+                query_params={
+                    "message": "Aun no se puede monitorear sesiones con esta técnica"
+                },
+                name_view="cata_system:detalles_sesion"
+            )
+
+        return response
     elif req.method == "POST":
-        action = req.POST["action"]
-        if action == "finish_session":
-            return actionFinishSession(context=context, session_code=session_code, controll_view=controll_view, req=req)
+        sensorial_session = SesionSensorial.objects.get(
+            codigo_sesion=session_code)
+        use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
+
+        if use_techinique == "escalas":
+            controll_view = MonitorEscalasController(sensorial_session)
+            action = req.POST["action"]
+            if action == "finish_session":
+                response = controll_view.controlPostResponseFinishSession(
+                    request=req)
+            else:
+                response = controll_view.controlGetResponse(
+                    request=req, error="No se ha definido la acción a realizar")
         else:
-            return general_error("No se ha especificado la acción")
+            response = noValidTechnique(
+                params={
+                    "session_code": session_code,
+                },
+                query_params={
+                    "message": "La técnica usada en la sesión aun no se implementa para esta función"
+                },
+                name_view="cata_system:detalles_sesion"
+            )
+
+        return response
     else:
         return JsonResponse({"error": "Método no permitido"})
-
-
-def actionFinishSession(context: dict, session_code: str, controll_view: MonitorSesionController, req: HttpRequest):
-    context["code_session"] = session_code
-    (is_all_end, message) = controll_view.checkAllParticipantsEnded()
-    context["message"] = message
-    if not is_all_end:
-        return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
-    response = controll_view.finishSession()
-    if isinstance(response, dict):
-        context["message"] = response["error"]
-        return render(req, "tecnicas/manage_sesions/monitor-sesion.html", context)
-    return redirect(reverse("cata_system:detalles_sesion", kwargs={"session_code": session_code}))

tecnicas/views/sessions_management/sessions_panel.py

@@ -1,22 +1,27 @@
-from django.http import HttpRequest
+from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render
-from ...controllers import SesionController
+from tecnicas.controllers import SesionController
 
 
 def sesionsPanel(req: HttpRequest, page: int):
     context = {"num_page": page}
 
-    response = SesionController.getSessionsSavesByCretor(
-        user_name=req.user.username, page=page)
+    if req.method == "GET":
+        response = SesionController.getSessionsSavesByCretor(
+            user_name=req.user.username, page=page)
 
-    if isinstance(response, dict):
-        context["error"] = response["error"]
-        return render(req, "tecnicas/manage_sesions/sesiones-panel.html", context=context)
-    
-    (sessions_in_page, is_last_page, current_page) = response
+        if isinstance(response, dict):
+            context["error"] = response["error"]
+            return render(req, "tecnicas/manage_sesions/sesiones-panel.html", context=context)
+
+        (sessions_in_page, is_last_page, current_page) = response
 
-    context["sessions"] = sessions_in_page
-    context["last_page"] = is_last_page
-    context["num_paginas"] = current_page
+        context["sessions"] = sessions_in_page
+        context["last_page"] = is_last_page
+        context["num_paginas"] = current_page
+        if "message" in req.GET:
+            context["message"] = req.GET.get("message")
 
-    return render(req, "tecnicas/manage_sesions/sesiones-panel.html", context=context)
+        return render(req, "tecnicas/manage_sesions/sesiones-panel.html", context=context)
+    else:
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/views/tester_forms/init_tester_form.py

@@ -1,11 +1,12 @@
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.controllers import SesionController, MainTesterFormController, ParticipacionController
+from tecnicas.controllers import MainTesterFormController, ParticipacionController
+from tecnicas.models import SesionSensorial
 
 
 def initTesterForm(req: HttpRequest, code_sesion: str):
-    session = SesionController.getSessionByCodePanelTester(code_sesion)
+    session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
 
     context = {
         "session": session
@@ -17,16 +18,20 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
     template_url = "tecnicas/forms_tester/init_session.html"
 
     if req.method == "GET":
-        order = view_controller.checkAssignOrder()
+        order = view_controller.checkAndAssignOrder()
 
-        if not isinstance(order, dict):
-            req.session["id_order"] = order.id
-            is_end = view_controller.isEndedSession(
-                repetition=session.tecnica.repeticion)
+        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
 
-            if is_end:
-                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-                context["has_ended"] = True
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
 
         return render(req, template_url, context)
     elif req.method == "POST":
@@ -35,26 +40,13 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
                 "code_sesion": code_sesion
             }
 
-            if "id_order" in req.session:
-                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)
-
-                return redirect(reverse("cata_system:session_convencional", kwargs=parameters))
-
-            order = view_controller.assignOrder()
-            if isinstance(order, dict):
-                context["error"] = order["error"]
-                return 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(
@@ -67,11 +59,3 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
             return render(req, template_url, context)
     else:
         return JsonResponse({"error": "metodo no permitido"})
-
-# 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
-
-# response.set_cookie('id_participacion', taster_participation.id, max_age=60*60*24)