Merge pull request #22 from CascoArcilla/HU10

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/models_controller/palabras_controller.py

@@ -14,11 +14,9 @@ class PalabrasController():
         self.ids_words = new_ids
 
     def setWords(self):
-        self.words = []
-        searched_words = list(Palabra.objects.filter(id__in=self.ids_words))
-        if not len(searched_words):
+        self.words = list(Palabra.objects.filter(id__in=self.ids_words))
+        if not len(self.words):
             return controller_error("No se han encontrado registros")
-        self.words = searched_words
         return self.words
 
     @staticmethod

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -6,9 +6,9 @@ from tecnicas.utils import controller_error
 class TecnicaController():
     def setTechnique(self, **kwargs):
         self.technique = Tecnica(
-            tipo_tecnica=kwargs["tipo_tecnica"],
-            id_estilo=kwargs["estilo_palabras"],
-            repeticiones_max=kwargs["numero_repeticiones"] or 0,
+            tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=kwargs["name_tecnica"]),
+            id_estilo=EstiloPalabra.objects.get(id=kwargs["estilo_palabras"]),
+            repeticiones_max=kwargs["numero_repeticiones"] or 1,
             limite_catadores=kwargs["numero_catadores"],
             instrucciones=kwargs["instrucciones"],
         )
@@ -17,7 +17,7 @@ class TecnicaController():
         self.technique = Tecnica(
             tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=basic["name_tecnica"]),
             id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
-            repeticiones_max=basic["numero_repeticiones"] or 0,
+            repeticiones_max=basic["numero_repeticiones"] or 1,
             limite_catadores=basic["numero_catadores"],
             instrucciones=basic["instrucciones"] or "Espere instrucciones del Presentador",
         )

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -5,14 +5,25 @@ from django.urls import reverse
 
 
 class PanelBasicController():
+    conf_initial_rata = {
+        "numero_catadores": 0,
+        "numero_repeticiones": 1
+    }
+
     def __init__(self):
         pass
 
     @staticmethod
     def controllGetEscalas(request: HttpRequest):
         form_sesion = SesionBasicForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "escalas"
+        }
+
         response = render(
-            request, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form_sesion})
+            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
         return response
 
     @staticmethod
@@ -40,3 +51,55 @@ class PanelBasicController():
                 "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
 
         return response
