Merge pull request #39 from CascoArcilla/HU7

tecnicas/admin.py

@@ -1,20 +1,6 @@
 from django.contrib import admin
 
-from .models import CategoriaTecnica, TipoTecnica, TipoEscala, EstiloPalabra
-
-from .models import Catador, Presentador
-
-from .models import Tecnica, SesionSensorial
-
-from .models import EsAtributo, Palabra, Vocabulario
-
-from .models import Etiqueta, Escala, EtiquetasEscala
-
-from .models import Producto, Participacion
-
-from .models import Orden, Posicion
-
-from .models import Dato, ValorDecimal, ValorBooleano, Calificacion, ListaPalabras, GrupoProducto
+from .models import CategoriaTecnica, TipoTecnica, TipoEscala, EstiloPalabra, Catador, Presentador, Tecnica, SesionSensorial, EsAtributo, Palabra, Vocabulario, Etiqueta, Escala, EtiquetasEscala, Producto, Participacion, Orden, Posicion, Dato, ValorDecimal, ValorBooleano, Calificacion, ListaPalabras, GrupoProducto, Modalidad, TecnicaModalidad, DatoPunto
 
 # Register your models here.
 admin.site.register(CategoriaTecnica)
@@ -46,5 +32,11 @@ admin.site.register(Dato)
 admin.site.register(ValorDecimal)
 admin.site.register(ValorBooleano)
 admin.site.register(Calificacion)
+
 admin.site.register(ListaPalabras)
 admin.site.register(GrupoProducto)
+
+admin.site.register(Modalidad)
+admin.site.register(TecnicaModalidad)
+
+admin.site.register(DatoPunto)

tecnicas/controllers/__init__.py

@@ -31,11 +31,13 @@ from .views_controller.session_management.details.details_rata_controller import
 from .views_controller.session_management.details.details_cata_controller import DetallesCATAController
 from .views_controller.session_management.details.details_pf_controller import DetallesPFController
 from .views_controller.session_management.details.details_sort_controller import DetallesSortController
+from .views_controller.session_management.details.details_napping_controller import DetallesNappingController
 
 from .views_controller.session_management.monitor.monitor_escalas_controller import MonitorEscalasController
 from .views_controller.session_management.monitor.monitor_rata_controller import MonitorRATAController
 from .views_controller.session_management.monitor.monitor_pf_controller import MonitorPFController
 from .views_controller.session_management.monitor.monitor_sort_controller import MonitorSortController
+from .views_controller.session_management.monitor.monitor_napping_controller import MonitorNappingController
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
@@ -45,11 +47,13 @@ from .views_controller.sessions_tester.tests_forms.test_rata_controller import T
 from .views_controller.sessions_tester.tests_forms.test_cata_controller import TestCataController
 from .views_controller.sessions_tester.tests_forms.test_pf_controller import TestPFController
 from .views_controller.sessions_tester.tests_forms.test_sort_controller import TestSortController
+from .views_controller.sessions_tester.tests_forms.test_napping_controller import TestNappingController
 
 from .views_controller.sessions_tester.init_session.init_session_escalas_controller import InitSessionEscalasController
 from .views_controller.sessions_tester.init_session.init_session_rata_controller import InitSessionRATAController
 from .views_controller.sessions_tester.init_session.init_session_pf_controller import InitSessionPFController
 from .views_controller.sessions_tester.init_session.init_session_sort_controller import InitSessionSortController
+from .views_controller.sessions_tester.init_session.init_session_napping_controller import InitSessionNappingController
 
 from .views_controller.vocabulary_manage.create_vocabulary_controller import CreateVocabularyController
 from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController
@@ -59,3 +63,5 @@ from .api_controller.rating_cata_controller import RatingCataController
 from .api_controller.rating_pf_list_controller import RatingPFListController
 from .views_controller.tester_list_controller import TesterListController
 from .api_controller.rating_sort_controller import RatingSortController
+from .api_controller.rating_napping_controller import RatingNappingController
+

tecnicas/controllers/api_controller/rating_napping_controller.py

@@ -0,0 +1,96 @@
+from django.http import JsonResponse
+from django.http import HttpRequest
+from django.db import transaction
+from tecnicas.models import Calificacion, DatoPunto, Producto, Participacion
+
+
+class RatingNappingController:
+    @staticmethod
+    def saveRatingCoordinates(request: HttpRequest, data: list):
+        participation = Participacion.objects.get(
+            id=request.session["id_participation"]
+        )
+
+        try:
+            with transaction.atomic():
+                products_map = RatingNappingController.getProductsMap(
+                    participation.tecnica)
+
+                existing_ratings_map = RatingNappingController.getExistingRatingsMap(
+                    participation.tecnica, participation.catador
+                )
+
+                new_ratings = []
+                ids_products = products_map.keys()
+                for item in data:
+                    product_id = int(item["idProduct"])
+                    if product_id not in existing_ratings_map and product_id in ids_products:
+                        new_ratings.append(
+                            Calificacion(
+                                num_repeticion=0,
+                                id_producto=products_map[product_id],
+                                id_tecnica=participation.tecnica,
+                                id_catador=participation.catador,
+                            )
+                        )
+
+                if new_ratings:
+                    Calificacion.objects.bulk_create(new_ratings)
+                    existing_ratings_map = RatingNappingController.getExistingRatingsMap(
+                        participation.tecnica, participation.catador
+                    )
+
+                existing_points_map = RatingNappingController.getExistingPointsMap(
+                    existing_ratings_map.values())
+
+                points_to_create = []
+                points_to_update = []
+
+                for item in data:
+                    product_id = int(item["idProduct"])
+                    rating = existing_ratings_map.get(product_id)
+
+                    if rating:
+                        if rating.id in existing_points_map:
+                            point = existing_points_map[rating.id]
+                            point.x = item["x"]
+                            point.y = item["y"]
+                            points_to_update.append(point)
+                        else:
+                            points_to_create.append(
+                                DatoPunto(
+                                    x=item["x"],
+                                    y=item["y"],
+                                    calificacion=rating,
+                                )
+                            )
+
+                if points_to_create:
+                    DatoPunto.objects.bulk_create(points_to_create)
+
+                if points_to_update:
+                    DatoPunto.objects.bulk_update(points_to_update, ['x', 'y'])
+
+            return JsonResponse({"message": "Datos guardados exitosamente"})
+
+        except Exception as e:
+            print("ERROR:", e)
+            return JsonResponse({"error": "Error al procesar datos"})
+
+    @staticmethod
+    def getProductsMap(id_tecnica):
+        products_qs = Producto.objects.filter(id_tecnica=id_tecnica)
+        return {p.id: p for p in products_qs}
+
+    @staticmethod
+    def getExistingRatingsMap(id_tecnica, id_catador):
+        ratings = Calificacion.objects.filter(
+            id_tecnica=id_tecnica,
+            id_catador=id_catador,
+        )
+        return {r.id_producto.id: r for r in ratings}
+
+    @staticmethod
+    def getExistingPointsMap(ratings):
+        points = DatoPunto.objects.filter(calificacion__in=ratings)
+        return {p.calificacion.id: p for p in points}

