Merge pull request #25 from CascoArcilla/HU9

Dockerfile

@@ -0,0 +1,35 @@
+FROM ubuntu:24.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    python3 python3-dev python3-pip python3-venv \
+    gcc pkg-config \
+    default-libmysqlclient-dev \
+    nodejs npm \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /cata_system
+
+RUN npm install -g pnpm
+
+COPY requirements.txt .
+
+RUN python3 -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+RUN pip install --upgrade pip && \
+    pip install wheel && \
+    pip install -r requirements.txt
+
+COPY . .
+
+RUN python3 manage.py tailwind install
+RUN python3 manage.py tailwind build
+RUN python3 manage.py collectstatic --noinput
+
+EXPOSE 7860
+
+CMD ["python3", "manage.py", "runserver", "0.0.0.0:7860"]

tecnicas/controllers/__init__.py

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

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -6,49 +6,22 @@ from tecnicas.utils import controller_error, getId
 
 class CalificacionController():
     def __init__(self, product: Producto | int, technique: Tecnica | int, tester: Catador | int):
+        technique = Tecnica.objects.only(
+            "repeticion").get(id=getId(technique))
+
         atributes = {
-            "num_repeticion": 0,
-            "id_tecnica_id": getId(technique),
+            "num_repeticion": technique.repeticion,
+            "id_tecnica": technique,
             "id_producto_id": getId(product),
             "id_catador_id": getId(tester),
         }
 
-        self.rating = Calificacion(**atributes)
-
-    def validateRating(self):
-        try:
-            self.rating.clean()
-            return self.rating
-        except ValidationError as e:
-            return controller_error("No es posible validar la calificación")
-
-    def setRepetition(self, repetition: int = None) -> int | dict:
-        try:
-            if repetition is not None:
-                self.rating.num_repeticion = repetition
-            else:
-                self.rating.num_repeticion = self.rating.id_tecnica.repeticion
-
-            return self.rating.num_repeticion
-        except ValidationError as e:
-            return controller_error(e)
-
-    def saveRating(self):
-        try:
-            self.rating.save()
-            return self.rating
-        except ValidationError as e:
-            return controller_error(e)
+        (self.rating, created) = Calificacion.objects.get_or_create(**atributes)
 
     @staticmethod
     def getRatingsByTechnique(technique: Tecnica):
         repetition = technique.repeticion
-
-        if not repetition:
-            return controller_error("Sin datos calificados aún")
-
         ratings = list(Calificacion.objects.filter(id_tecnica=technique))
-
         return ratings
 
     @staticmethod
@@ -94,39 +67,53 @@ class CalificacionController():
         return ratings
 
     @staticmethod
-    def checkProducsWithoutRating(
+    def checkPositionWithoutRating(
             positions: list[Posicion] = None,
-            user_cata: str = None,
+            user_cata: Catador | str = None,
             repetition: int = None,
-            technique: Tecnica = None,
-            id_technique: int = None,
+            technique: Tecnica | int = None,
             num_words: int = None):
-        check_products = [position.id_producto for position in positions]
+        end_rating = False
+
+        # Obtener lista con codigos de productos
+        check_products = [
+            position.id_producto.codigoProducto for position in positions]
 
         filters = {
-            "user_tester": user_cata,
-            "repetition": repetition
+            "num_repeticion": repetition,
+            "id_tecnica": getId(technique)
         }
 
-        if technique is not None:
-            filters["technique"] = technique
-        elif id_technique is not None:
-            filters["id_technique"] = id_technique
+        if isinstance(user_cata, Catador):
+            filters["id_catador"] = user_cata
+        else:
+            filters["id_catador"] = Catador.objects.get(
+                user__username=user_cata)
 
-        ratings = CalificacionController.getRatings(**filters)
+        ratings = list(Calificacion.objects.filter(**filters).select_related(
+            "id_producto",
+            "id_tecnica",
+            "id_catador",
+        ))
 
+        # Si no hay calificaciones regresar las posiciones
         if len(ratings) == 0:
-            return positions
+            return (positions, end_rating)
 
-        ratings_dict = defaultdict(list)
+        rating_products = [
+            rating.id_producto.codigoProducto for rating in ratings]
 
-        for rat in ratings:
-            ratings_dict[rat.id_producto.id].append(rat)
+        for index, rating in enumerate(ratings):
+            data_rating = rating.dato_calificacion.all()
 
-        for index, product in enumerate(check_products):
-            ratings_of_product = ratings_dict.get(product.id, [])
+            if len(data_rating) < num_words or len(data_rating) == 0:
+                return (positions[index], end_rating)
 
-            if len(ratings_of_product) < num_words or len(ratings_of_product) == 0:
-                return positions[index]
-
-        return controller_error("Sin productos por calificar")
+        next_product = list(set(check_products) - set(rating_products))
+        if len(next_product) != 0:
+            next_position = [
+                position for position in positions if position.id_producto.codigoProducto == next_product[0]][0]
+            return (next_position, end_rating)
+        else:
+            end_rating = True
+            return (positions[-1], end_rating)

tecnicas/controllers/models_controller/dato_controller.py

@@ -12,7 +12,11 @@ class DatoController():
         }
 
         self.data = Dato(**atributes)
-        self.value_data = ValorDecimal(valor=value_rating)
+
+        if isinstance(value_rating, bool):
+            self.value_data = ValorBooleano(valor=value_rating)
+        else:
+            self.value_data = ValorDecimal(valor=value_rating)
 
     def setRating(self, new_rating: Calificacion):
         try:
@@ -35,19 +39,14 @@ class DatoController():
         except ValidationError as e:
             return controller_error(e.message)
 
-    def setInstanceValue(self):
-        technique = self.data.id_calificacion.id_tecnica
-
-        if technique.tipo_tecnica == "cata":
-            self.value_data = ValorBooleano(
-                id_dato=self.data,
-                valor=self.value_data.valor
-            )
+    def setValue(self, new_value=None):
+        if new_value:
+            if isinstance(new_value, bool):
+                self.value_data = ValorBooleano(valor=new_value)
+            else:
+                self.value_data = ValorDecimal(valor=new_value)
         else:
-            self.value_data = ValorDecimal(
-                id_dato=self.data,
-                valor=self.value_data.valor
-            )
+            self.value_data.id_dato = self.data
 
         return self.value_data
 
@@ -88,7 +87,7 @@ class DatoController():
                 repeticion=F("id_dato__id_calificacion__num_repeticion"),
                 producto_code=F(
                     "id_dato__id_calificacion__id_producto__codigoProducto"),
-                usuarioCatador=F(
+                usuario_catador=F(
                     "id_dato__id_calificacion__id_catador__user__username"),
                 dato_valor=F("valor")
             )

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -16,15 +16,12 @@ class ParticipacionController():
             return controller_error("No se ha encontrado la participación")
 
     @staticmethod
-    def finishSession(id_participation: int):
-        try:
-            participation = Participacion.objects.get(id=id_participation)
-            participation.finalizado = True
-            participation.activo = False
-            participation.save()
-            return participation
-        except Participacion.DoesNotExist:
-            return controller_error("No se ha encontrado la participación")
+    def finishSession(participation: Participacion):
+        participation.refresh_from_db()
+        participation.finalizado = True
+        participation.activo = False
+        participation.save()
+        return participation
 
     @staticmethod
     def outSession(tester: Catador, session: SesionSensorial):

tecnicas/controllers/models_controller/sesion_controller.py

@@ -131,14 +131,6 @@ class SesionController():
         else:
             use_session = session
 
-        (is_update_participations,
-         message) = ParticipacionController.outAllInSession(use_session)
-
-        if not is_update_participations:
-            return controller_error(message)
-
         use_session.activo = False
-
         use_session.save()
-
         return session

tecnicas/controllers/views_controller/api_rating_controller.py

@@ -7,65 +7,18 @@ class ApiRatingController():
         self.rating_controller = rating_controller
         self.data_controller = data_controller
 
-    def setRating(self) -> int | dict:
-        repetition = self.rating_controller.setRepetition()
-        if isinstance(repetition, dict):
-            return controller_error(repetition["error"])
-        return repetition
+    def controllPostScales(self) -> dict:
+        self.data_controller.setRating(
+            new_rating=self.rating_controller.rating
+        )
 
-    def saveRating(self):
-        rating = self.rating_controller.saveRating()
-        if isinstance(rating, dict):
-            return controller_error(rating["error"])
-        return rating
-
-    def setRatingInData(self):
-        update_rating = self.data_controller.setRating(
-            self.rating_controller.rating)
-        if isinstance(update_rating, dict):
-            return controller_error(update_rating["error"])
-        return update_rating
-
-    def saveData(self):
         data = self.data_controller.saveData()
-        if isinstance(data, dict):
-            return controller_error(data["error"])
-        return data
-
-    def setValueRating(self):
-        self.data_controller.setInstanceValue()
-
-    def saveValue(self):
-        value = self.data_controller.saveValue()
-        if isinstance(value, dict):
-            return controller_error(value["error"])
-
-    def logicView(self) -> dict:
-        validate = self.rating_controller.validateRating()
-        if isinstance(validate, dict):
-            return controller_error(validate["error"])
-
-        reptition = self.setRating()
-        if isinstance(reptition, dict):
-            return controller_error(reptition["error"])
-
-        rating = self.saveRating()
-        if isinstance(rating, dict):
-            return controller_error(rating["error"])
-
-        rating_data = self.setRatingInData()
-        if isinstance(rating_data, dict):
-            return controller_error(rating_data["error"])
-
-        data = self.saveData()
         if isinstance(data, dict):
             return controller_error(data["error"])
 
-        value = self.setValueRating()
-        if isinstance(value, dict):
-            return controller_error(value["error"])
+        self.data_controller.setValue()
         
-        value_save = self.saveValue()
+        value_save = self.data_controller.saveValue()
         if isinstance(value_save, dict):
             return controller_error(value_save["error"])
 

tecnicas/controllers/views_controller/session_management/details_escala_controller.py

@@ -14,8 +14,8 @@ Encabezados de como deben de aparecer los datos juntos
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Tecnica
-from tecnicas.controllers import DatoController, CalificacionController, PalabrasController
+from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion
+from tecnicas.controllers import DatoController, PalabrasController, ParticipacionController
 from .details_controller import DetallesController
 from tecnicas.utils import defaultdict_to_dict, controller_error
 from collections import defaultdict
@@ -34,7 +34,7 @@ class DetallesEscalasController(DetallesController):
             context["error"] = error
         if message != "" or message:
             context["message"] = message
-            
+
         return render(
             request, self.url_template, context)
 
@@ -43,16 +43,19 @@ class DetallesEscalasController(DetallesController):
             "use_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
         }
         self.context["sesion"] = self.session