+
+    @staticmethod
+    def controllGetRATA(request: HttpRequest):
+        form_sesion = SesionBasicForm(
+            initial_conf=PanelBasicController.conf_initial_rata)
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "rata"
+        }
+
+        response = render(
+            request, "tecnicas/create_sesion/configuracion-panel-basic.html", view_context)
+        return response
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest, name_tecnica: str):
+        try:
+            form = SesionBasicForm(
+                request.POST, initial_conf=PanelBasicController.conf_initial_rata)
+
+            if form.is_valid():
+                values = {}
+                for name, value in form.cleaned_data.items():
+                    if name == "estilo_palabras" or name == "tipo_escala":
+                        values[name] = value.id
+                    else:
+                        values[name] = value
+
+                for key, expected in PanelBasicController.conf_initial_rata.items():
+                    actual = values.get(key)
+
+                    if actual is None or str(actual) != str(expected):
+                        form.add_error(
+                            key, f"Valor inválido para '{key}': se esperaba {expected}, se recibió {actual}")
+
+                if form.errors:
+                    response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                        "form_sesion": form, "error": "No puedes modificar el número de catadores o repeticiones"})
+                else:
+                    values["name_tecnica"] = name_tecnica
+                    request.session['form_basic'] = values
+                    response = redirect(
+                        reverse("cata_system:panel_configuracion_tags"))
+            else:
+                response = render(request, "tecnicas/create_sesion/configuracion-panel-basic.html", {
+                    "form_sesion": form, "error": "Información no valida"})
+        except KeyError:
+            response = redirect(reverse(
+                "cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -23,7 +23,8 @@ class PanelCodesController():
 
         context_codes_form = {
             "form_codes": form_codes,
-            "num_tester": num_tester
+            "num_tester": num_tester,
+            "use_technique": "escalas"
         }
 
         return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
@@ -48,6 +49,7 @@ class PanelCodesController():
         context_codes_form = {
             "form_codes": form_codes,
             "num_tester": num_tester,
+            "use_technique": "escalas"
         }
 
         if form_codes.is_valid():
@@ -64,6 +66,44 @@ class PanelCodesController():
 
         return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
 
+    @staticmethod
+    def controllGetRATA(request: HttpRequest, data):
+        num_products = data["numero_productos"]
+        codes_products = generarCodigos(num_products)
+        form_codes = CodesForm(codes=codes_products)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "num_tester": 0,
+            "use_technique": "rata"
+        }
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest):
+        codes = []
+        context_codes_form = {}
+
+        for name, value in request.POST.items():
+            if name.__contains__("producto_"):
+                codes.append(value)
+
+        form_codes = CodesForm(request.POST, codes=codes)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "use_technique": "rata"
+        }
+
+        if form_codes.is_valid():
+            request.session["form_codes"] = codes
+            return redirect(reverse("cata_system:panel_configuracion_words"))
+        else:
+            context_codes_form["error"] = "error en los datos recibidos"
+
+        return render(request, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
+
     @staticmethod
     def defineInfoConvencional(data):
         num_products = data["numero_productos"]

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

@@ -1,5 +1,6 @@
 from django.http import HttpRequest, JsonResponse
 from django.db import transaction
+from django.shortcuts import render
 from tecnicas.utils import general_error
 from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
 from tecnicas.utils import deleteDataSession
@@ -10,8 +11,9 @@ class PanelCreateController():
         pass
 
     @staticmethod
-    def controllGetEscalas(request: HttpRequest, data):
-        pass
+    def controllGetEscalas(request: HttpRequest):
+        return render(
+            request, 'tecnicas/create_sesion/creando_sesion.html')
 
     @staticmethod
     def controllPostEscalas(request: HttpRequest):
@@ -29,7 +31,6 @@ class PanelCreateController():
                 data_basic = request.session["form_basic"]
                 controllerTechnique = TecnicaController()
                 controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
-
                 technique = controllerTechnique.saveTechnique()
                 if not technique:
                     return general_error("Error al guardar la técnica")
@@ -147,7 +148,7 @@ class PanelCreateController():
 
                 # ////////////////////////////////// #
                 #
-                # Final step: Delete date en session #
+                # Final step: Delete date in session #
                 #
                 # ////////////////////////////////// #
 
@@ -155,3 +156,119 @@ class PanelCreateController():
                 return JsonResponse(context)
         else:
             return general_error("No se ha establecido acción")
+
+    @staticmethod
+    def controllPostRATA(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+
+            with transaction.atomic():
+                # ////////////////////////////////////////////////////// #
+                #
+                # First step: Create technique and scale with their tags #
+                #
+                # ////////////////////////////////////////////////////// #
+                data_basic = request.session["form_basic"]
+                data_basic["numero_catadores"] = 0
+                data_basic["numero_repeticiones"] = 1
+                controllerTechnique = TecnicaController()
+                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
+                technique = controllerTechnique.saveTechnique()
+                if not technique:
+                    return general_error("Error al guardar la técnica")
+
+                data_scale = {
+                    "id_scale": data_basic["tipo_escala"],
+                    "size": data_basic["tamano_escala"],
+                    "technique": technique
+                }
+
+                controllerScale = EscalaController(data=data_scale)
+
+                scale = controllerScale.saveScale()
+                if isinstance(scale, dict):
+                    return general_error(scale["error"])
+
+                dict_tags = request.session["form_tags"]
+                saved_related_tags = controllerScale.realteTags(dict_tags)
+                if "error" in saved_related_tags:
+                    return general_error(saved_related_tags["error"])
+
+                # ////////////////////////////////////////////// #
+                #
+                # Second step: Create productos with their codes #
+                #
+                # ////////////////////////////////////////////// #
+                codes = request.session["form_codes"]
+
+                controllerProducts = ProductosController(
+                    codes=codes,
+                    technique=technique
+                )
+
+                controllerProducts.setProductsNoSave()
+                saved_prodcuts = controllerProducts.saveProducts()
+                if isinstance(saved_prodcuts, dict):
+                    return general_error(saved_prodcuts["error"])
+
+                # /////////////////////////////////////////////////////// #
+                #
+                # Third step: Create relations technique with Words Style #
+                #
+                # /////////////////////////////////////////////////////// #
+                ids_words = request.session["form_words"]
+                words_controller = PalabrasController(ids=ids_words)
+
+                words_to_use = words_controller.setWords()
+                if isinstance(words_to_use, dict):
+                    return general_error(words_to_use["error"])
+
+                style_controller = EstiloPalabrasController(
+                    technique=technique, words=words_to_use)
+
+                instace_style = style_controller.createAndSaveInstaceStyle()
+                if isinstance(instace_style, dict):
+                    return general_error(instace_style["error"])
+
+                words_using = style_controller.relatedWords()
+                if isinstance(words_using, dict):
+                    return general_error(words_using["error"])
+
+                # //////////////////////////////////////////////////////// #
+                #
+                # Fourth step: Create session and relat with the technique #
+                #
+                # //////////////////////////////////////////////////////// #
+                session_controller = SesionController(
+                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                    technique=technique,
+                    creator=request.user.user_presentador
+                )
+
+                setting_session = session_controller.setSession()
+                if isinstance(setting_session, dict):
+                    return general_error(setting_session["error"])
+
+                saved_session = session_controller.saveSession()
+                if isinstance(saved_session, dict):
+                    return general_error(saved_session["error"])
+
+                context = {
+                    "message": "sesión creada",
+                    "data": {
+                        "codigo_sesion": saved_session.codigo_sesion,
+                        "nombre_sesion": saved_session.nombre_sesion
+                    }
+                }
+
+                # ////////////////////////////////// #
+                #
+                # Final step: Delete date en session #
+                #
+                # ////////////////////////////////// #
+                deleteDataSession(request)
+                return JsonResponse(context)
+        else:
+            return general_error("No se ha establecido acción")

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/forms/codes_form.py

@@ -1,10 +1,11 @@
 from django import forms
 
+
 class CodesForm(forms.Form):
-    def __init__(self, *args, codes = [], **kwargs):
+    def __init__(self, *args, codes=[], **kwargs):
         super().__init__(*args, **kwargs)
 
         for index, code in enumerate(codes):
             self.fields[f'producto_{index+1}'] = forms.CharField(max_length=3, required=True, min_length=3, initial=code, label=f"codigo {index+1}", widget=forms.TextInput(attrs={
                 "class": "ct-code bg-surface-ligt p-1 border-b-1 text-center w-full disabled:bg-surface-general uppercase"
-            }))
+            }))