tecnicas/controllers/views_controller/session_management/details/details_napping_controller.py

@@ -0,0 +1,126 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect
+from django.urls import reverse
+from django.db.models import F
+from .details_controller import DetallesController
+from tecnicas.models import SesionSensorial, Presentador, Modalidad, TecnicaModalidad, Catador, Participacion, DatoPunto, Calificacion
+from tecnicas.utils import defaultdict_to_dict
+from collections import defaultdict
+
+
+class DetallesNappingController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_template = "tecnicas/manage_sesions/details-session-napping.html"
+        self.url_next = "cata_system:monitor_sesion"
+
+    def getContext(self):
+        self.context = {
+            "session": self.session,
+        }
+
+        self.defineStatus()
+        self.setOptionesMode()
+        self.setDataTableNoMode()
+
+        return self.context
+
+    def defineStatus(self):
+        repetition = self.session.tecnica.repeticion
+
+        if not repetition and not self.session.activo:
+            self.context["status"] = "Listo para iniciar la sesión con Napping"
+        elif not repetition and self.session.activo:
+            self.context["status"] = "Sesión con Napping en curso"
+        elif repetition == 1 and not self.session.activo:
+            self.context["status"] = "En espera de la siguiente acción"
+        else:
+            self.context["status"] = "En espera de la siguiente acción"
+
+    def controllPostResponse(self, request: HttpRequest, action: str):
+        if action == "start_sin_modalidad":
+            name_mode = action.replace("start_", "").replace("_", " ")
+            response = self.startNapping(request=request, name_mode=name_mode)
+
+        if action == "start_perfil_ultra_flash":
+            name_mode = action.replace("start_", "").replace("_", " ")
+            return self.controllGetResponse(error="Trabajando en la modalidad", request=request)
+
+        elif action == "delete_session":
+            self.deleteSesorialSession()
+            response = redirect(
+                reverse("cata_system:panel_sesiones", kwargs={"page": 1}))
+
+        else:
+            response = self.controllGetResponse(
+                error="Modalidad sin implantar", request=request)
+
+        return response
+
+    def startNapping(self, request: HttpRequest, name_mode: str):
+        if request.user.user_presentador.user.username != self.session.creadoPor.user.username:
+            return self.controllGetResponse(error="Solo el presentador que crea la sesión puede iniciar la repetición", request=request)
+        elif self.session.activo:
+            return self.controllGetResponse(error="La sesión ya está activada", request=request)
+
+        tecnique_mode = TecnicaModalidad.objects.get_or_create(
+            tecnica=self.session.tecnica, modalidad=Modalidad.objects.get(nombre=name_mode), usando=True)
+
+        if not tecnique_mode:
+            return self.controllGetResponse(error="Modalidad no encontrada", request=request)
+
+        self.session.activo = True
+        self.session.save()
+
+        parameters = {
+            "session_code": self.session.codigo_sesion
+        }
+        return redirect(
+            reverse(self.url_next, kwargs=parameters))
+
+    def setDataTableNoMode(self):
+        participations = Participacion.objects.filter(
+            tecnica=self.session.tecnica).select_related("catador")
+        testers = [participation.catador for participation in participations]
+        self.context["testers"] = testers
+
+        ratings = Calificacion.objects.filter(id_tecnica=self.session.tecnica)
+
+        coordinates = (
+            DatoPunto.objects.filter(calificacion__in=ratings)
+            .values(
+                producto=F("calificacion__id_producto__codigoProducto"),
+                catador=F("calificacion__id_catador__user__username"),
+                px=F("x"),
+                py=F("y"),
+            ))
+
+        if not coordinates.exists():
+            self.context["there_data"] = False
+            return []
+
+        coordinates_by_product = defaultdict(dict)
+
+        for coordinate in coordinates:
+            coordinates_by_product[coordinate["producto"]][coordinate["catador"]] = {
+                "px": coordinate["px"],
+                "py": coordinate["py"],
+            }
+
+        self.context["coordinates_no_mode"] = defaultdict_to_dict(
+            coordinates_by_product)
+
+        self.context["there_data"] = True
+
+    def setOptionesMode(self):
+        modes = Modalidad.objects.all()
+        technique_modes = TecnicaModalidad.objects.filter(
+            tecnica=self.session.tecnica)
+
+        if not technique_modes.exists():
+            self.context["modes"] = modes
+        else:
+            use_modes = technique_modes.values_list("modalidad", flat=True)
+
+            self.context["modes"] = modes.exclude(
+                id__in=use_modes)

tecnicas/controllers/views_controller/session_management/monitor/monitor_napping_controller.py

@@ -0,0 +1,37 @@
+from tecnicas.models import SesionSensorial
+from tecnicas.models import Participacion, TecnicaModalidad
+from .monitor_controller import MonitorController
+
+
+class MonitorNappingController(MonitorController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-session-sort.html"
+        self.previus_view = "cata_system:detalles_sesion"
+
+    def checkAllFinish(self) -> (bool, str):
+        technique = self.sensorial_session.tecnica
+
+        num_participations = Participacion.objects.filter(
+            tecnica=technique).count()
+
+        if num_participations < technique.limite_catadores:
+            return (False, "No se ha alcanzado el número máximo de catadores")
+
+        unfinished_participations = Participacion.objects.filter(
+            tecnica=technique, finalizado=False).count()
+
+        if unfinished_participations > 0:
+            return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")
+
+    def finishSession(self):
+        mode_technique = TecnicaModalidad.objects.get(
+            tecnica=self.sensorial_session.tecnica, usando=True)
+        mode_technique.usando = False
+        mode_technique.save()
+
+        self.sensorial_session.activo = False
+        self.sensorial_session.save()
+        return self.sensorial_session

tecnicas/controllers/views_controller/sessions_tester/init_session/init_session_napping_controller.py

@@ -0,0 +1,74 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Participacion
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionNappingController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_test_napping.html"
+        self.napping_direction = "cata_system:session_napping"
+
+    def controllGet(self, request: HttpRequest):
+        self.context = {
+            "session": self.session,
+            "type_technique": "napping",
+            "has_ended": self.isEndedSession()
+        }
+
+        if self.session.tecnica.repeticion == 1:
+            self.context["status"] = "En esta sesión se usará Napping"
+        else:
+            self.context["status"] = "Se uso Napping puro en la última sesión"
+
+        if "error" in request.GET:
+            self.context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, self.context)
+
+    def isEndedSession(self):
+        return Participacion.objects.get(
+            tecnica=self.session.tecnica, catador=self.tester).finalizado
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        use_action = request.POST["action"]
+
+        if use_action == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            is_end = self.isEndedSession()
+            if is_end:
+                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+                return render(request, self.current_direction, context)
+
+            update_participation = ParticipacionController.enterSession(
+                tester=request.user.user_catador, session=self.session)
+
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                return render(request, self.current_direction, context)
+
+            request.session["id_participation"] = update_participation.id
+
+            return redirect(reverse(self.napping_direction, kwargs=parameters))
+
+        elif use_action == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return render(request, self.current_direction, context)
+
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)