+
+        # Recuperar la palabras de la tecnica
         self.words = PalabrasController.getWordsInTechnique(
             self.session.tecnica)
         self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
+        # Se recuperan las calificaciones
         ratings_for_repetition = []
 
-        ratings = CalificacionController.getRatingsByTechnique(
-            technique=self.session.tecnica)
+        ratings = list(Calificacion.objects.filter(
+            id_tecnica=self.session.tecnica))
 
-        if isinstance(ratings, dict) or not ratings:
+        if not ratings:
             self.context["calificaciones"] = ratings_for_repetition
             self.context["existen_calificaciones"] = False
             return self.context
@@ -64,7 +67,7 @@ class DetallesEscalasController(DetallesController):
             lambda: defaultdict(lambda: defaultdict(list)))
 
         for item in data:
-            user = item["usuarioCatador"]
+            user = item["usuario_catador"]
             rep = item["repeticion"]
             prod = item["producto_code"]
 
@@ -77,18 +80,30 @@ class DetallesEscalasController(DetallesController):
             ratings_for_repetition)
         self.context["existen_calificaciones"] = True
 
+        # Se comprueba que ya no se pueda iniciar la repeticion
+        self.context["fin_repeticiones"] = self.session.tecnica.repeticion >= self.session.tecnica.repeticiones_max
+
         return self.context
 
-    def startRepetition(self, presenter: Presentador):
+    def startRepetition(self, presenter: Presentador, request: HttpRequest):
         creator = presenter
         technique = self.session.tecnica
 
         if creator.user.username != self.session.creadoPor.user.username:
-            return self.getResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición")
+            return self.getResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición", request=request)
         elif self.session.activo:
-            return self.getResponse(error="La sesión ya está activada")
-        elif technique.repeticion == technique.repeticiones_max:
-            return self.getResponse(error="Se ha alcanzado el número de repeticiones máxima")
+            return self.getResponse(error="La sesión ya está activada", request=request)
+        elif technique.repeticion >= technique.repeticiones_max:
+            return self.getResponse(error="Se ha alcanzado el número de repeticiones máxima", request=request)
+
+        there_participacions = Participacion.objects.filter(
+            tecnica=technique).exists()
+
+        if there_participacions:
+            (is_update_participations,
+             message) = ParticipacionController.outAllInSession(self.session)
+            if not is_update_participations:
+                return self.getResponse(error=message, request=request)
 
         self.session.activo = True
         technique.repeticion = technique.repeticion + 1

tecnicas/controllers/views_controller/session_management/monitor_controller.py

@@ -4,7 +4,3 @@ 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/session_management/monitor_escalas_controller.py

@@ -89,5 +89,5 @@ class MonitorEscalasController(MonitorController):
         response = SesionController.finishRepetion(self.sensorial_session)
         if isinstance(response, dict):
             return controller_error(response["error"])
-        self.updataSession()
+        self.sensorial_session.refresh_from_db()
         return self.sensorial_session

tecnicas/controllers/views_controller/sessions_tester/convencional_scales_controller.py

@@ -0,0 +1,158 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Catador, Participacion, Producto, Calificacion, Palabra
+from tecnicas.controllers import PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+
+
+class ConvencionalScalesController:
+    context = {}
+    current_directory = "tecnicas/forms_tester/convencional.html"
+    previus_directory = "cata_system:catador_init_session"
+
+    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
+        self.tester = user_tester
+        self.session = sensorial_session
+
+    def controllGetEscalas(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        ctx = self.context
+        ctx["session"] = self.session
+
+        # Obtener posiciones y palabras de la técnica
+        positions_in_order = PosicionController.getPostionsInOrder(
+            id_order=request.session["id_order"])
+        aligned_positions_in_order = sorted(
+            positions_in_order, key=lambda p: p.posicion)
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        # Comprobar siguiente posición sin calificar
+        (next_position, end_products) = CalificacionController.checkPositionWithoutRating(
+            positions=aligned_positions_in_order,
+            user_cata=request.user.user_catador,
+            repetition=technique.repeticion,
+            technique=technique,
+            num_words=len(words)
+        )
+
+        # Si no hay productos se finaliza la sesion
+        if end_products:
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse('cata_system:catador_init_session', kwargs=params))
+
+        # Si devuelve una lista, tomar el primer elemento
+        if isinstance(next_position, list):
+            next_position = next_position[0]
+
+        # Producto a calificar ahora
+        product = next_position.id_producto
+        ctx["product"] = product
+
+        # Revisar las palabras para calificar
+        try:
+            rating = Calificacion.objects.get(
+                num_repeticion=technique.repeticion,
+                id_producto=product,
+                id_tecnica=technique,
+                id_catador=self.tester
+            )
+            there_rating = True
+        except Calificacion.DoesNotExist:
+            there_rating = False
+
+        # Si no hay calificaciones previas, usar todas las palabras
+        if not there_rating:
+            ctx["words"] = words
+        else:
+            ratings_product = rating.dato_calificacion.all()
+            # Filtrar palabras que faltan
+            words_to_use = PalabrasController.getWordsWithoutData(
+                recoreded_data=ratings_product,
+                words=words
+            )
+            ctx["words"] = words_to_use
+
+        # Escala y etiquetas relacionadas
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        ctx["scale"] = scale
+        ctx["type_scale"] = scale.id_tipo_escala.nombre_escala
+        ctx["tags"] = EscalaController.getRelatedTagsInScale(scale=scale)
+
+        return render(request, self.current_directory, ctx)
+
+    def controllGetRATA(self, request: HttpRequest):
+        technique = self.session.tecnica
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        self.context["session"] = self.session
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        use_product: Producto = None
+        use_words: list[Palabra] = None
+
+        # Revisamos el producto que le falten calificaciones
+        for current_product in products_in_technique:
+            try:
+                rating = Calificacion.objects.get(
+                    num_repeticion=technique.repeticion,
+                    id_producto=current_product,
+                    id_tecnica=technique,
+                    id_catador=self.tester
+                )
+                there_rating = True
+            except Calificacion.DoesNotExist:
+                there_rating = False
+
+            # Si no hay calificacion mandamos el producto actual y todas la palabras
+            if not there_rating:
+                use_product = current_product
+                use_words = words
+                break
+
+            # Obtener los datos asociados para la calificacion para ver que palabras quedan por calificar
+            recoreded_data = rating.dato_calificacion.all()
+
+            if not recoreded_data:
+                # Si no hay datos entonces devolver el producto con todas las palabras
+                use_product = current_product
+                use_words = words
+                break
+            else:
+                words_to_use = PalabrasController.getWordsWithoutData(
+                    recoreded_data=recoreded_data, words=words)
+
+                # Si quedan palabras por calificar mandar las palabras con el producto
+                if not isinstance(words_to_use, dict) and words_to_use:
+                    use_product = current_product
+                    use_words = words_to_use
+                    break
+
+        # Si no hay producto que falta por calificar finalizar sesion para el Catador
+        if not use_product:
+            updated_participation = ParticipacionController.finishSession(
+                self.participation)
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["product"] = use_product
+        self.context["words"] = use_words
+
+        # Agregar informacion de la escala
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        self.context["scale"] = scale
+        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        self.context["tags"] = use_tags
+
+        return render(request, self.current_directory, self.context)