tecnicas/forms/sesion_basic_form.py

@@ -34,9 +34,12 @@ class SesionBasicForm(forms.Form):
         "placeholder": "Este campo es opcional"
     }), required=False)
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, initial_conf: dict = None, **kwargs):
         super().__init__(*args, **kwargs)
 
+        if initial_conf is None:
+            initial_conf = {}
+
         self.fields['estilo_palabras'] = forms.ModelChoiceField(queryset=EstiloPalabra.objects.all(), widget=forms.RadioSelect(attrs={
             "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
         }), required=True, initial=EstiloPalabra.objects.first())
@@ -49,6 +52,12 @@ class SesionBasicForm(forms.Form):
             "class": "cts-size-input",
         }), required=True)
 
+        if "numero_catadores" in initial_conf:
+            self.fields["numero_catadores"].initial = initial_conf["numero_catadores"]
+
+        if "numero_repeticiones" in initial_conf:
+            self.fields["numero_repeticiones"].initial = initial_conf["numero_repeticiones"]
+
     def clean(self):
         data_clean = super().clean()
         escala = data_clean.get("tipo_escala")

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-basic.html

@@ -26,20 +26,45 @@
                         {{ form_sesion.nombre_sesion }}
                     </label>
                 </section>
-                <section
-                    class="flex flex-row flex-wrap justify-center gap-4 [&>label]:text-lg [&>label]:flex [&>label]:flex-col [&>label]:items-center [&>label]:px-2 [&>label]:font-medium [&>label]:tracking-wide [&>label]:[&>p]:tracking-normal [&>label]:[&>p]:text-base [&>label]:[&>p]:font-bold">
-                    <label for="{{ form_sesion.numero_productos.id_for_label }}">
-                        <p>Número de Productos:</p>
+                <section class="flex flex-row flex-wrap justify-center gap-4">
+                    <label for="{{ form_sesion.numero_productos.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Productos:
+                        </p>
                         {{ form_sesion.numero_productos }}
                     </label>