tecnicas/controllers/views_controller/sessions_tester/login_session_tester_controller.py

@@ -39,6 +39,7 @@ class LoginSessionTesterController():
                     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:
                 with transaction.atomic():
                     code_session = self.session.codigo_sesion
@@ -66,7 +67,7 @@ class LoginSessionTesterController():
             context["error"] = "Ya no es posible ingresar a la sesión"
             return render(request, self.current_direcction, context)
 
-    def validateEntryRATA(self, request: HttpRequest):
+    def validateEntryRataCata(self, request: HttpRequest):
         context = {}
         if not self.session.activo:
             context["error"] = "La sesión no está activa actualmente"
@@ -98,51 +99,64 @@ class LoginSessionTesterController():
             context["error"] = "Imposible acceder a esta sesión"
             return render(request, self.current_direcction, context)
 
-    def validateEntrySort(self, request: HttpRequest):
+    def validateEntryLimitTesters(self, request: HttpRequest):
         context = {}
         if not self.session.activo:
             context["error"] = "La sesión no está activa actualmente"
             return render(request, self.current_direcction, context)
 
         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)
+            return self.entrySessionLimitTesters(request)
 
-            except Participacion.DoesNotExist:
-                try:
-                    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()
-
-                        if current_num_testers >= max_testers:
-                            raise ValueError(
-                                "La sesión ha alcanzado el número máximo de catadores")
-
-                        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))
-                        
-                except ValueError as e:
-                    context["error"] = str(e)
-                    return render(request, self.current_direcction, context)
+        else:
+            context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, context)
+
+    def validateEntryNapping(self, request: HttpRequest):
+        context = {}
+        if not self.session.activo:
+            context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, context)
+
+        if self.session.tecnica.repeticion == 0:
+            return self.entrySessionLimitTesters(request)
 
         else:
             context["error"] = "Ya no es posible ingresar a la sesión"
             return render(request, self.current_direcction, context)
 
-    def validateEntryPF(self, request=HttpRequest):
-        return self.validateEntryEscalas(request=request)
+    def entrySessionLimitTesters(self, request: HttpRequest):
+        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:
+            try:
+                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()
+
+                    if current_num_testers >= max_testers:
+                        raise ValueError(
+                            "La sesión ha alcanzado el número máximo de catadores")
+
+                    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))
+
+            except ValueError as e:
+                context["error"] = str(e)
+                return render(request, self.current_direcction, context)

tecnicas/controllers/views_controller/sessions_tester/tests_forms/test_napping_controller.py

@@ -0,0 +1,74 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from django.db.models import F
+from tecnicas.models import Participacion, Producto, TecnicaModalidad, DatoPunto, Calificacion
+from tecnicas.utils import noValidTechnique
+from .general_test_controller import GenetalTestController
+
+
+class TestNappingController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.napping_test = "tecnicas/forms_tester/test_napping.html"
+
+    def controllGet(self, request: HttpRequest):
+        technique = self.session.tecnica
+
+        self.participation = Participacion.objects.get(
+            tecnica=technique, catador=request.user.user_catador)
+
+        # Comprobar que el Catador no haya finalizado
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        name_mode_activate = TecnicaModalidad.objects.get(
+            tecnica=technique, usando=True).modalidad.nombre
+
+        if name_mode_activate == "sin modalidad":
+            self.context["mode"] = "sin modalidad"
+            return self.nappingTest(request)
+        else:
+            return noValidTechnique(
+                name_view=self.previus_directory,
+                query_params={
+                    "error": "La técnica no tiene modalidad activada"
+                },
+                params={
+                    "code_sesion": self.session.codigo_sesion
+                }
+            )
+
+    def nappingTest(self, request: HttpRequest):
+        self.context["session"] = self.session
+        technique = self.session.tecnica
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+        self.context["products"] = products_in_technique
+
+        self.setCoordinates()
+
+        return render(request, self.napping_test, self.context)
+
+    def setCoordinates(self):
+        technique = self.session.tecnica
+
+        ratings = Calificacion.objects.filter(
+            num_repeticion=0,
+            id_tecnica=technique,
+            id_catador=self.participation.catador
+        )
+
+        data_points = DatoPunto.objects.filter(
+            calificacion__in=ratings
+        ).values(
+            code= F("calificacion__id_producto__codigoProducto"),
+            px= F("x"),
+            py= F("y"),
+            id_product= F("calificacion__id_producto")
+        )
+
+        self.context["data_points"] = list(data_points)

tecnicas/migrations/0025_modalidad_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.2.1 on 2025-11-28 19:09
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0024_alter_sesionsensorial_codigo_sesion_grupoproducto'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Modalidad',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('nombre', models.CharField(max_length=255)),
+            ],
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.CreateModel(
+            name='TecnicaModalidad',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('usado', models.BooleanField(default=False)),
+                ('modalidad', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='modalidad_tecnica', to='tecnicas.modalidad')),
+                ('tecnica', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tecnica_modalidad', to='tecnicas.tecnica')),
+            ],
+        ),
+    ]

tecnicas/migrations/0026_tecnica_modalidad_and_more.py

@@ -0,0 +1,27 @@
+# Generated by Django 5.2.1 on 2025-11-28 19:39
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0025_modalidad_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tecnica',
+            name='modalidad',
+            field=models.ManyToManyField(related_name='modalidad_tecnica', to='tecnicas.modalidad'),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.DeleteModel(
+            name='TecnicaModalidad',
+        ),
+    ]

tecnicas/migrations/0027_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.1 on 2025-11-28 19:59
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0026_tecnica_modalidad_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.AlterField(
+            model_name='tecnica',
+            name='modalidad',
+            field=models.ManyToManyField(blank=True, null=True, related_name='modalidad_tecnica', to='tecnicas.modalidad'),
+        ),
+    ]

tecnicas/migrations/0028_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.1 on 2025-11-28 20:10
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0027_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.AlterField(
+            model_name='tecnica',
+            name='modalidad',
+            field=models.ManyToManyField(blank=True, related_name='modalidad_tecnica', to='tecnicas.modalidad'),
+        ),
+    ]

tecnicas/migrations/0029_remove_tecnica_modalidad_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.2.1 on 2025-11-28 21:48
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0028_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='tecnica',
+            name='modalidad',
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+    ]

tecnicas/migrations/0030_alter_sesionsensorial_codigo_sesion_tecnicamodalidad.py

@@ -0,0 +1,29 @@
+# Generated by Django 5.2.1 on 2025-11-28 21:54
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0029_remove_tecnica_modalidad_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.CreateModel(
+            name='TecnicaModalidad',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('usando', models.BooleanField(default=False)),
+                ('modalidad', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='modalidad_tecnica', to='tecnicas.modalidad')),
+                ('tecnica', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tecnica_modalidad', to='tecnicas.tecnica')),
+            ],
+        ),
+    ]

tecnicas/migrations/0031_calificacion_palabras_and_more.py