tecnicas/controllers/views_controller/sessions_tester/init_session_tester_controller.py

@@ -2,7 +2,7 @@ from django.db import transaction
 from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
-from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
+from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario, Dato
 from tecnicas.controllers import ParticipacionController
 from tecnicas.utils import controller_error, shuffleArray
 
@@ -37,6 +37,9 @@ class InitSessionTesterController():
         if is_end:
             context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
 
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
         return render(request, self.current_direction, context)
 
     def controllPostEscalas(self, request: HttpRequest):
@@ -54,7 +57,7 @@ class InitSessionTesterController():
             if is_end:
                 context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
                 return render(request, self.current_direction, context)
-            
+
             update_participation = ParticipacionController.enterSession(
                 tester=request.user.user_catador, session=self.session)
             if isinstance(update_participation, dict):
@@ -122,8 +125,8 @@ class InitSessionTesterController():
 
             # ////////////////////////////////////////////////////////////// #
             #
-            # numero_calificaciones_esperadas = num_productos * num_palabras
-            # Si numero_calificaciones_esperadas ss igual a numero_calificaciones_actuales en la repetcion R
+            # numero_datos_esperadas = num_productos * num_palabras
+            # Si numero_datos_esperadas es igual a numero_datos_actuales en la repetcion R
             # Ha terminado la repeticion
             #
             # ////////////////////////////////////////////////////////////// #
@@ -137,17 +140,20 @@ class InitSessionTesterController():
 
                 num_words: int
 
-                if style_words.nombre_estilo == "atributos":
+                if style_words == "atributos":
                     num_words = EsAtributo.objects.get(
                         id_tecnica=self.session.tecnica).palabras.count()
-                elif style_words.nombre_estilo == "vocabulario":
+                elif style_words == "vocabulario":
                     num_words = EsVocabulario.objects.get(
                         id_tecnica=self.session.tecnica).id_vocabulario.palabras.count()
 
                 expected_ratings_repetition = num_products * num_words
 
-                num_ratings_now = Calificacion.objects.filter(
-                    id_tecnica=technique, id_catador=self.tester, num_repeticion=technique.repeticion).count()
+                num_ratings_now = Dato.objects.filter(
+                    id_calificacion__id_catador=self.tester,
+                    id_calificacion__id_tecnica=technique,
+                    id_calificacion__num_repeticion=technique.repeticion
+                ).count()
 
                 is_end = num_ratings_now >= expected_ratings_repetition
 

tecnicas/controllers/views_controller/sessions_tester/login_session_tester_controller.py

@@ -33,38 +33,38 @@ class LoginSessionTesterController():
             context["error"] = "La sesión no está activa actualmente"
             return render(request, self.current_direcction, context)
 
-        if self.session.tecnica.repeticion > 1:
+        if self.session.tecnica.repeticion == 1:
             try:
                 self.taster_participation = Participacion.objects.get(
                     tecnica=self.session.tecnica, catador=self.tester)
                 context["error"] = "Usted ya esta dentro de la sesión"
                 return render(request, self.current_direcction, context)
             except Participacion.DoesNotExist:
-                context["error"] = "No tienes permitido entrar a esta sesión"
-                return render(request, self.current_direcction, context)
-        else:
-            with transaction.atomic():
-                code_session = self.session.codigo_sesion
-                self.session = SesionSensorial.objects.select_for_update().get(
-                    codigo_sesion=code_session)
+                with transaction.atomic():
+                    code_session = self.session.codigo_sesion
+                    self.session = SesionSensorial.objects.select_for_update().get(
+                        codigo_sesion=code_session)
 