-                    <label for="{{ form_sesion.numero_catadores.id_for_label }}">
-                        <p>Número de Catadores:</p>
+                    {% if use_technique == 'escalas' %}
+                    <label for="{{ form_sesion.numero_catadores.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Catadores:
+                        </p>
                         {{ form_sesion.numero_catadores }}
                     </label>
-                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}">
-                        <p>Número de Repeticiones:</p>
+                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                    <p class="tracking-normal text-base font-bold">
+                        Número de Repeticiones:
+                    </p>
+                    {{ form_sesion.numero_repeticiones }}
+                    </label>
+                    {% else %}
+                    <label for="{{ form_sesion.numero_catadores.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide hidden">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Catadores:
+                        </p>
+                        {{ form_sesion.numero_catadores }}
+                    </label>
+                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide hidden">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de Repeticiones:
+                        </p>
                         {{ form_sesion.numero_repeticiones }}
                     </label>
+                    {% endif %}
                 </section>
                 <section class="flex justify-center items-center mt-2">
                     <label for="{{form_sesion.instrucciones.id_for_label}}"
@@ -95,15 +120,18 @@
                     </label>
                     <div class="flex justify-around max-sm:flex-col gap-8 cts-options-size-scale">
                         <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="5" class="radio radio-lg checked:bg-pink-500" />
+                            <input type="radio" name="option_size_scale" value="5"
+                                class="radio radio-lg checked:bg-pink-500" />
                             <span class="mt-2 text-xl text-gray-700 font-medium">5</span>
                         </label>
                         <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="7" class="radio radio-lg checked:bg-pink-500" />
+                            <input type="radio" name="option_size_scale" value="7"
+                                class="radio radio-lg checked:bg-pink-500" />
                             <span class="mt-2 text-xl text-gray-700 font-medium">7</span>
                         </label>
                         <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="9" class="radio radio-lg checked:bg-pink-500" />
+                            <input type="radio" name="option_size_scale" value="9"
+                                class="radio radio-lg checked:bg-pink-500" />
                             <span class="mt-2 text-xl text-gray-700 font-medium">9</span>
                         </label>
                     </div>

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-codes.html

@@ -27,12 +27,15 @@
                     </label>
                     {% endfor %}
                 </article>
+                {% if use_technique == 'escalas' %}
                 <button type="button" class="cts-btn-general cts-btn-secondary btn-push uppercase"
                     onclick="setPermutations()">
                     regenerar ordenes
                 </button>
+                {% endif %}
             </article>
 
+            {% if use_technique == 'escalas' %}
             <h2 class="text-2xl mb-2 font-bold">Ordenes</h2>
             <hr>
             <article class="w-full">
@@ -42,6 +45,7 @@
                     </article>
                 </section>
             </article>
+            {% endif %}
 
             <hr>
             <article class="flex flex-col items-center gap-4">
@@ -62,11 +66,16 @@
                 </a>
             </article>
         </form>
+
+        {% if use_technique == 'escalas' %}
         <input type="number" value="{{ num_tester }}" class="ct-num-cata hidden" disabled>
+        {% endif %}
     </article>
 </article>
 {% endblock %}
 
 {% block extra_js %}
+{% if use_technique == 'escalas' %}
 <script src="{% static 'js/panel-codes.js' %}"></script>
+{% endif %}
 {% endblock %}

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_config/configuration_panel_basic.py

@@ -7,12 +7,14 @@ from tecnicas.utils import deleteDataSession
 
 def configurationPanelBasic(req: HttpRequest):
     deleteDataSession(req)