@@ -0,0 +1,34 @@
+# Generated by Django 5.2.1 on 2025-11-29 03:05
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0030_alter_sesionsensorial_codigo_sesion_tecnicamodalidad'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='calificacion',
+            name='palabras',
+            field=models.ManyToManyField(blank=True, related_name='calificacion_palabras', to='tecnicas.palabra'),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+        migrations.CreateModel(
+            name='DatoPunto',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('x', models.FloatField(default=0)),
+                ('y', models.FloatField(default=0)),
+                ('calificacion', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='data_punto', to='tecnicas.calificacion')),
+            ],
+        ),
+    ]

tecnicas/models/__init__.py

@@ -3,6 +3,7 @@ from .etiqueta import Etiqueta
 from .tipo_escala import TipoEscala
 from .tipo_tecnica import TipoTecnica
 from .estilo_palabra import EstiloPalabra
+from .modalidad import Modalidad
 
 from .presentador import Presentador
 from .catador import Catador
@@ -31,3 +32,5 @@ from .participacion import Participacion
 
 from .lista_palabras import ListaPalabras
 from .grupo_producto import GrupoProducto
+from .tecnica_modalidad import TecnicaModalidad
+from .dato_punto import DatoPunto

tecnicas/models/calificacion.py

@@ -3,12 +3,20 @@ from django.db import models
 from .producto import Producto
 from .tecnica import Tecnica
 from .catador import Catador
+from .palabra import Palabra
+
 
 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_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")
+
+    palabras = models.ManyToManyField(
+        Palabra, related_name="calificacion_palabras", blank=True)
 
     def __str__(self):
-        return f"{self.id} - {self.id_tecnica.sesion_tecnica} - {self.num_repeticion} - {self.id_catador.user.username}"
+        return f"{self.id} - {self.id_tecnica.sesion_tecnica} - {self.num_repeticion} - {self.id_catador.user.username}"

tecnicas/models/dato_punto.py

@@ -0,0 +1,12 @@
+from django.db import models
+from .calificacion import Calificacion
+
+
+class DatoPunto(models.Model):
+    x = models.FloatField(null=False, default=0)
+    y = models.FloatField(null=False, default=0)
+    calificacion = models.ForeignKey(
+        Calificacion, on_delete=models.CASCADE, related_name="data_punto")
+
+    def __str__(self):
+        return f"({self.calificacion.id_producto.codigoProducto}: {self.x}, {self.y})"

tecnicas/models/modalidad.py

@@ -0,0 +1,8 @@
+from django.db import models
+
+
+class Modalidad(models.Model):
+    nombre = models.CharField(max_length=255)
+
+    def __str__(self):
+        return self.nombre

tecnicas/models/tecnica.py

@@ -2,6 +2,7 @@ from django.db import models
 
 from .estilo_palabra import EstiloPalabra
 from .tipo_tecnica import TipoTecnica
+from .modalidad import Modalidad
 
 
 class Tecnica(models.Model):

tecnicas/models/tecnica_modalidad.py

@@ -0,0 +1,12 @@
+from django.db import models
+from .tecnica import Tecnica
+from .modalidad import Modalidad
+
+
+class TecnicaModalidad(models.Model):
+    tecnica = models.ForeignKey(
+        Tecnica, on_delete=models.CASCADE, related_name="tecnica_modalidad")
+    modalidad = models.ForeignKey(
+        Modalidad, on_delete=models.CASCADE, related_name="modalidad_tecnica")
+
+    usando = models.BooleanField(default=False)

tecnicas/static/js/actions-form.js

@@ -3,4 +3,12 @@ function exit_sesion(styleClass) {
   const action = form.querySelector(".action-input");
   action.value = "exit_session";
   form.submit();
-}
+}
+
+function finishSession(styleClass) {
+  const form = document.querySelector(`.${styleClass}`);
+  form.action = ""
+  const action = form.querySelector(".action-input");
+  action.value = "finish_session";
+  form.submit();
+}

tecnicas/static/js/details-session.js

@@ -17,4 +17,12 @@ function deleteSession() {
   const input = actionForm.querySelector(".action-option")
   input.value = "delete_session";
   actionForm.submit();
-}
+}
+
+function startSession(nameMode) {
+  const nameUnderscort = nameMode.replaceAll(" ", "_");
+  console.log(nameUnderscort);
+  const input = actionForm.querySelector(".action-option")
+  input.value = `start_${nameUnderscort}`;
+  actionForm.submit();
+}

tecnicas/static/js/test-napping.js