-                max_testers = self.session.tecnica.limite_catadores
-                current_num_testers = Participacion.objects.filter(
-                    tecnica=self.session.tecnica).count()
+                    max_testers = self.session.tecnica.limite_catadores
+                    current_num_testers = Participacion.objects.filter(
+                        tecnica=self.session.tecnica).count()
 
-                if current_num_testers >= max_testers:
-                    context["error"] = "La sesión ha alcanzado el número máximo de catadores"
-                    return render(request, self.current_direcction, context)
+                    if current_num_testers >= max_testers:
+                        context["error"] = "La sesión ha alcanzado el número máximo de catadores"
+                        return render(request, self.current_direcction, context)
 
-                self.taster_participation = Participacion.objects.create(
-                    tecnica=self.session.tecnica,
-                    catador=self.tester,
-                    finalizado=False
-                )
-            params = {
-                "code_sesion": self.session.codigo_sesion
-            }
-            return redirect(reverse(self.destinity_direcction, kwargs=params))
+                    self.taster_participation = Participacion.objects.create(
+                        tecnica=self.session.tecnica,
+                        catador=self.tester,
+                        finalizado=False
+                    )
+                params = {
+                    "code_sesion": self.session.codigo_sesion
+                }
+                return redirect(reverse(self.destinity_direcction, kwargs=params))
+        else:
+            context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, context)
 
     def validateEntryRATA(self, request: HttpRequest):
         context = {}

tecnicas/models/calificacion.py

@@ -8,4 +8,7 @@ class Calificacion(models.Model):
     num_repeticion = models.IntegerField()
     id_producto = models.ForeignKey(Producto, on_delete=models.CASCADE, related_name="calificacion_producto")
     id_tecnica = models.ForeignKey(Tecnica, on_delete=models.CASCADE, related_name="calificacion_tecnica")
-    id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="calificacion_catador")
+    id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="calificacion_catador")
+
+    def __str__(self):
+        return f"{self.id} - {self.id_tecnica.sesion_tecnica} - {self.num_repeticion} - {self.id_catador.user.username}"

tecnicas/models/dato.py

@@ -11,4 +11,4 @@ class Dato(models.Model):
         Calificacion, on_delete=models.CASCADE, related_name="dato_calificacion")
 
     def __str__(self):
-        return f"{self.id_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.usuarioCatador}"
+        return f"{self.id_calificacion.id_tecnica.sesion_tecnica}- {self.id_calificacion.num_repeticion} - {self.id_palabra.nombre_palabra} - {self.id_calificacion.id_producto.codigoProducto} - {self.id_calificacion.id_catador.user.username}"

tecnicas/models/dato_valor.py

@@ -9,7 +9,7 @@ class ValorDecimal(models.Model):
     valor = models.FloatField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.user.username}"
 
 
 class ValorBooleano(models.Model):
@@ -18,4 +18,4 @@ class ValorBooleano(models.Model):
     valor = models.BooleanField()
 
     def __str__(self):
-        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.usuarioCatador}"
+        return f"{self.id} - {self.id_dato.id_palabra}: {self.valor} - {self.id_dato.id_calificacion.id_catador.user.username}"

tecnicas/static/js/created-scale.js

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

tecnicas/templates/tecnicas/components/form-scale-continue.html

@@ -0,0 +1,62 @@
+<form action="" method="post" class="form-rating-{{word}} w-full">
+    {% csrf_token %}
+    <article class="overflow-x-scroll w-full">
+        <article class="bg-surface-card p-6 rounded-lg mb-3 w-fit">
+            <label for="id-range-word-{{word}}"
+                class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
+
+            <span class="hidden id-word">{{ word.id }}</span>
+
+            <section class="block">
+                <div class="relative mx-6">
+                    <input type="range" type="range" min="0" max="1000" value="500" name="rating-word"
+                        class="range range-md text-blue-400 [--range-bg:orange] [--range-thumb:blue] [--range-fill:0]"
+                        style="width: {{scale.longitud}}cm;">
+
+                    <div class="absolute top-0 left-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
+                    </div>
+
+                    <div class="absolute top-1/5 left-1/2 w-0.5 transform -translate-x-1/2 h-4/5 bg-red-500 z-10">
+                    </div>
+
+                    <div class="absolute top-0 right-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
+                    </div>
+                </div>
+
+                <div class="flex justify-between mt-4">
+                    <div class="flex flex-col items-start text-left w-[100px]">
+                        <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                            {{ tags.0.id_etiqueta }}
+                        </span>
+                    </div>
+                    <div class="flex flex-col items-start text-center w-[100px]">
+                        <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                            {{ tags.1.id_etiqueta }}
+                        </span>
+                    </div>
+                    <div class="flex flex-col items-start text-right w-[100px]">
+                        <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                            {{ tags.2.id_etiqueta }}
+                        </span>
+                    </div>
+                </div>
+            </section>
+        </article>
+    </article>
+    <article class="flex flex-col justify-center gap-2 items-end actions-{{word}}">
+        <section class="flex justify-end items-center gap-2 btns-container">
+            <button type="button" onclick="checkSendRating('{{word}}')"
+                class="ct-btn-check-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-secondary btn-push">
+                ¿Guardar calificación?
+            </button>
+            <button type="button" onclick="sendRating('{{word}}')"
+                class="ct-btn-submit-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-primary btn-push hidden">
+                Estoy seguro
+            </button>
+            <button type="button" onclick="cancelSendRating('{{word}}')"
+                class="ct-btn-cancel-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-error btn-push hidden">
+                Cancelar
+            </button>
+        </section>
+    </article>
+</form>