-    
+
     if req.method == "GET":
         name_tecnica = req.GET["name_tecnica"]
 
         if name_tecnica == "escalas":
             response = PanelBasicController.controllGetEscalas(request=req)
+        elif name_tecnica == "rata":
+            response = PanelBasicController.controllGetRATA(request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida o sin implementar")
@@ -24,6 +26,9 @@ def configurationPanelBasic(req: HttpRequest):
         if name_tecnica == "escalas":
             response = PanelBasicController.controllPostEscalas(
                 request=req, name_tecnica=name_tecnica)
+        elif name_tecnica == "rata":
+            response = PanelBasicController.controllPostRATA(
+                request=req, name_tecnica=name_tecnica)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=¡Oh, vaya! Cambio de técnica repentino, vuelve a elegir otra vez")

tecnicas/views/sessions_config/configuration_panel_codes.py

@@ -10,26 +10,31 @@ def configurationPanelCodes(req: HttpRequest):
         deleteDataSession(req)
         return redirect(reverse("cata_system:seleccion_tecnica") +
                         "?error=datos del formulario requerido no encontrados")
-    
+
     data_basic = req.session["form_basic"]
 
     if req.method == "GET":
         if data_basic["name_tecnica"] == "escalas":
             response = PanelCodesController.controllGetEscalas(
                 req, data_basic)
+        elif data_basic["name_tecnica"] == "rata":
+            response = PanelCodesController.controllGetRATA(
+                req, data_basic)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
-            
+
         return response
     elif req.method == "POST":
         if data_basic["name_tecnica"] == "escalas":
             response = PanelCodesController.controllPostEscalas(
                 req, data_basic)
+        elif data_basic["name_tecnica"] == "rata":
+            response = PanelCodesController.controllPostRATA(request=req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
-            
+
         return response
     else:
         return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/configuration_panel_tags.py

@@ -10,11 +10,11 @@ def configurationPanelTags(req: HttpRequest):
         deleteDataSession(req)
         return redirect(reverse('cata_system:panel_configuracion_basic') +
                         "?error=datos requeridos no encontrados")
-    
+
     basic_data = req.session.get("form_basic")
 
     if req.method == "GET":
-        if basic_data["name_tecnica"] == "escalas":
+        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
             response = PanelTagsController.controllGetEscalas(
                 request=req, data=basic_data)
         else:
@@ -23,7 +23,7 @@ def configurationPanelTags(req: HttpRequest):
 
         return response
     elif req.method == "POST":
-        if basic_data["name_tecnica"] == "escalas":
+        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
             response = PanelTagsController.controllPostEscalas(
                 request=req, data=basic_data)
         else:

tecnicas/views/sessions_config/configuration_panel_words.py

@@ -14,7 +14,7 @@ def configurationPanelWords(req: HttpRequest):
     basic_data = req.session["form_basic"]
 
     if req.method == "GET":
-        if basic_data["name_tecnica"] == "escalas":
+        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
             response = PanelWordsController.controllGetEscalas(req)
         else:
             response = redirect(
@@ -22,12 +22,12 @@ def configurationPanelWords(req: HttpRequest):
 
         return response
     elif req.method == "POST":
-        if basic_data["name_tecnica"] == "escalas":
+        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
             response = PanelWordsController.controllPostEscalas(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
-            
+
         return response
     else:
         return JsonResponse({"message": "Método no permitido"})

tecnicas/views/sessions_config/create_session.py

@@ -14,9 +14,8 @@ def createSession(req: HttpRequest):
     basic_data = req.session["form_basic"]
 
     if req.method == "GET":
-        if basic_data["name_tecnica"] == "escalas":
-            response = render(
-                req, 'tecnicas/create_sesion/creando_sesion.html')
+        if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
+            response = PanelCreateController.controllGetEscalas(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
@@ -25,6 +24,8 @@ def createSession(req: HttpRequest):
     if req.method == "POST":
         if basic_data["name_tecnica"] == "escalas":
             response = PanelCreateController.controllPostEscalas(req)
+        elif basic_data["name_tecnica"] == "rata":
+            response = PanelCreateController.controllPostRATA(req)
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")

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)