@@ -0,0 +1,209 @@
+const planeContainer = document.getElementById('napping-plane');
+const productsContainer = document.getElementById('items');
+const products = document.querySelectorAll('.item-product');
+
+// Configuration for the physical dimensions of the tablecloth (in cm)
+const PHYSICAL_WIDTH = 60;
+const PHYSICAL_HEIGHT = 40;
+
+let selectedProductCode = null;
+let selectedProductId = null;
+
+// Object to store coordinates: { "CODE": { x: 10.5, y: 20.1, id: 123 } }
+const placedPoints = {};
+
+// 1. Handle Product Selection
+products.forEach(product => {
+    product.addEventListener('click', () => {
+        // Remove selection from others
+        products.forEach(p => p.classList.remove('ring-4', 'ring-primary'));
+
+        // Select current
+        product.classList.add('ring-4', 'ring-primary');
+        selectedProductCode = product.dataset.code;
+        selectedProductId = product.dataset.idProduct;
+    });
+});
+
+// 2. Handle Plane Click (Placing Points)
+planeContainer.addEventListener('click', (e) => {
+    if (!selectedProductCode) {
+        spanNotifaction("Por favor, selecciona un producto primero")
+        return;
+    }
+
+    const rect = planeContainer.getBoundingClientRect();
+
+    // Calculate click position relative to the container (in pixels)
+    const xPixel = e.clientX - rect.left;
+    const yPixel = e.clientY - rect.top;
+
+    // Calculate scaled coordinates (0 to PHYSICAL_DIMENSIONS)
+    // X axis: 0 on left, 60 on right
+    const xCoord = (xPixel / rect.width) * PHYSICAL_WIDTH;
+
+    // Y axis: 0 on bottom, 40 on top (Invert Y because DOM Y is 0 at top)
+    const yCoord = PHYSICAL_HEIGHT - ((yPixel / rect.height) * PHYSICAL_HEIGHT);
+
+    // Update Data Object
+    placedPoints[selectedProductCode] = {
+        x: parseFloat(xCoord.toFixed(2)),
+        y: parseFloat(yCoord.toFixed(2)),
+        id: selectedProductId
+    };
+
+    // Render Point
+    renderPoint(selectedProductCode, xPixel, yPixel, xCoord, yCoord);
+});
+
+function renderPoint(code, xPx, yPx, xVal, yVal) {
+    // Remove existing point for this product if it exists
+    const existingPoint = document.getElementById(`point-${code}`);
+    if (existingPoint) {
+        existingPoint.remove();
+    }
+
+    const point = document.createElement('div');
+    point.id = `point-${code}`;
+    point.className = 'absolute w-4 h-4 bg-red-600 rounded-full transform -translate-x-1/2 -translate-y-1/2 cursor-pointer border-2 border-white shadow-md group';
+    point.style.left = `${xPx}px`;
+    point.style.top = `${yPx}px`;
+
+    // Tooltip/Label
+    const label = document.createElement('div');
+    label.className = 'absolute bottom-full left-1/2 transform -translate-x-1/2 mb-2 px-2 py-1 bg-gray-800 text-white text-xs rounded whitespace-nowrap z-10 hidden group-hover:block';
+    label.innerHTML = `
+            <strong>${code}</strong><br>
+            X: ${xVal.toFixed(1)}<br>
+            Y: ${yVal.toFixed(1)}
+        `;
+
+    point.appendChild(label);
+    planeContainer.appendChild(point);
+
+    const textLabel = document.createElement('span');
+    textLabel.className = 'absolute top-4 left-1/2 transform -translate-x-1/2 text-xs font-bold text-gray-700 pointer-events-none';
+    textLabel.innerText = code;
+    point.appendChild(textLabel);
+}
+
+function checkPoints() {
+    const points = document.querySelectorAll('.data-point');
+
+    points.forEach(point => {
+        const code = point.dataset.code;
+
+        const xVal = parseFloat(point.dataset.px);
+        const yVal = parseFloat(point.dataset.py);
+
+        const rect = planeContainer.getBoundingClientRect();
+
+        const px = (xVal / PHYSICAL_WIDTH) * rect.width;
+        const py = ((PHYSICAL_HEIGHT - yVal) / PHYSICAL_HEIGHT) * rect.height;
+
+        placedPoints[code] = {
+            x: parseFloat(xVal.toFixed(2)),
+            y: parseFloat(yVal.toFixed(2)),
+            id: point.dataset.idProduct
+        };
+
+        renderPoint(code, px, py, xVal, yVal);
+    });
+}
+
+checkPoints();
+
+/*
+////
+//////
+//////// Question to finish session
+//////
+////
+*/
+
+function showOptionsSave() {
+    document.getElementById("question-save").classList.add("hidden");
+    document.getElementById("finish-session").classList.remove("hidden");
+    document.getElementById("cancel-save").classList.remove("hidden");
+}
+
+function showQuestionSave() {
+    document.getElementById("question-save").classList.remove("hidden");
+    document.getElementById("finish-session").classList.add("hidden");
+    document.getElementById("cancel-save").classList.add("hidden");
+}
+
+document
+    .getElementById("question-save")
+    .addEventListener("click", showOptionsSave);
+
+document
+    .getElementById("cancel-save")
+    .addEventListener("click", showQuestionSave);
+
+/*
+////
+//////
+//////// Save data and finish session
+//////
+////
+*/
+
+async function saveData() {
+    const codeProducts = Object.keys(placedPoints);
+    const data = [];
+
+    if (products.length != codeProducts.length) {
+        spanNotifaction("Por favor, coloca todos los puntos")
+        return;
+    }
+
+    codeProducts.forEach((code) => {
+        const point = placedPoints[code];
+
+        const objData = {
+            code: code,
+            x: point.x,
+            y: point.y,
+            idProduct: point.id
+        };
+
+        data.push(objData);
+    })
+
+    const URL = "/cata/testers/api/rating-napping/no-mode"
+    const csrfToken = document.querySelector('[name=csrfmiddlewaretoken]').value;
+
+    try {
+        const response = await fetch(URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-CSRFToken": csrfToken,
+            },
+            body: JSON.stringify(data),
+        })
+
+        if (!response.ok) {
+            spanNotifaction("Error en la respuesta del servidor")
+            return false;
+        }
+
+        const result = await response.json()
+
+        if (result.error) {
+            spanNotifaction(result.error)
+            return false
+        } else {
+            spanNotifaction(result.message, false)
+            return true
+        }
+    } catch (error) {
+        spanNotifaction("Error en proceso de guardar los datos")
+        return false
+    }
+}
+
+document
+    .getElementById("save-progress")
+    .addEventListener("click", saveData);

tecnicas/templates/tecnicas/components/table-napping-no-mode.html

@@ -0,0 +1,41 @@
+{% load custom_filters %}
+<article class="space-y-4 text-black">
+    <h2 class="font-bold text-xl text-center">
+        Datos de Napping sin modalidad
+    </h2>
+
+    <div class="overflow-x-auto rounded-lg border border-surface-general">
+        <table id="generic-donwload-table" class="min-w-max w-full text-sm text-center border-collapse">
+            <thead class="bg-surface-sweet font-semibold">
+                <tr>
+                    <th class="py-2 px-3 border border-surface-general">Producto</th>
+                    {% for tester in testers %}
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        X{{ forloop.counter }}
+                    </th>
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        Y{{ forloop.counter }}
+                    </th>
+                    {% endfor %}
+                </tr>
+            </thead>
+            <tbody class="bg-surface-ligt divide-y divide-gray-200">
+                {% for product, coordinates_tester in coordinates_no_mode.items %}
+                <tr>
+                    <td class="py-2 px-3 border border-surface-general">{{ product }}</td>
+                    {% for tester in testers %}
+                    {% with points=coordinates_tester|get_item:tester.user.username %}
+                    <td class="py-2 px-3 border border-surface-general">
+                        {{ points.px }}
+                    </td>
+                    <td class="py-2 px-3 border border-surface-general">
+                        {{ points.py }}
+                    </td>
+                    {% endwith %}
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</article>

tecnicas/templates/tecnicas/forms_tester/init_test_napping.html