tecnicas/templates/tecnicas/components/form-scale-structure.html

@@ -0,0 +1,52 @@
+<form action="" method="post" class="form-rating-{{ word }} w-full">
+    {% csrf_token %}
+    <article class="overflow-x-scroll w-full">
+        <article class="bg-surface-card p-6 rounded-lg mb-3 w-fit">
+            <label for="id-scale-word-{{ word }}"
+                class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
+            <span class="hidden id-word">{{ word.id }}</span>
+
+            <section>
+                <div class="w-full min-w-xs">
+                    <div class="relative mx-6">
+                        <input type="range" min="1" max="{{ scale.longitud }}" step="1" name="rating-word"
+                            class="w-full range range-md text-blue-400 [--range-bg:orange] [--range-thumb:blue] [--range-fill:0] z-5">
+                        <div class="absolute top-0 left-0 w-full h-full z-10 flex justify-between pointer-events-none">
+                            {% for tag in tags %}
+                            <div class="w-0.5 transform -translate-x-1/2 h-full bg-red-500">
+                            </div>
+                            {% endfor %}
+                        </div>
+                    </div>
+
+                    <div class="flex justify-between mt-4 text-xs gap-1">
+                        {% for tag in tags %}
+                        <div class="flex items-center justify-center text-center w-[70px]">
+                            <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                                {{ tag.id_etiqueta }}
+                            </span>
+                        </div>
+                        {% endfor %}
+                    </div>
+                </div>
+            </section>
+        </article>
+    </article>
+
+    <article class="flex flex-col justify-center gap-2 items-end actions-{{ word }}">
+        <section class="flex justify-end items-center gap-2 btns-container">
+            <button type="button" onclick="checkSendRating('{{ word }}')"
+                class="ct-btn-check-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-secondary btn-push">
+                ¿Guardar calificación?
+            </button>
+            <button type="button" onclick="sendRating('{{ word }}')"
+                class="ct-btn-submit-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-primary btn-push hidden">
+                Estoy seguro
+            </button>
+            <button type="button" onclick="cancelSendRating('{{ word }}')"
+                class="ct-btn-cancel-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-error btn-push hidden">
+                Cancelar
+            </button>
+        </section>
+    </article>
+</form>

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -37,7 +37,8 @@
     <article class="cts-wrap-content text-black">
         <header class="text-center flex-row w-full items-stretch flex justify-around flex-wrap gap-2">
             <h1 class="rounded font-bold text-2xl bg-surface-ligt p-4 flex-1">
-                Sesión usando <br>técnica Convencional
+                Sesión usando <br>técnica
+                <span class="uppercase">{{ session.tecnica.tipo_tecnica }}</span>
             </h1>
             <button class="cts-btn-general cts-btn-error btn-push" onclick="exit_sesion('form-actions')">
                 Salir de la sesión
@@ -45,12 +46,17 @@
         </header>
 
         <article class="hidden">
-            <form action="{% url 'cata_system:catador_init_session' code_sesion=session.codigo_sesion %}" method="post" class="form-actions">
+            <form action="{% url 'cata_system:catador_init_session' code_sesion=session.codigo_sesion %}" method="post"
+                class="form-actions">
                 {% csrf_token %}
                 <input type="hidden" name="action" class="action-input">
             </form>
         </article>
 
+        <section class="hidden">
+            <input type="hidden" value="{{ session.tecnica.id }}" name="id-tecnica" class="ct-input-id-tech">
+        </section>
+
         {% if error %}
         <hr>
         <article class="bg-red-600 p-4 text-white rounded-xl ct-notification-error">
@@ -95,132 +101,17 @@
 
         <article
             class="scales-container [&>*:not(:last-child)]:mb-5 min-lg:grid min-lg:items-start grid-cols-2 gap-3 justify-center items-center">
-            {% if type_scale == "continua" %}
-            {% for word in words %}
-            <form action="" method="post" class="form-rating-{{word}} w-full">
-                {% csrf_token %}
-                <article class="overflow-x-scroll w-full">
-                    <article class="bg-surface-card p-6 rounded-lg mb-3 w-fit">
-                        <label for="id-range-word-{{word}}"
-                            class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
-
-                        <span class="hidden id-word">{{ word.id }}</span>
-
-                        <section class="block">
-                            <div class="relative mx-6">
-                                <input type="range" type="range" min="0" max="1000" value="500" name="rating-word"
-                                    class="range range-md text-blue-400 [--range-bg:orange] [--range-thumb:blue] [--range-fill:0]"
-                                    style="width: {{scale.longitud}}cm;">
-
-                                <div
-                                    class="absolute top-0 left-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
-                                </div>
-
-                                <div
-                                    class="absolute top-1/5 left-1/2 w-0.5 transform -translate-x-1/2 h-4/5 bg-red-500 z-10">
-                                </div>
-
-                                <div
-                                    class="absolute top-0 right-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
-                                </div>
-                            </div>
-
-                            <div class="flex justify-between mt-4">
-                                <div class="flex flex-col items-start text-left w-[100px]">
-                                    <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
-                                        {{ tags.0.id_etiqueta }}
-                                    </span>
-                                </div>
-                                <div class="flex flex-col items-start text-center w-[100px]">
-                                    <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
-                                        {{ tags.1.id_etiqueta }}
-                                    </span>
-                                </div>
-                                <div class="flex flex-col items-start text-right w-[100px]">
-                                    <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
-                                        {{ tags.2.id_etiqueta }}
-                                    </span>
-                                </div>
-                            </div>
-                        </section>
-                    </article>
-                </article>
-                <article class="flex flex-col justify-center gap-2 items-end actions-{{word}}">
-                    <section class="flex justify-end items-center gap-2 btns-container">
-                        <button type="button" onclick="checkSendRating('{{word}}')"
-                            class="ct-btn-check-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-secondary btn-push">
-                            ¿Guardar calificación?
-                        </button>
-                        <button type="button" onclick="sendRating('{{word}}')"
-                            class="ct-btn-submit-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-primary btn-push hidden">
-                            Estoy seguro
-                        </button>
-                        <button type="button" onclick="cancelSendRating('{{word}}')"
-                            class="ct-btn-cancel-{{word}} cts-btn-general-compress py-2 px-4 cts-btn-error btn-push hidden">
-                            Cancelar
-                        </button>
-                    </section>
-                </article>
-            </form>
-            {% endfor %}
-            {% elif type_scale == "estructurada" %}
-            {% for word in words %}
-            <form action="" method="post" class="form-rating-{{ word }} w-full">
-                {% csrf_token %}
-                <article class="overflow-x-scroll w-full">
-                    <article class="bg-surface-card p-6 rounded-lg mb-3 w-fit">
-                        <label for="id-scale-word-{{ word }}"
-                            class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
-                        <span class="hidden id-word">{{ word.id }}</span>
-
-                        <section>
-                            <div class="w-full min-w-xs">
-                                <div class="relative mx-6">
-                                    <input type="range" min="1" max="{{scale.longitud}}" step="1" name="rating-word"
-                                        class="w-full range range-md text-blue-400 [--range-bg:orange] [--range-thumb:blue] [--range-fill:0] z-5">
-                                    <div
-                                        class="absolute top-0 left-0 w-full h-full z-10 flex justify-between pointer-events-none">
-                                        {% for tag in tags %}
-                                        <div class="w-0.5 transform -translate-x-1/2 h-full bg-red-500">
-                                        </div>
-                                        {% endfor %}
-                                    </div>
-                                </div>
-
-                                <div class="flex justify-between mt-4 text-xs gap-1">
-                                    {% for tag in tags %}
-                                    <div class="flex items-center justify-center text-center w-[70px]">
-                                        <span
-                                            class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
-                                            {{ tag.id_etiqueta }}
-                                        </span>
-                                    </div>
-                                    {% endfor %}
-                                </div>
-                            </div>
-                        </section>
-                    </article>
-                </article>
-
-                <article class="flex flex-col justify-center gap-2 items-end actions-{{ word }}">
-                    <section class="flex justify-end items-center gap-2 btns-container">
-                        <button type="button" onclick="checkSendRating('{{ word }}')"
-                            class="ct-btn-check-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-secondary btn-push">
-                            ¿Guardar calificación?
-                        </button>
-                        <button type="button" onclick="sendRating('{{ word }}')"
-                            class="ct-btn-submit-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-primary btn-push hidden">
-                            Estoy seguro
-                        </button>
-                        <button type="button" onclick="cancelSendRating('{{ word }}')"
-                            class="ct-btn-cancel-{{ word }} cts-btn-general-compress py-2 px-4 cts-btn-error btn-push hidden">
-                            Cancelar
-                        </button>
-                    </section>
-                </article>
-            </form>
-            {% endfor %}
-            {% endif %}
+            {% with path_con="../components/form-scale-continue.html" path_str="../components/form-scale-structure.html" %}
+                {% if type_scale == "continua" %}
+                    {% for word in words %}
+                        {% include path_con with word=word tags=tags scale=scale id_tecnica=session.tecnica.id %}
+                    {% endfor %}
+                {% elif type_scale == "estructurada" %}
+                    {% for word in words %}
+                        {% include path_str with word=word tags=tags scale=scale %}
+                    {% endfor %}
+                {% endif %}
+            {% endwith %}
         </article>
     </article>
 </article>

tecnicas/templates/tecnicas/forms_tester/init_session.html

@@ -5,7 +5,7 @@
 
 {% block content %}
 <article class="cts-container-main">
-    <article class="cts-wrap-content text-black">
+    <article class="cts-wrap-content text-black max-w-4xl">
         <header class="text-center flex-row w-full flex justify-around items-center flex-wrap gap-10">
             <h1 class="rounded-xl font-bold text-2xl bg-surface-ligt p-4 flex-1">
                 Panel principal de Catadores

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

@@ -181,6 +181,14 @@
         </p>
         <article class="flex flex-wrap gap-10 max-sm:gap-2">
             {% if not sesion.activo %}
+            {% if fin_repeticiones %}
+            <div
+                class="text-2xl font-semibold flex-1 cts-btn-secondary p-4 flex justify-center items-center rounded-lg select-none text-center">
+                <p class=" text-black">
+                    Máximo número de repeticiones alcanzado
+                </p>
+            </div>
+            {% else %}
             <button
                 class="ct-btn-start-repition flex-1 uppercase text-lg max-sm:text-base tracking-wider p-4 border-b-2 active:border-b-0 active:border-t-2 active:border-green-500 border-green-800  transition-all rounded-xl bg-green-600 text-white font-bold disabled:bg-amber-600 flex flex-col justify-center items-center gap-2"
                 onclick="startRepetition()">