@@ -0,0 +1,113 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Detalles Sesion{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <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
+            </h1>
+        </header>
+
+        <article>
+            <p class="text-2xl font-medium text-center bg-surface-sweet p-4 rounded-lg">
+                Información sobre la sesión en la que participa
+            </p>
+        </article>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+        <hr>
+
+        <article class="rounded-xl grid grid-cols-1 gap-3 text-center grid grid-cols-2">
+            <section class="bg-surface-card col-span-2 p-4 rounded-2xl flex max-sm:flex-col justify-center gap-2">
+                <p class="text-xl font-bold">
+                    Código:
+                </p>
+                <p class="font-sans text-xl font-normal">
+                    {{ session.codigo_sesion }}
+                </p>
+            </section>
+
+            <section class="bg-surface-card col-span-2 p-4 rounded-2xl">
+                <p class="text-xl font-bold">
+                    {% if session.nombre_sesion %}
+                    {{ session.nombre_sesion }}
+                    {% else %}
+                    Sin nombre
+                    {% endif %}
+                </p>
+            </section>
+
+            <section class="bg-surface-card p-4 rounded-2xl flex max-sm:flex-col justify-center gap-2">
+                <p class="text-xl font-medium">
+                    Esta sesión usa la técnica <span class="uppercase">{{ session.tecnica.tipo_tecnica }}</span>
+                </p>
+            </section>
+
+            <section class="bg-surface-card p-4 rounded-2xl flex max-sm:flex-col justify-center gap-2">
+                <p class="text-xl font-medium">
+                    Sesión Única
+                </p>
+            </section>
+
+            <section class="bg-surface-card col-span-2 p-4 rounded-2xl">
+                <p class="text-xl">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+
+            <section class="bg-surface-card col-span-2 p-4 rounded-2xl">
+                <p class="text-xl">
+                    {{ status }}
+                </p>
+            </section>
+        </article>
+
+        <hr>
+
+        <article class="flex flex-wrap gap-10">
+            {% if has_ended %}
+            <div
+                class="text-2xl font-semibold flex-1 cts-btn-secondary p-4 flex justify-center items-center rounded-lg select-none">
+                <p class=" text-black">Finalizaste la sesión</p>
+            </div>
+            {% else %}
+            <button
+                class="ct-btn-start-repition flex-1 uppercase text-lg tracking-wider cts-btn-general cts-btn-primary btn-push flex flex-col justify-center items-center gap-2"
+                onclick="startTest()">
+                Iniciar técnica
+                <figure class="w-10">
+                    <img src="{% static 'img/check.svg' %}" alt="flechas girando" class="invert">
+                </figure>
+            </button>
+            {% endif %}
+            <a href="{% url 'cata_system:catador_list_sessions' num_page=1 %}">
+                <button
+                    class="flex-1 uppercase text-lg tracking-wider cts-btn-general cts-btn-error btn-push flex flex-col justify-center items-center gap-2">
+                    Regresar a la lista
+                    <figure class="w-10">
+                        <img src="{% static 'img/exit.svg' %}" alt="bote de basura" class="invert">
+                    </figure>
+                </button>
+            </a>
+        </article>
+
+        <form action="" method="post" class="hidden ct-action-form">
+            {% csrf_token %}
+            <input type="hidden" class="action-option" name="action" value="start_posting">
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/start-tester-test.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/forms_tester/test_napping.html

@@ -0,0 +1,150 @@
+{% extends 'tecnicas/layouts/base.html' %}
+
+{% load static %}
+
+{% block title %}Napping{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black max-w-4xl">
+        <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
+                <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
+            </button>
+        </header>
+
+        <article class="hidden">
+            <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 %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+
+        <article class="rounded flex flex-col gap-4">
+            <section class="flex items-center justify-center bg-surface-ligt p-2 rounded-lg">
+                <p class="text-lg font-medium text-center">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+
+            <section class="flex items-center justify-center flex-wrap gap-4 bg-surface-ligt p-2 rounded-lg">
+                <p class="text-xl font-bold text-center capitalize">
+                    Modalidad: {% if mode != "sin modalidad" %}{{ mode }} {% else %} Nappging {% endif %}
+                </p>
+            </section>
+        </article>
+
+        <article class="container-rating-word p-2 py-6 space-y-6 bg-surface-ligt rounded min-w-3xl">
+            <h2 class="text-xl font-bold">Productos en la sesión</h2>
+            <div id="items" class="original-products flex gap-4 flex-wrap justify-center"
+                data-original-products="original">
+                {% for product in products %}
+                <div class="item-product bg-btn-secondary text-black font-bold px-4 py-2 rounded cursor-grab transition-all"
+                    data-id-product="{{ product.id }}" data-code="{{ product.codigoProducto }}">
+                    {{ product.codigoProducto }}
+                </div>
+                {% endfor %}
+            </div>
+
+            <!-- Cartesian Plane Container -->
+            <div class="flex justify-center w-full">
+                <div class="relative w-full max-w-[800px] aspect-[3/2] bg-white border-2 border-gray-400 shadow-inner cursor-crosshair"
+                    id="napping-plane"
+                    style="background-image: linear-gradient(#e5e7eb 1px, transparent 1px), linear-gradient(90deg, #e5e7eb 1px, transparent 1px); background-size: 20px 20px;">
+
+                    <span class="absolute bottom-1 right-2 text-xs text-gray-500 font-bold">60cm (X)</span>
+                    <span class="absolute top-2 left-1 text-xs text-gray-500 font-bold">40cm (Y)</span>
+                    <span class="absolute bottom-1 left-1 text-xs text-gray-500 font-bold">0</span>
+
+                    {% for point in data_points %}
+                    <div id="point-{{ point.code }}"
+                        class="data-point absolute w-4 h-4 bg-red-600 rounded-full transform -translate-x-1/2 -translate-y-1/2 cursor-pointer border-2 border-white shadow-md group"
+                        data-px="{{ point.px }}" data-py="{{ point.py }}" data-code="{{ point.code }}"
+                        data-id-product="{{ point.id_product }}">
+                        <div
+                            class="absolute bottom-full left-1/2 transform -translate-x-1/2 mb-2 px-2 py-1 bg-gray-800 text-white text-xs rounded whitespace-nowrap z-10 hidden group-hover:block">
+                            <strong>{{ point.code }}</strong><br>
+                            X: {{ point.px }}<br>
+                            Y: {{ point.py }}
+                        </div>
+                        <span
+                            class="absolute top-4 left-1/2 transform -translate-x-1/2 text-xs font-bold text-gray-700 pointer-events-none">
+                            {{ point.code }}
+                        </span>
+                    </div>
+                    {% endfor %}
+                </div>
+            </div>
+
+            <section role="alert" class="alert alert-info">
+                <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
+                    class="h-6 w-6 shrink-0 stroke-current">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                        d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 0 0118 0z"></path>
+                </svg>
+                <span class="text-lg">
+                    Para guardar los datos sin finalizar su sesión use el botón
+                    <b>"Guardar progreso"</b>
+                </span>
+            </section>
+
+            <section role="alert" class="alert alert-warning">
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-6 w-6 shrink-0 stroke-current" fill="none"
+                    viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                        d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+                </svg>
+                <div class="flex-col">
+                    <span class="text-lg block">
+                        Si usas el botón <b>“Salir de la sesión”</b> asegúrese de guardar el progreso de lo contrario
+                        perderás todo lo que no hayas guardado antes
+                    </span>
+                    <span class="text-lg block">
+                        Con el botón <b>“Finalizar”</b>, se guardan las posiciones, sales de la sesión y no
+                        podrás ingresar otra vez
+                    </span>
+                </div>
+            </section>
+
+            <section class="flex justify-end gap-4 max-sm:flex-col">
+                <button id="save-progress" class="cts-btn-general cts-btn-primary btn-push">
+                    Guardar progreso
+                </button>
+                <div class="flex gap-2">
+                    <button id="question-save" class="cts-btn-general cts-btn-secondary btn-push flex-1">
+                        ¿Finalizar sesión?
+                    </button>
+                    <button id="finish-session" class="cts-btn-general cts-btn-tertiary btn-push hidden flex-1"
+                        onclick="finishSession('form-actions')">
+                        Finalizar
+                    </button>
+                    <button id="cancel-save" class="cts-btn-general cts-btn-error btn-push hidden flex-1">
+                        Cancelar
+                    </button>
+                </div>
+                <span id="loading-data-save" class="loading loading-spinner loading-xl text-accent hidden"></span>
+            </section>
+        </article>
+
+        {% include "../components/toast-container.html" %}
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/actions-form.js' %}"></script>
+<script src="{% static 'js/test-napping.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/manage_sesions/details-session-napping.html

@@ -0,0 +1,198 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Detalles Sesion{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <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
+            </h1>
+            <a href="{% url 'cata_system:panel_sesiones' page=1 %}">
+                <button class="cts-btn-general cts-btn-error btn-push">
+                    Volver a las Sesiones
+                </button>
+            </a>
+        </header>
+
+        {% if message %}
+        {% 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  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>
+                <p class="font-sans">
+                    {{ session.codigo_sesion }}
+                </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-bold">
+                    Nombre:
+                </p>
+                <p class="antialiased">
+                    {% if session.nombre_sesion %}
+                    {{ session.nombre_sesion }}
+                    {% else %}
+                    Sin nombre
+                    {% endif %}
+                </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">
+                    Fecha creación:
+                </p>
+                <p class="font-sans font-normal uppercase">
+                    {{ session.fechaCreacion }}
+                </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">
+                    Estado:
+                </p>
+                <p class="font-sans text-lg max-sm:text-base font-normal">
+                    {{ status }}
+                </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>
+                <p class="font-sans text-lg max-sm:text-base font-normal uppercase">
+                    {{ session.tecnica.tipo_tecnica }}
+                </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-sans">
+                    <b>Catadores Max.</b> {{ session.tecnica.limite_catadores }}
+                </p>
+            </section>
+
+            {% if repetition %}
+            <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">
+                    <b>Repetición:</b> {{ repetition }}
+                </p>
+            </section>
+            {% endif %}
+
+            <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>
+                <p class="font-sans text-xl max-sm:text-base font-normal">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+        </article>
+
+        <p class="text-black font-bold text-2xl border-b-2">
+            Modalidades disponibles
+        </p>
+        <article class="grid grid-cols-2 gap-4 max-sm:gap-2">
+            {% if not session.activo %}
+            {% for mode in modes %}
+            <button
+                class="cts-btn-general capitalize cts-btn-primary btn-push flex flex-col justify-center items-center gap-2"
+                data-mode="{{ mode.nombre }}" onclick="startSession('{{ mode.nombre }}')">
+                Napping {% if mode.nombre != "sin modalidad" %} {{ mode.nombre }} {% endif %}
+                <figure class="w-10">
+                    <img src="{% static 'img/giro.svg' %}" alt="flechas girando" class="invert">
+                </figure>
+            </button>
+            {% endfor %}
+            {% else %}
+            <a href="{% url 'cata_system:monitor_sesion' session_code=session.codigo_sesion %}" class="w-full">
+                <button
+                    class="cts-btn-general capitalize active:border-orange-500 border-orange-800 bg-orange-600 btn-push flex flex-col justify-center items-center gap-2 w-full">
+                    Monitorear repetición
+                    <figure class="w-10">
+                        <img src="{% static 'img/monitor.svg' %}" alt="flechas girando" class="invert">
+                    </figure>
+                </button>
+            </a>
+            {% endif %}
+            <button
+                class="uppercase text-lg cts-btn-general cts-btn-error btn-push flex flex-col justify-center items-center gap-2 w-full"
+                onclick="showWarningDialog('cts-warnig-dialog')">
+                borrar
+                <figure class="w-10">
+                    <img src="{% static 'img/basura.svg' %}" alt="bote de basura" class="invert">
+                </figure>
+            </button>
+        </article>
+
+        <section
+            class="absolute w-full h-full flex justify-center items-center bg-surface-alter-card/70 top-0 left-0 p-6 rounded-xl cts-warnig-dialog hidden">
+            <article class="bg-surface-card p-4 space-y-6 rounded-xl">
+                <h2 class="text-4xl text-black text-center">
+                    ¡¡¡Cuidado!!!
+                </h2>
+                <p class="text-2xl text-black text-center">
+                    Esta acción no es reversible, si la continua también borrara todos los datos recopilados
+                    relacionados a esta sesión y no podrá volver a recuperarlos
+                </p>
+                <section class="text-black font-bold text-xl space-y-4">
+                    <p class="text-center">
+                        ¿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()">
+                            Estoy seguro
+                        </button>
+                        <button class="cts-btn-general cts-btn-primary btn-push"
+                            onclick="hiddenWarningDialog('cts-warnig-dialog')">
+                            No, cancelar
+                        </button>
+                    </div>
+                </section>
+            </article>
+        </section>
+
+        <p class="text-black font-bold text-2xl border-b-2">
+            Datos obtenidos
+        </p>
+
+        {% if there_data %}
+        {% include "../components/table-napping-no-mode.html" with testers=testers coordinates_no_mode=coordinates_no_mode %}
+        {% else %}
+        {% include "../components/error-message.html" with message='Sin datos por mostrar aún' %}
+        {% endif %}
+
+
+        <form action="" method="post" class="form-action-session hidden">
+            <input type="hidden" name="action" class="action-option">
+            {% csrf_token %}
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/details-session.js' %}"></script>
+<script src="{% static 'js/showHiddenElement.js' %}"></script>
+{% endblock %}

tecnicas/urls.py

@@ -122,6 +122,10 @@ urlpatterns = [
          views.sortTest,
          name="session_sort"),
 
+    path("testers/init-session/<str:code_sesion>/nappping",
+         views.nappingTest,
+         name="session_napping"),
+
 
     # APIs
     path("presenter/api/nueva-etiqueta",
@@ -151,4 +155,8 @@ urlpatterns = [
     path("testers/api/rating-sort",
          views.ratingSort,
          name="api_rating_sort"),
+
+    path("testers/api/rating-napping/no-mode",
+         views.ratingNappingNoMode,
+         name="api_rating_napping_no_mode"),
 ]

tecnicas/views/__init__.py

@@ -29,6 +29,7 @@ from .apis.api_list_words_pf import apiListWordsPF
 from .apis.rating_word_scales import ratingWordScales
 from .apis.rating_word_cata import ratingWordCata
 from .apis.rating_sort import ratingSort
+from .apis.rating_napping import ratingNappingNoMode
 
 from .tester_forms.init_tester_form import initTesterForm
 from .tester_forms.panel_main_tester import mainPanelTester
@@ -38,3 +39,4 @@ from .tester_forms.convencional_scales import convencionalScales
 from .tester_forms.cata_test import cataTest
 from .tester_forms.pf_test import pfTest
 from .tester_forms.sort_test import sortTest
+from .tester_forms.napping_test import nappingTest

tecnicas/views/apis/rating_napping.py

@@ -0,0 +1,16 @@
+from django.http import HttpRequest, JsonResponse
+from tecnicas.controllers import RatingNappingController
+import json
+
+
+def ratingNappingNoMode(req:  HttpRequest):
+    if req.method == "POST":
+        try:
+            data = json.loads(req.body.decode("utf-8"))
+            response = RatingNappingController.saveRatingCoordinates(
+                request=req, data=data)
+            return response
+        except Exception as e:
+            return JsonResponse({"error": "Error al procesar datos"})
+    else:
+        return JsonResponse({"error": "Método no permitido"})

tecnicas/views/sessions_management/session_details.py

@@ -3,7 +3,7 @@ from django.shortcuts import redirect
 from django.urls import reverse
 from tecnicas.models import SesionSensorial
 from tecnicas.utils import noValidTechnique
-from tecnicas.controllers import DetallesController, DetallesEscalasController, DetallesCATAController, DetallesPFController, DetallesSortController
+from tecnicas.controllers import DetallesController, DetallesEscalasController, DetallesCATAController, DetallesPFController, DetallesSortController, DetallesNappingController
 
 
 def sessionDetails(req: HttpRequest, session_code: str):
@@ -43,6 +43,12 @@ def sessionDetails(req: HttpRequest, session_code: str):
             response = controller_view.controllGetResponse(
                 request=req, message=message)
 
+        elif use_techinique == "napping":
+            controller_view = DetallesNappingController(
+                session=sensorial_session)
+            response = controller_view.controllGetResponse(
+                request=req, message=message)
+
         else:
             response = noValidTechnique(
                 params={"page": 1},
@@ -51,6 +57,7 @@ def sessionDetails(req: HttpRequest, session_code: str):
                 },
                 name_view="cata_system:panel_sesiones"
             )
+            
         return response
 
     elif req.method == "POST":
@@ -58,19 +65,27 @@ def sessionDetails(req: HttpRequest, session_code: str):
             codigo_sesion=session_code)
 
         use_techinique = sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
-
         controller_view = DetallesController(sensorial_session)
 
+        action = req.POST.get("action")
+
         if use_techinique in ["escalas", "rata", "cata", "perfil flash", "sort"]:
-            if req.POST.get("action") == "start_session":
+            if action == "start_session":
                 response = controller_view.startRepetition(
                     presenter=req.user.user_presentador, request=req)
 
-            elif req.POST.get("action") == "delete_session":
+            elif action == "delete_session":
                 controller_view.deleteSesorialSession()
                 response = redirect(
                     reverse("cata_system:panel_sesiones", kwargs={"page": 1}))
 
+        elif use_techinique == "napping":
+            controller_view = DetallesNappingController(
+                session=sensorial_session)
+
+            response = controller_view.controllPostResponse(
+                request=req, action=action)
+
         else:
             response = controller_view.controllGetResponse(
                 error="No se reconoce la acción a realizar")

tecnicas/views/sessions_management/session_monitor.py

@@ -7,7 +7,7 @@ from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from tecnicas.models import SesionSensorial
-from tecnicas.controllers import MonitorEscalasController, MonitorRATAController, MonitorPFController, MonitorSortController
+from tecnicas.controllers import MonitorEscalasController, MonitorRATAController, MonitorPFController, MonitorSortController, MonitorNappingController
 from tecnicas.utils import noValidTechnique
 
 
@@ -29,6 +29,10 @@ def sessionMonitor(req: HttpRequest, session_code: str):
             controll_view = MonitorSortController(sensorial_session)
             response = controll_view.controllGetResponse(request=req)
 
+        elif use_techinique == "napping":
+            controll_view = MonitorNappingController(sensorial_session)
+            response = controll_view.controllGetResponse(request=req)
+
         else:
             response = noValidTechnique(
                 params={
@@ -89,6 +93,17 @@ def sessionMonitor(req: HttpRequest, session_code: str):
                 response = controll_view.controlGetResponse(
                     request=req, error="No se ha definido la acción a realizar")
 
+        elif use_techinique == "napping":
+            controll_view = MonitorNappingController(sensorial_session)
+            action = req.POST["action"]
+
+            if action == "finish_session":
+                response = controll_view.controllPostFinishSession(
+                    request=req)
+            else:
+                response = controll_view.controlGetResponse(
+                    request=req, error="No se ha definido la acción a realizar")
+
         else:
             response = noValidTechnique(
                 params={

tecnicas/views/tester_forms/init_tester_form.py

@@ -1,6 +1,6 @@
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import render
-from tecnicas.controllers import InitSessionEscalasController, InitSessionRATAController, InitSessionPFController, InitSessionSortController
+from tecnicas.controllers import InitSessionEscalasController, InitSessionRATAController, InitSessionPFController, InitSessionSortController, InitSessionNappingController
 from tecnicas.models import SesionSensorial
 
 
@@ -30,10 +30,15 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
                 sensorial_session=session, user_tester=req.user.user_catador)
             response = view_controller.controllGet(request=req)
 
+        elif type_technique == "napping":
+            view_controller = InitSessionNappingController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllGet(request=req)
+
         else:
             context = {
                 "session": session,
-                "error": "La técnica usada en esta sesión o ha sido implementada para ingresar a ella"
+                "error": "La técnica usada en esta sesión no ha sido implementada para ingresar a ella"
             }
             response = render(
                 req, template_url, context)
@@ -41,7 +46,7 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
         return response
 
     elif req.method == "POST":
-        if type_technique == "escalas" or type_technique == "rata" or type_technique == "cata":
+        if type_technique in ["escalas", "rata", "cata"]:
             view_controller = InitSessionEscalasController(
                 sensorial_session=session, user_tester=req.user.user_catador)
             response = view_controller.controllPost(request=req)
@@ -55,7 +60,12 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
             view_controller = InitSessionSortController(
                 sensorial_session=session, user_tester=req.user.user_catador)
             response = view_controller.controllPost(request=req)
-        
+
+        elif type_technique == "napping":
+            view_controller = InitSessionNappingController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllPost(request=req)
+
         else:
             context = {
                 "session": session,

tecnicas/views/tester_forms/login_session.py

@@ -27,17 +27,14 @@ def loginSessionTester(req: HttpRequest):
 
         type_technique = session.tecnica.tipo_tecnica.nombre_tecnica
 
-        if type_technique == "escalas":
-            response = login_controller.validateEntryEscalas(request=req)
+        if type_technique in ["escalas", "perfil flash", "sort"]:
+            response = login_controller.validateEntryLimitTesters(request=req)
 
-        elif type_technique == "rata" or type_technique == "cata":
-            response = login_controller.validateEntryRATA(request=req)
+        elif type_technique in ["rata", "cata"]:
+            response = login_controller.validateEntryRataCata(request=req)
 
-        elif type_technique == "perfil flash":
-            response = login_controller.validateEntryRATA(request=req)
-
-        elif type_technique == "sort":
-            response = login_controller.validateEntrySort(request=req)
+        elif type_technique == "napping":
+            response = login_controller.validateEntryNapping(request=req)
 
         else:
             context = {

tecnicas/views/tester_forms/napping_test.py

@@ -0,0 +1,27 @@
+from django.http import HttpRequest
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import TestNappingController
+from tecnicas.utils import noValidTechnique
+
+
+def nappingTest(req: HttpRequest, code_sesion: str):
+    if req.method == "GET":
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestNappingController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllGet(request=req)
+
+    elif req.method == "POST":
+        # Se usa para finalizar la sesión
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestNappingController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllPost(request=req)
+
+    else:
+        return noValidTechnique(
+            name_view="cata_system:catador_init_session",
+            query_params={
+                "error": "Método no valido"
+            }
+        )