@@ -189,6 +197,7 @@
                     <img src="{% static 'img/giro.svg' %}" alt="flechas girando" class="invert">
                 </figure>
             </button>
+            {% endif %}
             {% else %}
             <a href="{% url 'cata_system:monitor_sesion' session_code=sesion.codigo_sesion %}" class="flex-1 w-fit">
                 <button
@@ -243,9 +252,11 @@
 
         {% if existen_calificaciones %}
         <article class="bg-surface-card p-4 max-sm:px-2 text-black rounded">
+            {% with url_component="../components/table-convencional.html" %}
             {% for repeticion, catadores in calificaciones.items %}
-            {% include "../components/table-convencional.html" with repeticion=repeticion catadores=catadores palabras=palabras %}
+            {% include url_component with repeticion=repeticion catadores=catadores palabras=palabras %}
             {% endfor %}
+            {% endwith %}
         </article>
         {% else %}
         {% include "../components/error-message.html" with message='Sin calificaciones que mostrar aún' %}

tecnicas/utils/general_controllers.py

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

tecnicas/views/apis/rating_word.py

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

tecnicas/views/sessions_management/session_details.py

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

tecnicas/views/tester_forms/convencional_scales.py

@@ -55,78 +55,26 @@
             - Cata segmento en el que se divide debe tener la etiqueda correspondiente por debajo
 '''
 from django.http import HttpRequest
-from django.shortcuts import redirect, render
-from django.urls import reverse
-from ...controllers import SesionController, PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+from tecnicas.controllers import SesionController, ConvencionalScalesController
+from tecnicas.utils import noValidTechnique
 
 
 def convencionalScales(req: HttpRequest, code_sesion: str):
-    if not "id_order" in req.session:
-        return redirect(reverse("cata_system:catador_main"))
-
     session = SesionController.getSessionByCode(code_sesion)
-    technique = session.tecnica
-
-    context = {
-        "session": session
-    }
-
-    req.session["id_technique"] = session.tecnica.id
+    type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
 
     if req.method == "GET":
-        positions = PosicionController.getPostionsInOrder(
-            id_order=req.session["id_order"])
-
-        sorted_positions = sorted(positions, key=lambda posi: posi.posicion)
-
-        words = PalabrasController.getWordsInTechnique(technique=technique)
-
-        next_position = CalificacionController.checkProducsWithoutRating(
-            positions=sorted_positions,
-            user_cata=req.user.username,
-            id_technique=session.tecnica.id,
-            repetition=session.tecnica.repeticion,
-            technique=technique,
-            num_words=len(words)
-        )
-
-        if isinstance(next_position, dict):
-            updated_participation = ParticipacionController.finishSession(
-                req.session["id_participation"])
-            return redirect(reverse("cata_system:catador_main"))
-
-        if isinstance(next_position, list):
-            next_position = next_position[0]
-
-        context["product"] = next_position.id_producto
-
-        ratings_product = CalificacionController.getRatings(
-            technique=technique,
-            product=next_position.id_producto,
-            repetition=technique.repeticion,
-            user_tester=req.user.username
-        )
-
-        if isinstance(ratings_product, dict):
-            context["error"] = ratings_product["error"]
-            return render(req, "tecnicas/forms_tester/convencional.html", context)
-        elif not ratings_product:
-            context["words"] = words
+        view_controller = ConvencionalScalesController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        if type_technique == "escalas":
+            respose = view_controller.controllGetEscalas(request=req)
+        elif type_technique == "rata":
+            respose = view_controller.controllGetRATA(request=req)
         else:
-            recoreded_data = DatoController.getRerecordedData(
-                ratings=ratings_product)
-            if not recoreded_data:
-                context["words"] = words
-            else:
-                words_to_use = PalabrasController.getWordsWithoutData(
-                    recoreded_data=recoreded_data, words=words)
-                context["words"] = words_to_use
-
-        scale = EscalaController.getScaleByTechnique(technique=technique)
-        context["scale"] = scale
-        context["type_scale"] = scale.id_tipo_escala.nombre_escala
-
-        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
-        context["tags"] = use_tags
+            respose = noValidTechnique(
+                name_view='cata_system:catador_init_session',
+                params={"code_sesion": session.codigo_sesion},
+                query_params={"error": "No es posible poder usar esta técnica"}
+            )
 
-        return render(req, "tecnicas/forms_tester/convencional.html", context)
+        return respose

tecnicas/views/tester_forms/init_tester_form.py

@@ -7,11 +7,6 @@ from tecnicas.models import SesionSensorial
 
 def initTesterForm(req: HttpRequest, code_sesion: str):
     session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
-
-    context = {
-        "session": session
-    }
-
     type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
     template_url = "tecnicas/forms_tester/init_session.html"
 
@@ -25,6 +20,7 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
             response = view_controller.controllGetRATA(request=req)
         else:
             context = {
+                "session": session,
                 "error": "La técnica usada en esta sesión o ha sido implementada para ingresar a ella"
             }
             response = render(
@@ -36,6 +32,7 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
             response = view_controller.controllPostEscalas(request=req)
         else:
             context = {
+                "session": session,
                 "error": "Esta opción aun no esta disponible para la técnica usada por la sesión"
             }
             response = render(