Merge branch 'dev'

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
+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,3 +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

@@ -16,22 +16,53 @@ from .views_controller.create_session.panel_basic_controller import PanelBasicCo
 from .views_controller.create_session.panel_tags_controller import PanelTagsController
 from .views_controller.create_session.panel_codes_controller import PanelCodesController
 from .views_controller.create_session.panel_words_controller import PanelWordsController
-from .views_controller.create_session.panel_create_controller import PanelCreateController
 
-from .views_controller.session_management.details_controller import DetallesController
-from .views_controller.session_management.details_escala_controller import DetallesEscalasController
-from .views_controller.session_management.details_rata_controller import DetallesRATAController
-from .views_controller.session_management.monitor_controller import MonitorController
-from .views_controller.session_management.monitor_escalas_controller import MonitorEscalasController
-from .views_controller.session_management.monitor_rata_controller import MonitorRATAController
+from .views_controller.create_session.panels_create.panel_create_escalas_controller import PanelCreateEscalasController
+from .views_controller.create_session.panels_create.panel_create_rata_controller import PanelCreateRataController
+from .views_controller.create_session.panels_create.panel_create_cata_controller import PanelCreateCataController
+from .views_controller.create_session.panels_create.panel_create_pf_controller import PanelCreatePFController
+from .views_controller.create_session.panels_create.panel_create_sort_controller import PanelCreateSortController
+from .views_controller.create_session.panels_create.panel_create_napping_controller import PanelCreateNappingController
+
+
+from .views_controller.session_management.details.details_controller import DetallesController
+from .views_controller.session_management.details.details_escala_controller import DetallesEscalasController
+from .views_controller.session_management.details.details_rata_controller import DetallesRATAController
+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.init_session_tester_controller import InitSessionTesterController
-from .views_controller.sessions_tester.convencional_scales_controller import ConvencionalScalesController
 from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
 
+from .views_controller.sessions_tester.tests_forms.test_scales_controller import TestScalesController
+from .views_controller.sessions_tester.tests_forms.test_rata_controller import TestRataController
+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.view_vocabulary_controller import ViewVocabularyController
 from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController
 
-from .views_controller.api_rating_controller import ApiRatingController
+from .api_controller.rating_sacales_controller import RatingScalesController
+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_cata_controller.py

@@ -0,0 +1,78 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction
+from tecnicas.models import Calificacion, Dato, ValorBooleano, Participacion, Palabra
+
+
+class RatingCataController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def saveRatingWords(request: HttpRequest, data_words: list[dict], data_prodct: dict):
+        try:
+            with transaction.atomic():
+                participation = Participacion.objects.get(
+                    id=request.session["id_participation"])
+                if not participation:
+                    raise ValueError("No está autorizado en la sesión")
+
+                ids_words = []
+                words_values = {}
+
+                # Acoplar datos para usar
+                for da_wo in data_words:
+                    ids_words.append(da_wo["id"])
+                    words_values[da_wo["word"]] = da_wo["is_check"]
+
+                words_for_rating = Palabra.objects.filter(id__in=ids_words)
+                if not words_for_rating:
+                    raise ValueError("No se han encontrado sus palabras")
+
+                technique = participation.tecnica
+
+                # Creando la calificacion
+                (rating, creataed) = Calificacion.objects.get_or_create(
+                    num_repeticion=technique.repeticion,
+                    id_producto_id=data_prodct["id"],
+                    id_tecnica=technique,
+                    id_catador=request.user.user_catador
+                )
+                if not rating:
+                    raise ValueError("Problemas al crear la calificación")
+
+                # Guardando datos
+                data_for_save = []
+                for word in words_for_rating:
+                    data_for_save.append(Dato(
+                        id_palabra=word,
+                        id_calificacion=rating
+                    ))
+
+                Dato.objects.bulk_create(data_for_save)
+                data_saved = Dato.objects.filter(
+                    id_calificacion=rating).only("id_palabra")
+                if not data_saved:
+                    raise ValueError("Problemas al crear los datos")
+
+                # Guardando valores de datos
+                values_for_save = []
+                for data in data_saved:
+                    word_for_rating = data.id_palabra.nombre_palabra
+                    values_for_save.append(
+                        ValorBooleano(
+                            id_dato=data,
+                            valor=words_values[word_for_rating]
+                        )
+                    )
+
+                ValorBooleano.objects.bulk_create(values_for_save)
+                values_saves = ValorBooleano.objects.filter(
+                    id_dato__id_calificacion=rating).count()
+                if not values_saves:
+                    raise ValueError("Error al guardar los datos")
+
+            return JsonResponse({"message": "Valores guardados"})
+
+        except ValueError as e:
+            print(f"Error de calificacion: {e}")
+            return JsonResponse({"error": e}, statusstatus=500)

tecnicas/controllers/api_controller/rating_napping_controller.py

@@ -0,0 +1,367 @@
+from django.http import JsonResponse
+from django.http import HttpRequest
+from django.db import transaction
+from tecnicas.models import Calificacion, DatoPunto, Producto, Participacion, Palabra, GrupoProducto, TecnicaModalidad
+from tecnicas.forms import ListWordsForm
+
+
+class RatingNappingController:
+    @staticmethod
+    def saveRatingCoordinates(request: HttpRequest, data: list | dict):
+        participation = Participacion.objects.get(
+            id=request.session["id_participation"]
+        )
+
+        name_mod = TecnicaModalidad.objects.get(
+            tecnica=participation.tecnica
+        ).modalidad.nombre.lower()
+
+        # Branch based on modality
+        if name_mod == 'sorting':
+            return RatingNappingController.processSortingMode(
+                data, participation
+            )
+
+        if name_mod in ['sin modalidad', 'perfil ultra flash']:
+            return RatingNappingController.processNappOrPUF(
+                data, participation
+            )
+
+        else:
+            return JsonResponse({"error": "Modalidad no soportada"})
+
+    @staticmethod
+    def processSortingMode(data: dict, participation):
+        try:
+            with transaction.atomic():
+                # Extract products array (always present)
+                products = data.get("products", [])
+                if not products:
+                    return JsonResponse({"error": "No se proporcionaron productos"})
+
+                existing_ratings_map, products_map = RatingNappingController.savePoints(
+                    isSorting=True, products=products, participation=participation
+                )
+
+                # Process groups if they exist
+                groups = data.get("groups", {})
+                if groups:
+                    RatingNappingController.processGroupsForSorting(
+                        products, groups, participation, existing_ratings_map, products_map
+                    )
+                else:
+                    RatingNappingController.deleteAllGroups(participation)
+
+            return JsonResponse({"message": "Datos guardados exitosamente"})
+
+        except Exception as e:
+            print("ERROR:", e)
+            import traceback
+            traceback.print_exc()
+            return JsonResponse({"error": f"Error al procesar datos: {str(e)}"})
+
+    @staticmethod
+    def processNappOrPUF(data: list, participation):
+        try:
+            with transaction.atomic():
+                existing_ratings_map, products_map = RatingNappingController.savePoints(
+                    isSorting=False, products=data, participation=participation
+                )
+
+                RatingNappingController.processWordsForRatings(
+                    data, existing_ratings_map
+                )
+
+            return JsonResponse({"message": "Datos guardados exitosamente"})
+
+        except Exception as e:
+            print("ERROR:", e)
+            return JsonResponse({"error": "Error al procesar datos"})
+
+    @staticmethod
+    def processGroupsForSorting(products, groups, participation, existing_ratings_map, products_map):
+        """Process groups for sorting mode
+        - Creates/updates GrupoProducto instances
+        - Ensures products don't belong to multiple groups
+        - Associates words with groups
+        """
+        # Build mapping of product_id to group_id from products array
+        product_to_group = {}
+        for product_item in products:
+            group_code = product_item.get("group", "")
+            if group_code:  # Only if product has a group assigned
+                product_id = int(product_item["idProduct"])
+                if product_id in product_to_group:
+                    raise ValueError(
+                        f"Producto {product_id} pertenece a múltiples grupos")
+                product_to_group[product_id] = group_code
+
+        # Get existing groups for this catador and technique
+        existing_groups = GrupoProducto.objects.filter(
+            tecnica=participation.tecnica,
+            catador=participation.catador
+        )
+
+        # Create a map of existing groups by their product composition
+        # We'll identify groups by the set of products they contain
+        existing_groups_map = {}
+        for group in existing_groups:
+            product_ids = set(group.productos.values_list('id', flat=True))
+            key = frozenset(product_ids)
+            existing_groups_map[key] = group
+
+        # Build new groups structure
+        groups_to_create = []
+        groups_to_update = []
+        group_products_map = {}  # group_id -> [product_ids]
+
+        # Organize products by group
+        for product_id, group_code in product_to_group.items():
+            if group_code not in group_products_map:
+                group_products_map[group_code] = []
+            group_products_map[group_code].append(product_id)
+
+        # Process each group
+        for group_code, product_ids in group_products_map.items():
+            product_set = frozenset(product_ids)
+
+            # Check if this group already exists
+            if product_set in existing_groups_map:
+                group = existing_groups_map[product_set]
+                groups_to_update.append((group, group_code))
+            else:
+                # Create new group
+                group = GrupoProducto(
+                    tecnica=participation.tecnica,
+                    catador=participation.catador
+                )
+                groups_to_create.append((group, product_ids, group_code))
+
+        # Create new groups
+        created_groups = []
+        for group, product_ids, group_code in groups_to_create:
+            group.save()  # Save first to get ID for M2M
+
+            # Add products to group
+            productos = [products_map[pid]
+                         for pid in product_ids if pid in products_map]
+            group.productos.set(productos)
+
+            created_groups.append((group, group_code))
+
+        # Combine created and existing groups for word processing
+        all_groups_for_words = created_groups + groups_to_update
+
+        # Delete groups that no longer exist
+        current_group_sets = set(frozenset(pids)
+                                 for pids in group_products_map.values())
+        for product_set, group in existing_groups_map.items():
+            if product_set not in current_group_sets:
+                group.delete()
+
+        # Process words for groups
+        if groups:
+            RatingNappingController.processWordsForGroups(
+                groups, all_groups_for_words
+            )
+    
+    @staticmethod
+    def deleteAllGroups(participation):
+        GrupoProducto.objects.filter(
+            tecnica=participation.tecnica,
+            catador=participation.catador
+        ).delete()
+
+    @staticmethod
+    def processWordsForGroups(groups_data, groups_list):
+        """Process and associate words to groups
+        - Creates words that don't exist
+        - Associates words to GrupoProducto instances
+        - Handles concurrency
+        """
+        # Collect all unique words from all groups
+        all_words = set()
+        for group_id, words in groups_data.items():
+            if words:
+                all_words.update(words)
+
+        if not all_words:
+            # No words to process, just clear existing words from groups
+            for grupo, _ in groups_list:
+                grupo.palabras.clear()
+            return
+
+        # Get existing words
+        existing_words = Palabra.objects.filter(
+            nombre_palabra__in=all_words
+        )
+        existing_words_map = {w.nombre_palabra: w for w in existing_words}
+
+        # Create missing words with concurrency handling
+        word_objects = {}
+        for word_name in all_words:
+            if word_name in existing_words_map:
+                word_objects[word_name] = existing_words_map[word_name]
+            else:
+                word_obj, created = Palabra.objects.get_or_create(
+                    nombre_palabra=word_name
+                )
+                word_objects[word_name] = word_obj
+
+        # Associate words with groups
+        for grupo, group_id in groups_list:
+            words = groups_data.get(group_id, [])
+            if words:
+                words_to_set = [word_objects[word_name]
+                                for word_name in words if word_name in word_objects]
+                grupo.palabras.set(words_to_set)
+            else:
+                grupo.palabras.clear()
+
+    @staticmethod
+    def savePoints(isSorting: bool, products, participation):
+        try:
+            with transaction.atomic():
+                # Get products map for validation
+                products_map = RatingNappingController.getProductsMap(
+                    participation.tecnica)
+
+                # Get existing ratings map
+                existing_ratings_map = RatingNappingController.getExistingRatingsMap(
+                    participation.tecnica, participation.catador)
+
+                if not isSorting:
+                    validation_result = RatingNappingController.validateWords(
+                        products)
+                    if validation_result is not None:
+                        return validation_result
+
+                # Create new ratings for products that don't have them
+                new_ratings = []
+                ids_products = products_map.keys()
+                for item in products:
+                    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)
+
+                # Process DatoPunto instances from products array
+                existing_points_map = RatingNappingController.getExistingPointsMap(
+                    existing_ratings_map.values())
+
+                points_to_create = []
+                points_to_update = []
+
+                for item in products:
+                    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 (existing_ratings_map, products_map)
+
+        except Exception as e:
+            print(e)
+            return JsonResponse({"error": "Error al guardar los puntos"})
+
+    @staticmethod
+    def validateWords(data: list):
+        for item in data:
+            words = item.get("words", [])
+            if words:
+                dic_words = {}
+                for index, word in enumerate(words, start=1):
+                    dic_words[f"palabra_{index}"] = word
+
+                form = ListWordsForm(dic_words, new_words=words)
+                if not form.is_valid():
+                    errors = []
+                    for field, error_list in form.errors.items():
+                        errors.extend(error_list)
+                    return JsonResponse({"error": f"Error en validación de palabras: {', '.join(errors)}"})
+        return None
+
+    @staticmethod
+    def processWordsForRatings(data: list, existing_ratings_map: dict):
+        all_words = set()
+        for item in data:
+            words = item.get("words", [])
+            if words:
+                all_words.update(words)
+
+        if not all_words:
+            return
+
+        existing_words = Palabra.objects.filter(
+            nombre_palabra__in=all_words
+        )
+        existing_words_map = {w.nombre_palabra: w for w in existing_words}
+
+        word_objects = {}
+        for word_name in all_words:
+            if word_name in existing_words_map:
+                word_objects[word_name] = existing_words_map[word_name]
+            else:
+                word_obj, created = Palabra.objects.get_or_create(
+                    nombre_palabra=word_name
+                )
+                word_objects[word_name] = word_obj
+
+        for item in data:
+            words = item.get("words", [])
+            if words:
+                product_id = int(item["idProduct"])
+                rating = existing_ratings_map.get(product_id)
+
+                if rating:
+                    words_to_set = [word_objects[word_name]
+                                    for word_name in words]
+                    rating.palabras.set(words_to_set)
+
+    @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/api_controller/rating_pf_list_controller.py

@@ -0,0 +1,221 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction, IntegrityError
+from tecnicas.models import Palabra, ListaPalabras, Participacion, Calificacion, Producto, Dato, ValorDecimal
+from tecnicas.forms import ListWordsForm
+
+
+class RatingPFListController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def getListWords(request: HttpRequest):
+        participation_current_tester = Participacion.objects.get(
+            id=request.session["id_participation"])
+
+        technique = participation_current_tester.tecnica
+
+        participations_testers = Participacion.objects.exclude(
+            catador=participation_current_tester.catador).filter(tecnica=technique)
+
+        all_testers = [
+            participation.catador for participation in participations_testers]
+
+        list_words_testers = list(ListaPalabras.objects.filter(
+            tecnica=technique, catador__in=all_testers, es_final=True))
+
+        if not list_words_testers:
+            return JsonResponse({"error": "Aun no hay listas finales de Catadores"})
+
+        result = []
+        for list_tester in list_words_testers:
+            try:
+                username = list_tester.catador.user.username
+            except Exception:
+                username = None
+
+            finish = [
+                participation.finalizado for participation in participations_testers if participation.catador.user.username == username][0]
+
+            status = "Lista terminada" if finish else "Lista en proceso"
+
+            words_qs = list_tester.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words,
+                'status': status
+            })
+
+        return JsonResponse({
+            "message": "Listas encontradas",
+            "lists_words": result
+        })
+
+    @staticmethod
+    def saveList(request: HttpRequest, words: list, current_phase: int):
+        dic_words = {}
+        for index, word in enumerate(words, start=1):
+            dic_words[f"palabra_{index}"] = word
+
+        form = ListWordsForm(dic_words, new_words=words)
+
+        if form.is_valid():
+            participation = Participacion.objects.get(
+                id=request.session["id_participation"])
+
+            if not participation:
+                return JsonResponse({"error": "No está autorizado en la sesión"})
+
+            technique = participation.tecnica
+
+            list_words_tester: ListaPalabras
+            if current_phase == 1:
+                (list_words_tester, created) = ListaPalabras.objects.get_or_create(
+                    tecnica=technique,
+                    catador=request.user.user_catador,
+                    es_final=False,
+                )
+            elif current_phase == 2:
+                (list_words_tester, created) = ListaPalabras.objects.get_or_create(
+                    tecnica=technique,
+                    catador=request.user.user_catador,
+                    es_final=True,
+                )
+
+            added_words = RatingPFListController.addWordsToListWordsTester(
+                list_words=words, list_tester=list_words_tester)
+
+            response = JsonResponse({
+                "message": "Palabras guardadas con exito",
+                "words": [word.nombre_palabra for word in added_words]
+            })
+        else:
+            response = JsonResponse({"error": "Palabras invalidas"})
+
+        return response
+
+    @staticmethod
+    def addWordsToListWordsTester(list_words: list[str], list_tester: ListaPalabras):
+        # Normalizar
+        clean_words = [s.strip() for s in list_words if s.strip()]
+
+        # Obtener existentes
+        all_words = Palabra.objects.filter(nombre_palabra__in=clean_words)
+
+        names_words_exist = set(
+            all_words.values_list('nombre_palabra', flat=True))
+
+        # Ejecutar el query para no sumar palabras repetidas
+        all_words = list(all_words)
+
+        # Determinar faltantes
+        missing_words = [
+            nombre for nombre in clean_words if nombre not in names_words_exist]
+        print("No save words", missing_words)
+
+        created_words = []
+
+        # Intentar crear missing_words
+        for nombre in missing_words:
+            try:
+                with transaction.atomic():
+                    palabra, created = Palabra.objects.get_or_create(
+                        nombre_palabra=nombre)
+                    if created:
+                        created_words.append(palabra)
+            except IntegrityError:
+                palabra = Palabra.objects.get(nombre_palabra=nombre)
+                created_words.append(palabra)
+
+        # Combinar todas (all_words + created_words)
+        all_new_words = all_words + created_words
+
+        list_tester.palabras.set(all_new_words)
+
+        return all_new_words
+
+    @staticmethod
+    def saveRatings(request: HttpRequest, word_rating: str, data: list):
+        participation = Participacion.objects.get(
+            id=request.session["id_participation"])
+
+        technique = participation.tecnica
+        products = Producto.objects.filter(id_tecnica=technique)
+
+        # Crear o obtener las instancias Calificacion en la repeticion de todos los producutos
+        ratings = Calificacion.objects.filter(
+            num_repeticion=technique.repeticion,
+            id_tecnica=technique,
+            id_catador=participation.catador,
+            id_producto__in=products
+        )
+
+        existing_dict = {rating.id_producto_id: rating for rating in ratings}
+        to_create = []
+
+        for product in products:
+            if product.id not in existing_dict:
+                to_create.append(
+                    Calificacion(
+                        num_repeticion=technique.repeticion,
+                        id_producto=product,
+                        id_tecnica=technique,
+                        id_catador=participation.catador
+                    )
+                )
+        Calificacion.objects.bulk_create(to_create)
+
+        ratings = Calificacion.objects.filter(
+            num_repeticion=technique.repeticion,
+            id_tecnica=technique,
+            id_catador=participation.catador,
+            id_producto__in=products
+        )
+
+        # Guardar datos con ValorDecimal
+        word = Palabra.objects.get(nombre_palabra=word_rating)
+        try:
+            if (
+                len(data) != len(products) or 
+                len(data) != len(ratings) or 
+                len(products) != len(ratings)
+            ):
+                raise ValueError(
+                    "Al parecer los datos mandados no corresponden con el total de productos")
+
+            product_values = {info["product"]["code"]: info["value"] for info in data}
+
+            datos_to_create = []
+            values_to_create = []
+
+            with transaction.atomic():
+                for rating in ratings:
+                    datos_to_create.append(Dato(
+                        id_palabra=word,
+                        id_calificacion=rating
+                    ))
+
+                datos_save = Dato.objects.bulk_create(datos_to_create)
+                save_data = Dato.objects.filter(id_palabra=word, id_calificacion__in=ratings)
+
+                for data_save in save_data:
+                    values_to_create.append(ValorDecimal(
+                        id_dato=data_save,
+                        valor=product_values.get(data_save.id_calificacion.id_producto.codigoProducto)
+                    ))
+
+                ValorDecimal.objects.bulk_create(values_to_create)
+
+            return JsonResponse({"message": "Calificaciones guardadas con exito"})
+        except ValueError as e:
+            error_message = str(e)
+            print(f"Error de calificacion: {error_message}")
+            return JsonResponse({"error": error_message})

tecnicas/controllers/{views_controller/api_rating_controller.py → api_controller/rating_sacales_controller.py}

@@ -1,8 +1,8 @@
-from ...controllers import CalificacionController, DatoController
+from .. import CalificacionController, DatoController
 from ...utils import controller_error
 
 
-class ApiRatingController():
+class RatingScalesController():
     def __init__(self, rating_controller: CalificacionController, data_controller: DatoController):
         self.rating_controller = rating_controller
         self.data_controller = data_controller

tecnicas/controllers/api_controller/rating_sort_controller.py

@@ -0,0 +1,67 @@
+from django.http import JsonResponse, HttpRequest
+from django.db import transaction
+from tecnicas.models import Participacion, Palabra, GrupoProducto, Producto
+
+
+class RatingSortController():
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def saveRating(request: HttpRequest, data: list[dict]):
+        try:
+            with transaction.atomic():
+                participation = Participacion.objects.get(
+                    id=request.session["id_participation"])
+
+                technique = participation.tecnica
+                catador = participation.catador
+
+                # Obtener productos de la técnica
+                technique_products = Producto.objects.filter(
+                    id_tecnica=technique)
+                technique_product_ids = set(p.id for p in technique_products)
+
+                # Recolectar IDs de productos enviados
+                sent_product_ids = set()
+                for group in data:
+                    for product in group["products"]:
+                        sent_product_ids.add(int(product["id"]))
+
+                # Validar que los productos enviados existan en la técnica
+                if not sent_product_ids.issubset(technique_product_ids):
+                    return JsonResponse({"error": "Productos enviados no pertenecen a la técnica"})
+
+                # Validar que todos los productos de la técnica estén presentes
+                if sent_product_ids != technique_product_ids:
+                    return JsonResponse({"error": "Faltan productos por clasificar"})
+
+                for group in data:
+                    words_data = group["words"]
+                    products_data = group["products"]
+
+                    # Crear u obtener palabras
+                    words_objs = []
+                    for word_name in words_data:
+                        word, created = Palabra.objects.get_or_create(nombre_palabra=word_name)
+                        words_objs.append(word)
+
+                    # Crear GrupoProducto
+                    group_product = GrupoProducto.objects.create(
+                        tecnica=technique,
+                        catador=catador
+                    )
+
+                    # Asignar palabras
+                    group_product.palabras.set(words_objs)
+
+                    # Asignar productos
+                    product_ids = [p["id"] for p in products_data]
+                    group_product.productos.set(product_ids)
+
+            return JsonResponse({"message": "Valores guardados"})
+        except Participacion.DoesNotExist:
+            return JsonResponse({"error": "Participación no encontrada"})
+        except Exception as e:
+            print(f"Error de calificacion: {e}")
+            return JsonResponse({"error": "Error al guardar los datos"})

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -21,7 +21,7 @@ class CalificacionController():
     @staticmethod
     def getRatingsByTechnique(technique: Tecnica):
         repetition = technique.repeticion
-        ratings = list(Calificacion.objects.filter(id_tecnica=technique))
+        ratings = list(Calificacion.objects.filter(id_tecnica=technique, num_repeticion=repetition))
         return ratings
 
     @staticmethod

tecnicas/controllers/models_controller/dato_controller.py

@@ -1,5 +1,5 @@
-from ...models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano, Tecnica
-from ...utils import controller_error, getId
+from tecnicas.models import Calificacion, Dato, Palabra, ValorDecimal, ValorBooleano, Tecnica, Catador
+from tecnicas.utils import controller_error, getId
 from django.core.exceptions import ValidationError
 from django.db.models import F
 
@@ -12,11 +12,7 @@ class DatoController():
         }
 
         self.data = Dato(**atributes)
-
-        if isinstance(value_rating, bool):
-            self.value_data = ValorBooleano(valor=value_rating)
-        else:
-            self.value_data = ValorDecimal(valor=value_rating)
+        self.value_rating = value_rating
 
     def setRating(self, new_rating: Calificacion):
         try:
@@ -39,15 +35,23 @@ class DatoController():
         except ValidationError as e:
             return controller_error(e.message)
 
-    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)
+    def setValue(self):
+        type_technique = self.data.id_calificacion.id_tecnica.tipo_tecnica
+        if type_technique == "cata":
+            self.value_data = ValorBooleano(valor=self.value_rating)
+
         else:
-            self.value_data.id_dato = self.data
+            type_scale = self.data.id_calificacion.id_tecnica.escala_tecnica.id_tipo_escala.nombre_escala
+
+            if type_scale == "continua":
+                decimal_value = self.value_rating/100
+                value_rounded = round(decimal_value)
+                self.value_data = ValorDecimal(valor=value_rounded)
 
+            else:
+                self.value_data = ValorDecimal(valor=self.value_rating)
+
+        self.value_data.id_dato = self.data
         return self.value_data
 
     def saveValue(self):
@@ -94,3 +98,21 @@ class DatoController():
         )
 
         return list(result)
+
+    @staticmethod
+    def getWordValuesPF(technique: Tecnica, ratings: list[Calificacion], tester: Catador):
+        ids_ratings = [rat.id for rat in ratings]
+
+        result = (
+            ValorDecimal.objects
+            .filter(id_dato__id_calificacion_id__in=ids_ratings, id_dato__id_calificacion__id_catador=tester)
+            .values(
+                nombre_palabra=F("id_dato__id_palabra__nombre_palabra"),
+                repeticion=F("id_dato__id_calificacion__num_repeticion"),
+                producto_code=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+                dato_valor=F("valor")
+            )
+        )
+
+        return list(result)

tecnicas/controllers/models_controller/escala_controller.py

@@ -7,19 +7,25 @@ class EscalaController():
     scale: Escala
     tags_relation: dict[str, EtiquetasEscala]
 
-    def __init__(self, data):
-        self.scale = Escala(
-            id_tipo_escala=TipoEscala.objects.get(id=data["id_scale"]),
-            longitud=data["size"],
-            tecnica=data["technique"]
-        )
-
-    def setScale(self, newData):
-        self.scale = Escala(
-            id_tipo_escala=TipoEscala.objects.get(id=newData["id_scale"]),
-            longitud=newData["size"],
-            tecnica=newData["technique"]
-        )
+    def __init__(self, data, use_scale: Escala = None):
+        if use_scale:
+            self.scale = use_scale
+        else:
+            self.scale = Escala(
+                id_tipo_escala=TipoEscala.objects.get(id=data["id_scale"]),
+                longitud=data["size"],
+                tecnica=data["technique"]
+            )
+
+    def setScale(self, newData, use_scale: Escala):
+        if use_scale:
+            self.scale = use_scale
+        else:
+            self.scale = Escala(
+                id_tipo_escala=TipoEscala.objects.get(id=data["id_scale"]),
+                longitud=data["size"],
+                tecnica=data["technique"]
+            )
 
     def saveScale(self):
         try:

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -35,24 +35,14 @@ class ParticipacionController():
             return controller_error("No se ha encontrado la participación")
 
     @staticmethod
-    def outAllInSession(session: SesionSensorial | str):
+    def outAllInSession(session: SesionSensorial):
         try:
-            if isinstance(session, str):
-                use_session = SesionSensorial.objects.get(
-                    codigo_sesion=session)
-            else:
-                use_session = session
-
             participations = Participacion.objects.filter(
-                tecnica=use_session.tecnica)
-
-            if not participations.exists():
-                message = "No se encontraron participaciones en la sesión"
-                return (False, message)
+                tecnica=session.tecnica)
 
             participations.update(finalizado=False)
 
-            message = "Participaciones actualizadas a finalizadas"
+            message = "Participaciones actualizadas a finalizadas como falso"
             return (True, message)
         except Exception as e:
             print(f"Error al actualizar las participaciones: {str(e)}")

tecnicas/controllers/models_controller/sesion_controller.py

@@ -125,12 +125,7 @@ class SesionController():
             return controller_error("Presentador invalido")
 
     @staticmethod
-    def finishRepetion(session: SesionSensorial | str):
-        if isinstance(session, str):
-            use_session = SesionSensorial.objects.get(codigo_sesion=session)
-        else:
-            use_session = session
-
-        use_session.activo = False
-        use_session.save()
+    def finishRepetion(session: SesionSensorial):
+        session.activo = False
+        session.save()
         return session

tecnicas/controllers/models_controller/tecnica_controller.py

@@ -16,7 +16,7 @@ class TecnicaController():
     def setTechniqueFromBasicData(self, basic):
         self.technique = Tecnica(
             tipo_tecnica=TipoTecnica.objects.get(nombre_tecnica=basic["name_tecnica"]),
-            id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
+            id_estilo=EstiloPalabra.objects.get(nombre_estilo=basic["estilo_palabras"]),
             repeticiones_max=basic["numero_repeticiones"] or 1,
             limite_catadores=basic["numero_catadores"],
             instrucciones=basic["instrucciones"] or "Espere instrucciones del Presentador",

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -1,4 +1,4 @@
-from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm
+from tecnicas.forms import SesionBasicForm, SesionBasicCATAForm, SesionBasicPFForm, SesionBasicSortForm, SesionBasicNappingForm
 from django.http import HttpRequest
 from django.shortcuts import redirect, render
 from django.urls import reverse
@@ -10,11 +10,14 @@ class PanelBasicController():
         "numero_repeticiones": 1
     }
 
-    url_panel_basic = "tecnicas/create_sesion/configuracion-panel-basic.html"
+    url_panel_basic = "tecnicas/create_sesion/conf-panel-basic.html"
     url_panel_basic_cata = "tecnicas/create_sesion/panel-basic-cata.html"
+    url_panel_basic_pf = "tecnicas/create_sesion/panel-basic-pf.html"
+    url_panel_basic_sort = "tecnicas/create_sesion/panel-basic-sort.html"
+    url_panel_basic_napping = "tecnicas/create_sesion/panel-basic-napping.html"
 
-    url_next_panel_scales = "cata_system:panel_configuracion_tags"
-    url_next_panel_cata = "cata_system:panel_configuracion_codes"
+    url_next_panel_tags = "cata_system:panel_configuracion_tags"
+    url_next_panel_codes = "cata_system:panel_configuracion_codes"
 
     url_select_technique = "cata_system:seleccion_tecnica"
 
@@ -42,7 +45,7 @@ class PanelBasicController():
             if form.is_valid():
                 values = {}
                 for name, value in form.cleaned_data.items():
-                    if name == "estilo_palabras" or name == "tipo_escala":
+                    if name == "tipo_escala":
                         values[name] = value.id
                     else:
                         values[name] = value
@@ -50,7 +53,7 @@ class PanelBasicController():
                 values["name_tecnica"] = name_tecnica
                 request.session['form_basic'] = values
                 response = redirect(
-                    reverse("cata_system:panel_configuracion_tags"))
+                    reverse(PanelBasicController.url_next_panel_tags))
             else:
                 response = render(request, PanelBasicController.url_panel_basic, {
                     "form_sesion": form, "error": "Información no valida"})
@@ -83,7 +86,7 @@ class PanelBasicController():
             if form.is_valid():
                 values = {}
                 for name, value in form.cleaned_data.items():
-                    if name == "estilo_palabras" or name == "tipo_escala":
+                    if name == "tipo_escala":
                         values[name] = value.id
                     else:
                         values[name] = value
@@ -102,7 +105,7 @@ class PanelBasicController():
                     values["name_tecnica"] = name_tecnica
                     request.session['form_basic'] = values
                     response = redirect(
-                        reverse("cata_system:panel_configuracion_tags"))
+                        reverse(PanelBasicController.url_next_panel_tags))
             else:
                 response = render(request, PanelBasicController.url_panel_basic, {
                     "form_sesion": form, "error": "Información no valida"})
@@ -131,17 +134,107 @@ class PanelBasicController():
         if form.is_valid():
             values = {}
             for name, value in form.cleaned_data.items():
-                if name == "estilo_palabras":
-                    values[name] = value.id
-                else:
-                    values[name] = value
+                values[name] = value
 
             values["name_tecnica"] = name_tecnica
             request.session['form_basic'] = values
             response = redirect(
-                reverse(PanelBasicController.url_next_panel_cata))
+                reverse(PanelBasicController.url_next_panel_codes))
         else:
             response = render(request, PanelBasicController.url_panel_basic, {
                 "form_sesion": form, "error": "Información no valida"})
 
         return response
+
+    @staticmethod
+    def controllGetPF(request: HttpRequest):
+        form_sesion = SesionBasicPFForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "perfil flash"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_pf, view_context)
+
+    @staticmethod
+    def controllPostPF(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicPFForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_pf, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response
+
+    @staticmethod
+    def controllGetSort(request: HttpRequest):
+        form_sesion = SesionBasicSortForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "sort"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_sort, view_context)
+
+    @staticmethod
+    def controllPostSort(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicSortForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_sort, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response
+
+    @staticmethod
+    def controllGetNapping(request: HttpRequest):
+        form_sesion = SesionBasicNappingForm()
+
+        view_context = {
+            "form_sesion": form_sesion,
+            "use_technique": "napping"
+        }
+
+        return render(
+            request, PanelBasicController.url_panel_basic_napping, view_context)
+
+    @staticmethod
+    def controllPostNapping(request: HttpRequest, name_tecnica: str):
+        form = SesionBasicNappingForm(request.POST)
+
+        if form.is_valid():
+            values = {}
+            for name, value in form.cleaned_data.items():
+                values[name] = value
+
+            values["name_tecnica"] = name_tecnica
+            request.session['form_basic'] = values
+            response = redirect(
+                reverse(PanelBasicController.url_next_panel_codes))
+        else:
+            response = render(request, PanelBasicController.url_panel_basic_napping, {
+                "form_sesion": form, "error": "Información no valida"})
+
+        return response

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -7,8 +7,9 @@ import json
 
 
 class PanelCodesController():
-    url_current_panel = "tecnicas/create_sesion/configuracion-panel-codes.html"
-    url_next_panel = "cata_system:panel_configuracion_words"
+    url_current_panel = "tecnicas/create_sesion/conf-panel-codes.html"
+    url_words = "cata_system:panel_configuracion_words"
+    url_create_session = "cata_system:creando_sesion"
 
     def __init__(self):
         pass
@@ -58,14 +59,14 @@ class PanelCodesController():
 
             codes_sort["sort_codes"] = sorts_code
             request.session["form_codes"] = codes_sort
-            return redirect(reverse(PanelCodesController.url_next_panel))
+            return redirect(reverse(PanelCodesController.url_words))
         else:
             context_codes_form["error"] = "error en los datos recibidos"
 
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllGetRATA(request: HttpRequest, data):
+    def controllGetWithoutOrders(request: HttpRequest, data, name_technique: str):
         num_products = data["numero_productos"]
         codes_products = generarCodigos(num_products)
         form_codes = CodesForm(codes=codes_products)
@@ -73,13 +74,13 @@ class PanelCodesController():
         context_codes_form = {
             "form_codes": form_codes,
             "num_tester": 0,
-            "use_technique": "rata"
+            "use_technique": name_technique
         }
 
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllPostRATA(request: HttpRequest, is_rata: True):
+    def controllPostWithWords(request: HttpRequest, name_technique: str):
         codes = []
         context_codes_form = {}
 
@@ -91,12 +92,14 @@ class PanelCodesController():
 
         context_codes_form = {
             "form_codes": form_codes,
-            "use_technique": "rata" if is_rata else "cata"
+            "use_technique": name_technique
         }
 
         if form_codes.is_valid():
-            request.session["form_codes"] = codes
-            return redirect(reverse(PanelCodesController.url_next_panel))
+            # Extract codes from cleaned_data to ensure uppercase conversion
+            cleaned_codes = [value for name, value in form_codes.cleaned_data.items() if name.startswith('producto_')]
+            request.session["form_codes"] = cleaned_codes
+            return redirect(reverse(PanelCodesController.url_words))
         else:
             context_codes_form["error"] = "error en los datos recibidos"
 
@@ -114,3 +117,29 @@ class PanelCodesController():
         }
 
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
+
+    @staticmethod
+    def controllPostWithoutOrdersWords(request: HttpRequest, name_technique: str):
+        codes = []
+        context_codes_form = {}
+
+        for name, value in request.POST.items():
+            if name.__contains__("producto_"):
+                codes.append(value)
+
+        form_codes = CodesForm(request.POST, codes=codes)
+
+        context_codes_form = {
+            "form_codes": form_codes,
+            "use_technique": name_technique
+        }
+
+        if form_codes.is_valid():
+            # Extract codes from cleaned_data to ensure uppercase conversion
+            cleaned_codes = [value for name, value in form_codes.cleaned_data.items() if name.startswith('producto_')]
+            request.session["form_codes"] = cleaned_codes
+            return redirect(reverse(PanelCodesController.url_create_session))
+        else:
+            context_codes_form["error"] = "error en los datos recibidos"
+
+        return render(request, PanelCodesController.url_current_panel, context_codes_form)

tecnicas/controllers/views_controller/create_session/panel_tags_controller.py

@@ -25,7 +25,7 @@ class PanelTagsController():
             "form_new_tag": form_new_etiqueta
         }
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+        return render(request, "tecnicas/create_sesion/conf-panel-tags.html", context_tags)
 
     @staticmethod
     def controllPostEscalas(request: HttpRequest, data):
@@ -54,7 +54,7 @@ class PanelTagsController():
         else:
             context_tags["error"] = "ha ocurrido un error"
             response = render(
-                request, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+                request, "tecnicas/create_sesion/conf-panel-tags.html", context_tags)
 
         return response
 

tecnicas/controllers/views_controller/create_session/panel_words_controller.py

@@ -7,7 +7,7 @@ import json
 
 
 class PanelWordsController():
-    current_url_escalas_atribute = "tecnicas/create_sesion/configuracion-panel-words.html"
+    current_url_escalas_atribute = "tecnicas/create_sesion/conf-panel-words.html"
     current_url_escalas_vocabulary = "tecnicas/create_sesion/conf-panel-vocabulary.html"
 
     def __init__(self):

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_cata_controller.py

@@ -0,0 +1,137 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import EsVocabulario, Tecnica, TipoTecnica, EstiloPalabra, EsAtributo, Vocabulario, Palabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateCataController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_codes") or not request.session.get("form_words"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = 0
+                    data_basic["numero_repeticiones"] = 1
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo=data_basic["estilo_palabras"]),
+                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+
+                    if style_words == "atributos":
+                        raw_ids_words = request.session["form_words"]
+                        ids_words = [int(id_w) for id_w in raw_ids_words]
+
+                        words = Palabra.objects.filter(id__in=ids_words)
+
+                        style_atribute = EsAtributo.objects.create(
+                            id_tecnica=technique
+                        )
+
+                        if not style_atribute:
+                            raise ValueError(
+                                "Error al intentar relacionar las palabras con la técnica")
+
+                        style_atribute.palabras.set(words)
+
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        try:
+                            vocabulary = Vocabulario.objects.get(
+                                nombre_vocabulario=name_vocabulary)
+                        except Vocabulario.DoesNotExist:
+                            raise ValueError("Vocabulario no encontrado")
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                        if not es_vocabulary:
+                            raise ValueError(
+                                "Error al intentar relacionar el vocabulario con la técnica")
+
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_controller.py

@@ -0,0 +1,17 @@
+from django.http import JsonResponse, HttpRequest
+from django.shortcuts import render
+
+class PanelCreateController():
+    url_template = 'tecnicas/create_sesion/creating_session.html'
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def controllGet(request: HttpRequest):
+        return render(
+            request, PanelCreateController.url_template)
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        return JsonResponse({"message": "Método no permitido"})

tecnicas/controllers/views_controller/create_session/{panel_create_controller.py → panels_create/panel_create_escalas_controller.py}

@@ -1,23 +1,17 @@
+from .panel_create_controller import PanelCreateController
 from django.http import HttpRequest, JsonResponse
 from django.db import transaction
-from django.shortcuts import render
-from tecnicas.utils import general_error
-from tecnicas.models import EsAtributo, EsVocabulario, Vocabulario, Tecnica, TipoTecnica, EstiloPalabra, Producto, Palabra, SesionSensorial
-from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
-from tecnicas.utils import deleteDataSession
+from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, PalabrasController, EstiloPalabrasController, SesionController
+from tecnicas.models import EsVocabulario, Vocabulario
+from tecnicas.utils import deleteDataSession, general_error
 
 
-class PanelCreateController():
+class PanelCreateEscalasController(PanelCreateController):
     def __init__(self):
-        pass
+        super().__init__()
 
     @staticmethod
-    def controllGetEscalas(request: HttpRequest):
-        return render(
-            request, 'tecnicas/create_sesion/creando_sesion.html')
-
-    @staticmethod
-    def controllPostEscalas(request: HttpRequest):
+    def controllPost(request: HttpRequest):
         if request.POST.get('action') == 'create_session':
             if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
                 deleteDataSession(request)
@@ -173,274 +167,3 @@ class PanelCreateController():
                 return general_error(f"Error: {e}")
         else:
             return general_error("No se ha establecido acción")
-
-    @staticmethod
-    def controllPostRATA(request: HttpRequest):
-        if request.POST.get('action') == 'create_session':
-            if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
-                deleteDataSession(request)
-                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
-            try:
-                with transaction.atomic():
-                    # ////////////////////////////////////////////////////// #
-                    #
-                    # First step: Create technique and scale with their tags #
-                    #
-                    # ////////////////////////////////////////////////////// #
-                    data_basic = request.session["form_basic"]
-                    data_basic["numero_catadores"] = 0
-                    data_basic["numero_repeticiones"] = 1
-
-                    technique = Tecnica.objects.create(
-                        tipo_tecnica=TipoTecnica.objects.get(
-                            nombre_tecnica=data_basic["name_tecnica"]),
-                        id_estilo=EstiloPalabra.objects.get(
-                            id=data_basic["estilo_palabras"]),
-                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
-                        limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
-                    )
-
-                    if not technique:
-                        raise ValueError("Error al guardar la técnica")
-
-                    data_scale = {
-                        "id_scale": data_basic["tipo_escala"],
-                        "size": data_basic["tamano_escala"],
-                        "technique": technique
-                    }
-
-                    controllerScale = EscalaController(data=data_scale)
-
-                    scale = controllerScale.saveScale()
-                    if isinstance(scale, dict):
-                        raise ValueError(scale["error"])
-
-                    dict_tags = request.session["form_tags"]
-                    saved_related_tags = controllerScale.realteTags(dict_tags)
-                    if "error" in saved_related_tags:
-                        raise ValueError(saved_related_tags["error"])
-
-                    # ////////////////////////////////////////////// #
-                    #
-                    # Second step: Create productos with their codes #
-                    #
-                    # ////////////////////////////////////////////// #
-                    codes = request.session["form_codes"]
-
-                    if not codes:
-                        raise ValueError("No hay códigos de productos")
-
-                    products_without_save = []
-                    for code in codes:
-                        product = Producto(
-                            codigoProducto=code,
-                            id_tecnica=technique
-                        )
-                        products_without_save.append(product)
-
-                    Producto.objects.bulk_create(products_without_save)
-
-                    # /////////////////////////////////////////////////////// #
-                    #
-                    # Third step: Create relations technique with Words Style #
-                    #
-                    # /////////////////////////////////////////////////////// #
-                    style_words = technique.id_estilo.nombre_estilo
-
-                    if style_words == "atributos":
-                        raw_ids_words = request.session["form_words"]
-                        ids_words = [int(id_w) for id_w in raw_ids_words]
-
-                        words = Palabra.objects.filter(id__in=ids_words)
-
-                        style_atribute = EsAtributo.objects.create(
-                            id_tecnica=technique
-                        )
-
-                        if not style_atribute:
-                            raise ValueError(
-                                "Error al intentar relacionar las palabras con la técnica")
-
-                        style_atribute.palabras.set(words)
-
-                    elif style_words == "vocabulario":
-                        name_vocabulary = request.session["form_words"]
-                        try:
-                            vocabulary = Vocabulario.objects.get(
-                                nombre_vocabulario=name_vocabulary)
-                        except Vocabulario.DoesNotExist:
-                            raise ValueError("Vocabulario no encontrado")
-
-                        es_vocabulary = EsVocabulario.objects.create(
-                            id_tecnica=technique,
-                            id_vocabulario=vocabulary
-                        )
-                        if not es_vocabulary:
-                            raise ValueError(
-                                "Error al intentar relacionar el vocabulario con la técnica")
-
-                    else:
-                        raise ValueError("Estilo de palabas no permitido")
-
-                    # //////////////////////////////////////////////////////// #
-                    #
-                    # Fourth step: Create session and relat with the technique #
-                    #
-                    # //////////////////////////////////////////////////////// #
-                    session = SesionSensorial.objects.create(
-                        name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                        technique=technique,
-                        creator=request.user.user_presentador
-                    )
-
-                    if not session:
-                        raise ValueError("Error al crear sesion sensorial")
-
-                    context = {
-                        "message": "sesión creada",
-                        "data": {
-                            "codigo_sesion": session.codigo_sesion,
-                            "nombre_sesion": session.nombre_sesion
-                        }
-                    }
-
-                    # ////////////////////////////////// #
-                    #
-                    # Final step: Delete date en session #
-                    #
-                    # ////////////////////////////////// #
-
-                    deleteDataSession(request)
-                    return JsonResponse(context)
-            except ValueError as e:
-                return general_error(f"Error: {e}")
-        else:
-            return general_error("No se ha establecido acción")
-
-    @staticmethod
-    def controllPostCATA(request: HttpRequest):
-        if request.POST.get('action') == 'create_session':
-            if not request.session.get("form_codes") or not request.session.get("form_words"):
-                deleteDataSession(request)
-                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
-            try:
-                with transaction.atomic():
-                    # //////////////////////////// #
-                    #
-                    # First step: Create technique #
-                    #
-                    # //////////////////////////// #
-                    data_basic = request.session["form_basic"]
-                    data_basic["numero_catadores"] = 0
-                    data_basic["numero_repeticiones"] = 1
-
-                    technique = Tecnica.objects.create(
-                        tipo_tecnica=TipoTecnica.objects.get(
-                            nombre_tecnica=data_basic["name_tecnica"]),
-                        id_estilo=EstiloPalabra.objects.get(
-                            id=data_basic["estilo_palabras"]),
-                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
-                        limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
-                    )
-
-                    if not technique:
-                        raise ValueError("Error al guardar la técnica")
-
-                    # ////////////////////////////////////////////// #
-                    #
-                    # Second step: Create productos with their codes #
-                    #
-                    # ////////////////////////////////////////////// #
-                    codes = request.session["form_codes"]
-
-                    if not codes:
-                        raise ValueError("No hay códigos de productos")
-
-                    products_without_save = []
-                    for code in codes:
-                        product = Producto(
-                            codigoProducto=code,
-                            id_tecnica=technique
-                        )
-                        products_without_save.append(product)
-
-                    Producto.objects.bulk_create(products_without_save)
-
-                    # /////////////////////////////////////////////////////// #
-                    #
-                    # Third step: Create relations technique with Words Style #
-                    #
-                    # /////////////////////////////////////////////////////// #
-                    style_words = technique.id_estilo.nombre_estilo
-
-                    if style_words == "atributos":
-                        raw_ids_words = request.session["form_words"]
-                        ids_words = [int(id_w) for id_w in raw_ids_words]
-
-                        words = Palabra.objects.filter(id__in=ids_words)
-
-                        style_atribute = EsAtributo.objects.create(
-                            id_tecnica=technique
-                        )
-
-                        if not style_atribute:
-                            raise ValueError(
-                                "Error al intentar relacionar las palabras con la técnica")
-
-                        style_atribute.palabras.set(words)
-
-                    elif style_words == "vocabulario":
-                        name_vocabulary = request.session["form_words"]
-                        try:
-                            vocabulary = Vocabulario.objects.get(
-                                nombre_vocabulario=name_vocabulary)
-                        except Vocabulario.DoesNotExist:
-                            raise ValueError("Vocabulario no encontrado")
-
-                        es_vocabulary = EsVocabulario.objects.create(
-                            id_tecnica=technique,
-                            id_vocabulario=vocabulary
-                        )
-                        if not es_vocabulary:
-                            raise ValueError(
-                                "Error al intentar relacionar el vocabulario con la técnica")
-
-                    else:
-                        raise ValueError("Estilo de palabas no permitido")
-
-                    # //////////////////////////////////////////////////////// #
-                    #
-                    # Fourth step: Create session and relat with the technique #
-                    #
-                    # //////////////////////////////////////////////////////// #
-                    session = SesionSensorial.objects.create(
-                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                        tecnica=technique,
-                        creadoPor=request.user.user_presentador
-                    )
-
-                    if not session:
-                        raise ValueError("Error al crear sesion sensorial")
-
-                    context = {
-                        "message": "sesión creada",
-                        "data": {
-                            "codigo_sesion": session.codigo_sesion,
-                            "nombre_sesion": session.nombre_sesion
-                        }
-                    }
-
-                    # ////////////////////////////////// #
-                    #
-                    # Final step: Delete date en session #
-                    #
-                    # ////////////////////////////////// #
-                    deleteDataSession(request)
-                    return JsonResponse(context)
-
-            except ValueError as e:
-                return general_error(f"Error: {e}")
-        else:
-            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_napping_controller.py

@@ -0,0 +1,114 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, Producto, SesionSensorial, Modalidad, TecnicaModalidad
+from django.db import transaction
+from tecnicas.utils import deleteDataSession
+
+
+class PanelCreateNappingController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_basic") or not request.session.get("form_codes"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = data_basic["numero_catadores"] or 2
+                    data_basic["numero_repeticiones"] = 0
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="napping"),
+                        repeticiones_max=data_basic["numero_repeticiones"],
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    mod = Modalidad.objects.get(
+                        nombre=data_basic["modalidad"])
+
+                    if not mod:
+                        raise ValueError("Modalidad no encontrada")
+
+                    technique_mod = TecnicaModalidad.objects.create(
+                        tecnica=technique,
+                        modalidad=mod
+                    )
+
+                    if not technique_mod:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_pf_controller.py

@@ -0,0 +1,105 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, SesionSensorial, Escala, TipoEscala, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreatePFController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_codes"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+            try:
+                with transaction.atomic():
+                    # ////////////////////////////////////// #
+                    #
+                    # First step: Create technique and scale #
+                    #
+                    # ////////////////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    phases_before_reptition = 2
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="perfil flash"),
+                        repeticiones_max=data_basic["numero_repeticiones"] +
+                        phases_before_reptition,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Analista",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    created_scale = Escala.objects.create(
+                        id_tipo_escala=TipoEscala.objects.get(
+                            nombre_escala="estructurada"),
+                        longitud=data_basic["numero_productos"],
+                        tecnica=technique
+                    )
+
+                    if not created_scale:
+                        raise ValueError("No se ha podido crear la escala")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_rata_controller.py

@@ -0,0 +1,155 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.controllers import EscalaController
+from tecnicas.models import EsVocabulario, Tecnica, TipoTecnica, EstiloPalabra, EsAtributo, Vocabulario, Palabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateRataController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+            try:
+                with transaction.atomic():
+                    # ////////////////////////////////////////////////////// #
+                    #
+                    # First step: Create technique and scale with their tags #
+                    #
+                    # ////////////////////////////////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = 0
+                    data_basic["numero_repeticiones"] = 1
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo=data_basic["estilo_palabras"]),
+                        repeticiones_max=data_basic["numero_repeticiones"] or 1,
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    data_scale = {
+                        "id_scale": data_basic["tipo_escala"],
+                        "size": data_basic["tamano_escala"],
+                        "technique": technique
+                    }
+
+                    controllerScale = EscalaController(data=data_scale)
+
+                    scale = controllerScale.saveScale()
+                    if isinstance(scale, dict):
+                        raise ValueError(scale["error"])
+
+                    dict_tags = request.session["form_tags"]
+                    saved_related_tags = controllerScale.realteTags(dict_tags)
+                    if "error" in saved_related_tags:
+                        raise ValueError(saved_related_tags["error"])
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+
+                    if style_words == "atributos":
+                        raw_ids_words = request.session["form_words"]
+                        ids_words = [int(id_w) for id_w in raw_ids_words]
+
+                        words = Palabra.objects.filter(id__in=ids_words)
+
+                        style_atribute = EsAtributo.objects.create(
+                            id_tecnica=technique
+                        )
+
+                        if not style_atribute:
+                            raise ValueError(
+                                "Error al intentar relacionar las palabras con la técnica")
+
+                        style_atribute.palabras.set(words)
+
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        try:
+                            vocabulary = Vocabulario.objects.get(
+                                nombre_vocabulario=name_vocabulary)
+                        except Vocabulario.DoesNotExist:
+                            raise ValueError("Vocabulario no encontrado")
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                        if not es_vocabulary:
+                            raise ValueError(
+                                "Error al intentar relacionar el vocabulario con la técnica")
+
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else "",
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panels_create/panel_create_sort_controller.py

@@ -0,0 +1,95 @@
+from .panel_create_controller import PanelCreateController
+from django.http import HttpRequest, JsonResponse
+from django.db import transaction
+from tecnicas.models import Tecnica, TipoTecnica, EstiloPalabra, SesionSensorial, Producto
+from tecnicas.utils import deleteDataSession, general_error
+
+
+class PanelCreateSortController(PanelCreateController):
+    def __init__(self):
+        super().__init__()
+
+    @staticmethod
+    def controllPost(request: HttpRequest):
+        if request.POST.get('action') == 'create_session':
+            if not request.session.get("form_basic") or not request.session.get("form_codes"):
+                deleteDataSession(request)
+                return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
+            try:
+                with transaction.atomic():
+                    # //////////////////////////// #
+                    #
+                    # First step: Create technique #
+                    #
+                    # //////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = data_basic["numero_catadores"] or 1
+                    data_basic["numero_repeticiones"] = 1
+
+                    technique = Tecnica.objects.create(
+                        tipo_tecnica=TipoTecnica.objects.get(
+                            nombre_tecnica=data_basic["name_tecnica"]),
+                        id_estilo=EstiloPalabra.objects.get(
+                            nombre_estilo="sort"),
+                        repeticiones_max=data_basic["numero_repeticiones"],
+                        limite_catadores=data_basic["numero_catadores"],
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                    )
+
+                    if not technique:
+                        raise ValueError("Error al guardar la técnica")
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    if not codes:
+                        raise ValueError("No hay códigos de productos")
+
+                    products_without_save = []
+                    for code in codes:
+                        product = Producto(
+                            codigoProducto=code,
+                            id_tecnica=technique
+                        )
+                        products_without_save.append(product)
+
+                    Producto.objects.bulk_create(products_without_save)
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create session and relat with the technique #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    session = SesionSensorial.objects.create(
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
+                    )
+
+                    if not session:
+                        raise ValueError("Error al crear sesion sensorial")
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": session.codigo_sesion,
+                            "nombre_sesion": session.nombre_sesion
+                        }
+                    }
+
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+
+            except ValueError as e:
+                return general_error(f"Error: {e}")
+        else:
+            return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/session_management/{details_rata_controller.py → details/details_cata_controller.py}

@@ -1,48 +1,60 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from tecnicas.models import SesionSensorial
-from tecnicas.controllers import PalabrasController, DatoController, CalificacionController
+from django.db.models import F
+from tecnicas.models import SesionSensorial, Calificacion, ValorBooleano
+from tecnicas.controllers import PalabrasController
 from tecnicas.utils import defaultdict_to_dict
 from .details_controller import DetallesController
 from collections import defaultdict
 
 
-class DetallesRATAController(DetallesController):
+class DetallesCATAController(DetallesController):
     def __init__(self, session: SesionSensorial):
         super().__init__(session)
-
-    def getResponse(self, request: HttpRequest, error: str = ""):
-        context = self.getContext()
-        if error != "" or error:
-            context["error"] = error
-        return render(
-            request, self.url_template, context)
+        self.url_template = "tecnicas/manage_sesions/details-session-cata.html"
+        self.url_next = "cata_system:monitor_sesion"
 
     def getContext(self):
-        self.context = {}
-        self.context["sesion"] = self.session
+        technique = self.session.tecnica
+
+        self.context = {
+            "sesion": self.session,
+            "use_technique": technique
+        }
+
+        # Recuperar palabras
         self.words = PalabrasController.getWordsInTechnique(
             self.session.tecnica)
         self.context["palabras"] = [word.nombre_palabra for word in self.words]
 
+        # Intentar recuperar las calificaciones
         ratings_for_repetition = []
 
-        ratings = CalificacionController.getRatingsByTechnique(
-            technique=self.session.tecnica)
+        ratings = list(Calificacion.objects.filter(
+            id_tecnica=technique))
 
-        if isinstance(ratings, dict) or not ratings:
+        if not ratings:
             self.context["calificaciones"] = ratings_for_repetition
             self.context["existen_calificaciones"] = False
             return self.context
 
-        data = DatoController.getWordValuesForConvecional(
-            ratings=ratings, technique=self.session.tecnica)
+        data = (
+            ValorBooleano.objects
+            .filter(id_dato__id_calificacion__in=ratings)
+            .values(
+                nombre_palabra=F("id_dato__id_palabra__nombre_palabra"),
+                repeticion=F("id_dato__id_calificacion__num_repeticion"),
+                producto_code=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+                usuario_catador=F(
+                    "id_dato__id_calificacion__id_catador__user__username"),
+                dato_valor=F("valor")
+            )
+        )
 
         ratings_for_repetition = defaultdict(
             lambda: defaultdict(lambda: defaultdict(list)))
 
         for item in data:
-            user = item["usuarioCatador"]
+            user = item["usuario_catador"]
             rep = item["repeticion"]
             prod = item["producto_code"]
 
@@ -54,3 +66,7 @@ class DetallesRATAController(DetallesController):
         self.context["calificaciones"] = defaultdict_to_dict(
             ratings_for_repetition)
         self.context["existen_calificaciones"] = True
+
+        # Se comprueba que ya no se pueda iniciar la repeticion
+        self.context["fin_repeticiones"] = technique.repeticion >= technique.repeticiones_max
+        return self.context

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

@@ -0,0 +1,70 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Presentador, Tecnica, Participacion
+from tecnicas.controllers import ParticipacionController
+
+
+class DetallesController():
+    url_template: str
+    url_next = "cata_system:monitor_sesion"
+
+    def __init__(self, session: SesionSensorial):
+        self.session = session
+
+    def controllGetResponse(self, request: HttpRequest, error: str = "", message: str = ""):
+        context = self.getContext()
+
+        if error != "" or error:
+            context["error"] = error
+        if message != "" or message:
+            context["message"] = message
+
+        return render(
+            request, self.url_template, context)
+
+    def getContext(self):
+        return {}
+
+    def deleteSesorialSession(self):
+        technique = Tecnica.objects.get(id=self.session.tecnica.id)
+        technique.delete()
+
+    def startRepetition(self, presenter: Presentador, request: HttpRequest):
+        creator = presenter
+        technique = self.session.tecnica
+
+        if creator.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)
+        elif technique.repeticion >= technique.repeticiones_max:
+            return self.controllGetResponse(error="Se ha alcanzado el número de repeticiones máxima", request=request)
+
+        is_update_participations = self.setParticipationsToNoFinished()
+        if not is_update_participations:
+            return self.controllGetResponse(error="Error al actualizar las participaciones", request=request)
+
+        self.session.activo = True
+        technique.repeticion = technique.repeticion + 1
+
+        technique.save()
+        self.session.save()
+
+        parameters = {
+            "session_code": self.session.codigo_sesion
+        }
+        return redirect(
+            reverse(self.url_next, kwargs=parameters))
+
+    def setParticipationsToNoFinished(self):
+        there_participacions = Participacion.objects.filter(
+            tecnica=self.session.tecnica).exists()
+
+        if there_participacions:
+            (is_update_participations,
+             message) = ParticipacionController.outAllInSession(self.session)
+
+            return is_update_participations
+
+        return True

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

@@ -11,40 +11,26 @@ Encabezados de como deben de aparecer los datos juntos
 | Repeticion | Codigo Producto | Catador | P1 | P2 | P3 | Pn |
 
 '''
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from django.urls import reverse
-from tecnicas.models import SesionSensorial, Presentador, Participacion, Calificacion, Escala
-from tecnicas.controllers import DatoController, PalabrasController, ParticipacionController
+from tecnicas.models import SesionSensorial, Calificacion, Escala
+from tecnicas.controllers import DatoController, PalabrasController
 from .details_controller import DetallesController
-from tecnicas.utils import defaultdict_to_dict, controller_error
+from tecnicas.utils import defaultdict_to_dict
 from collections import defaultdict
 
 
 class DetallesEscalasController(DetallesController):
-    url_template = "tecnicas/manage_sesions/detalles-sesion.html"
-
     def __init__(self, session: SesionSensorial):
         super().__init__(session)
-
-    def getResponse(self, request: HttpRequest, error: str = "", message: str = ""):
-        context = self.getContext()
-
-        if error != "" or error:
-            context["error"] = error
-        if message != "" or message:
-            context["message"] = message
-
-        return render(
-            request, self.url_template, context)
+        self.url_template = "tecnicas/manage_sesions/details-session.html"
+        self.url_next = "cata_system:monitor_sesion"
 
     def getContext(self):
+        technique = self.session.tecnica
+
         self.context = {
-            "use_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+            "sesion": self.session,
+            "use_technique": technique.tipo_tecnica.nombre_tecnica
         }
-        self.context["sesion"] = self.session
-
-        technique = self.session.tecnica
 
         # Datos de la escala usada
         scale: Escala = technique.escala_tecnica
@@ -94,35 +80,3 @@ class DetallesEscalasController(DetallesController):
         self.context["fin_repeticiones"] = technique.repeticion >= technique.repeticiones_max
 
         return self.context
-
-    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", request=request)
-        elif self.session.activo:
-            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
-
-        technique.save()
-        self.session.save()
-
-        parameters = {
-            "session_code": self.session.codigo_sesion
-        }
-        return redirect(
-            reverse("cata_system:monitor_sesion", kwargs=parameters))

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

@@ -0,0 +1,508 @@
+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, GrupoProducto, ValorBooleano,
+    ValorDecimal, Producto, Escala, EsVocabulario, Vocabulario
+)
+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"
+        self.context = {}
+
+    def getContext(self):
+        self.context["session"] = self.session
+
+        self.defineStatus()
+        self.setIsEndSession()
+        self.setDataTable()
+
+        return self.context
+
+    def defineStatus(self):
+        repetition = self.session.tecnica.repeticion
+        mod = TecnicaModalidad.objects.get(
+            tecnica=self.session.tecnica)
+
+        self.context["mod_tech"] = mod.modalidad.nombre
+        self.context["mode"] = mod.modalidad.nombre
+        if mod.modalidad.nombre == "sin modalidad":
+            self.context["mod_tech"] = "No se usa modalidad"
+
+        if not self.session.activo:
+            self.context["status"] = "Listo para iniciar la sesión con Napping"
+        elif self.session.activo:
+            self.context["status"] = "Sesión con en curso"
+
+    def controllPostResponse(self, request: HttpRequest, action: str):
+        if action == "start_sin_modalidad":
+            response = self.startNapping(request=request)
+
+        elif action == "start_perfil_ultra_flash":
+            response = self.startNapping(request=request)
+
+        elif action == "start_sorting":
+            response = self.startNapping(request=request)
+
+        elif action == "combine_sessions":
+            response = self.combineSessions(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):
+        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)
+
+        is_update_participations = self.setParticipationsToNoFinished()
+        if not is_update_participations:
+            return self.controllGetResponse(error="Error al actualizar las participaciones", 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 setDataTable(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)
+
+        # Add word frequency data for perfil ultra flash mode
+        mod = TecnicaModalidad.objects.get(tecnica=self.session.tecnica)
+        if mod.modalidad.nombre == "perfil ultra flash":
+            self.setWordFrequencies(ratings)
+        elif mod.modalidad.nombre == "sorting":
+            self.setSortingData()
+
+        self.context["there_data"] = True
+
+    def setWordFrequencies(self, ratings):
+        from collections import Counter
+
+        # Prefetch palabras to optimize queries
+        ratings_with_words = ratings.prefetch_related(
+            'palabras').select_related('id_producto')
+
+        # Dictionary to store word frequencies by product
+        word_frequencies_by_product = defaultdict(Counter)
+        all_words_set = set()
+
+        for rating in ratings_with_words:
+            producto_code = rating.id_producto.codigoProducto
+            words = rating.palabras.all()
+
+            for word in words:
+                word_name = word.nombre_palabra
+                word_frequencies_by_product[producto_code][word_name] += 1
+                all_words_set.add(word_name)
+
+        # Convert Counter objects to regular dicts and sort words alphabetically
+        word_frequencies_dict = {
+            product: dict(frequencies)
+            for product, frequencies in word_frequencies_by_product.items()
+        }
+
+        # Sort all words alphabetically for consistent column ordering
+        all_words_sorted = sorted(all_words_set)
+
+        self.context["word_frequencies"] = word_frequencies_dict
+        self.context["all_words"] = all_words_sorted
+
+    def setSortingData(self):
+        # Get all ratings for this technique to access DatoPunto
+        ratings = Calificacion.objects.filter(id_tecnica=self.session.tecnica)
+
+        # Get coordinates for all products
+        coordinates = (
+            DatoPunto.objects.filter(calificacion__in=ratings)
+            .values(
+                producto=F("calificacion__id_producto__codigoProducto"),
+                producto_id=F("calificacion__id_producto__id"),
+                catador=F("calificacion__id_catador__user__username"),
+                catador_id=F("calificacion__id_catador__id"),
+                px=F("x"),
+                py=F("y"),
+            ))
+
+        # Create a mapping of (catador_id, producto_id) -> coordinates
+        coord_map = {}
+        for coord in coordinates:
+            key = (coord["catador_id"], coord["producto_id"])
+            coord_map[key] = {
+                "px": coord["px"],
+                "py": coord["py"],
+                "producto": coord["producto"],
+                "catador": coord["catador"]
+            }
+
+        # Get all groups with their products and words
+        grupos = (
+            GrupoProducto.objects.filter(tecnica=self.session.tecnica)
+            .prefetch_related("productos", "palabras")
+            .select_related("catador__user")
+        )
+
+        # Create a mapping of (catador_id, producto_id) -> words
+        words_map = defaultdict(list)
+        for grupo in grupos:
+            catador_id = grupo.catador.id
+            words = [palabra.nombre_palabra for palabra in grupo.palabras.all()]
+            words_str = ";".join(words) if words else ""
+
+            for producto in grupo.productos.all():
+                key = (catador_id, producto.id)
+                words_map[key] = words_str
+
+        # Structure final data: product -> catador -> {px, py, words}
+        sorting_data = defaultdict(dict)
+
+        for key, coord_data in coord_map.items():
+            catador_id, producto_id = key
+            producto_code = coord_data["producto"]
+            catador_username = coord_data["catador"]
+
+            sorting_data[producto_code][catador_username] = {
+                "px": coord_data["px"],
+                "py": coord_data["py"],
+                "words": words_map.get(key, "")
+            }
+
+        self.context["sorting_data"] = defaultdict_to_dict(sorting_data)
+
+    def setIsEndSession(self):
+        if not self.session.activo and self.session.tecnica.repeticion < 1:
+            self.context["finished"] = False
+            return
+        elif self.session.activo:
+            self.context["finished"] = False
+            return
+        elif not self.session.activo and self.session.tecnica.repeticion >= 1:
+            self.context["finished"] = True
+            return
+
+    # ==================== SESSION COMBINATION METHODS ====================
+
+    def combineSessions(self, request: HttpRequest):
+        """Handle session combination request"""
+        session_b_code = request.POST.get("session_b_code", "").strip()
+
+        if not session_b_code:
+            return self.controllGetResponse(
+                error="Debe proporcionar un código de sesión", request=request)
+
+        # Validate and get session B
+        validation_result = self.validateSessionCombination(session_b_code)
+
+        if validation_result.get("error"):
+            return self.controllGetResponse(
+                error=validation_result["error"], request=request)
+
+        session_b = validation_result["session_b"]
+        technique_type = validation_result["technique_type"]
+
+        # Get combined data based on technique type
+        if technique_type == "cata":
+            combined_data = self.getCombinedDataForCATA(session_b)
+        elif technique_type == "rata":
+            combined_data = self.getCombinedDataForRATA(session_b)
+        elif technique_type == "escalas":
+            combined_data = self.getCombinedDataForEscalas(session_b)
+        else:
+            return self.controllGetResponse(
+                error="Tipo de técnica no soportado para combinación", request=request)
+
+        # Add combined data to context
+        self.context["combined_data"] = combined_data
+        self.context["session_b"] = session_b
+        self.context["session_b_technique_type"] = technique_type
+
+        return self.controllGetResponse(request=request)
+
+    def validateSessionCombination(self, session_b_code: str):
+        """Validate that Session B can be combined with Session A (Napping)"""
+        result = {"error": None, "session_b": None, "technique_type": None}
+
+        # Check if Session B exists
+        try:
+            session_b = SesionSensorial.objects.select_related(
+                "tecnica__tipo_tecnica").get(codigo_sesion=session_b_code)
+        except SesionSensorial.DoesNotExist:
+            result["error"] = f"No existe una sesión con el código: {session_b_code}"
+            return result
+
+        # Check if Session B technique is CATA, RATA, or Escalas
+        technique_type = session_b.tecnica.tipo_tecnica.nombre_tecnica
+        valid_techniques = ["cata", "rata", "escalas"]
+
+        if technique_type not in valid_techniques:
+            result[
+                "error"] = f"La sesión B debe usar CATA, RATA o Escalas. Técnica actual: {technique_type}"
+            return result
+
+        # Check if Session B is finished
+        if session_b.activo:
+            result["error"] = "La sesión B debe estar finalizada (no activa)"
+            return result
+
+        if session_b.tecnica.repeticion < 1:
+            result["error"] = "La sesión B debe haber completado al menos una repetición"
+            return result
+
+        # Get products from both sessions
+        products_a = set(
+            Producto.objects.filter(
+                calificacion_producto__id_tecnica=self.session.tecnica
+            ).values_list("codigoProducto", flat=True).distinct()
+        )
+
+        products_b = set(
+            Producto.objects.filter(
+                calificacion_producto__id_tecnica=session_b.tecnica
+            ).values_list("codigoProducto", flat=True).distinct()
+        )
+
+        # Check if products match
+        if products_a != products_b:
+            result["error"] = f"Los productos no coinciden. Sesión A: {len(products_a)} productos, Sesión B: {len(products_b)} productos"
+            return result
+
+        # Get tasters from both sessions
+        tasters_a = set(
+            Participacion.objects.filter(
+                tecnica=self.session.tecnica
+            ).values_list("catador__user__username", flat=True)
+        )
+
+        tasters_b = set(
+            Participacion.objects.filter(
+                tecnica=session_b.tecnica
+            ).values_list("catador__user__username", flat=True)
+        )
+
+        # Check if tasters match
+        if tasters_a != tasters_b:
+            result["error"] = f"Los catadores no coinciden. Sesión A: {len(tasters_a)} catadores, Sesión B: {len(tasters_b)} catadores"
+            return result
+
+        result["session_b"] = session_b
+        result["technique_type"] = technique_type
+        return result
+
+    def getCombinedDataForCATA(self, session_b: SesionSensorial):
+        """Get combined data for CATA technique (word frequencies)"""
+        from collections import Counter
+
+        # Get all ratings for session B
+        ratings_b = Calificacion.objects.filter(id_tecnica=session_b.tecnica)
+
+        # Get boolean values (CATA uses boolean)
+        data = (
+            ValorBooleano.objects
+            .filter(id_dato__id_calificacion__in=ratings_b, valor=True)
+            .values(
+                palabra=F("id_dato__id_palabra__nombre_palabra"),
+                producto=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+            )
+        )
+
+        # Count word frequencies per product
+        word_frequencies = defaultdict(Counter)
+        all_words_set = set()
+
+        for item in data:
+            palabra = item["palabra"]
+            producto = item["producto"]
+            word_frequencies[producto][palabra] += 1
+            all_words_set.add(palabra)
+
+        # Get vocabulary info if exists
+        vocabulary_info = self.getVocabularyInfo(session_b.tecnica)
+
+        return {
+            "word_frequencies": defaultdict_to_dict(word_frequencies),
+            "all_words": sorted(all_words_set),
+            "vocabulary_info": vocabulary_info,
+        }
+
+    def getCombinedDataForRATA(self, session_b: SesionSensorial):
+        """Get combined data for RATA technique (word averages)"""
+
+        # Get all ratings for session B
+        ratings_b = Calificacion.objects.filter(id_tecnica=session_b.tecnica)
+
+        # Get decimal values (RATA uses decimal)
+        data = (
+            ValorDecimal.objects
+            .filter(id_dato__id_calificacion__in=ratings_b)
+            .values(
+                palabra=F("id_dato__id_palabra__nombre_palabra"),
+                producto=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+                valor_decimal=F("valor"),
+            )
+        )
+
+        # Calculate averages per product per word
+        word_sums = defaultdict(lambda: defaultdict(list))
+        all_words_set = set()
+
+        for item in data:
+            palabra = item["palabra"]
+            producto = item["producto"]
+            valor = item["valor_decimal"]
+            word_sums[producto][palabra].append(valor)
+            all_words_set.add(palabra)
+
+        # Calculate averages
+        word_averages = {}
+        for producto, palabras in word_sums.items():
+            word_averages[producto] = {}
+            for palabra, valores in palabras.items():
+                word_averages[producto][palabra] = sum(valores) / len(valores)
+
+        # Get vocabulary info if exists
+        vocabulary_info = self.getVocabularyInfo(session_b.tecnica)
+
+        return {
+            "word_averages": word_averages,
+            "all_words": sorted(all_words_set),
+            "vocabulary_info": vocabulary_info,
+        }
+
+    def getCombinedDataForEscalas(self, session_b: SesionSensorial):
+        """Get combined data for Escalas technique (averages across repetitions)"""
+
+        # Get all ratings for session B
+        ratings_b = Calificacion.objects.filter(id_tecnica=session_b.tecnica)
+
+        # Get decimal values grouped by repetition
+        data = (
+            ValorDecimal.objects
+            .filter(id_dato__id_calificacion__in=ratings_b)
+            .values(
+                palabra=F("id_dato__id_palabra__nombre_palabra"),
+                producto=F(
+                    "id_dato__id_calificacion__id_producto__codigoProducto"),
+                repeticion=F("id_dato__id_calificacion__num_repeticion"),
+                valor_decimal=F("valor"),
+            )
+        )
+
+        # Calculate averages per repetition (like RATA), then average across repetitions
+        # Structure: {producto: {repeticion: {palabra: [valores]}}}
+        repetition_values = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(list)))
+        all_words_set = set()
+
+        for item in data:
+            palabra = item["palabra"]
+            producto = item["producto"]
+            repeticion = item["repeticion"]
+            valor = item["valor_decimal"]
+            # Collect all values for averaging
+            repetition_values[producto][repeticion][palabra].append(valor)
+            all_words_set.add(palabra)
+
+        # Calculate average per repetition, then average across repetitions
+        word_averages = {}
+        for producto, repeticiones in repetition_values.items():
+            word_averages[producto] = {}
+            # Get all words for this product across all repetitions
+            all_product_words = set()
+            for rep_words in repeticiones.values():
+                all_product_words.update(rep_words.keys())
+
+            # Calculate average for each word
+            for palabra in all_product_words:
+                # Get average for each repetition
+                rep_averages = []
+                for rep in repeticiones.keys():
+                    if palabra in repeticiones[rep]:
+                        valores = repeticiones[rep][palabra]
+                        rep_averages.append(sum(valores) / len(valores))
+
+                # Average the repetition averages
+                if rep_averages:
+                    word_averages[producto][palabra] = sum(
+                        rep_averages) / len(rep_averages)
+
+        # Get scale and vocabulary info
+        scale = Escala.objects.get(tecnica=session_b.tecnica)
+        scale_info = None
+        if scale:
+            scale_info = {
+                "type": scale.id_tipo_escala.nombre_escala,
+                "size": scale.longitud
+            }
+
+        vocabulary_info = self.getVocabularyInfo(session_b.tecnica)
+
+        return {
+            "word_averages": word_averages,
+            "all_words": sorted(all_words_set),
+            "scale_info": scale_info,
+            "vocabulary_info": vocabulary_info,
+            "num_repetitions": session_b.tecnica.repeticion,
+        }
+
+    def getVocabularyInfo(self, tecnica):
+        es_vocabulario = EsVocabulario.objects.filter(
+            id_tecnica=tecnica).first()
+        if es_vocabulario:
+            vocabulario = es_vocabulario.id_vocabulario
+            return {
+                "nombre": vocabulario.nombre_vocabulario,
+            }
+        return None

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

@@ -0,0 +1,215 @@
+from tecnicas.models import SesionSensorial, ListaPalabras, Calificacion, Catador
+from tecnicas.controllers import DatoController
+from tecnicas.utils import defaultdict_to_dict
+from .details_controller import DetallesController
+from collections import defaultdict
+
+
+class DetallesPFController(DetallesController):
+    skip_repetition = 2
+
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_template = "tecnicas/manage_sesions/details-session-pf.html"
+        self.url_next = "cata_system:monitor_sesion"
+
+    def getContext(self):
+        technique = self.session.tecnica
+
+        self.context = {
+            "sesion": self.session,
+            "use_technique": technique,
+            "tipo_escala": technique.escala_tecnica.id_tipo_escala.nombre_escala,
+            "repeticiones_max": technique.repeticiones_max - self.skip_repetition
+        }
+
+        # Definir el estado de la sesion
+        rep = technique.repeticion
+        activate = self.session.activo
+        self.context["estado"] = self.getStatus(rep, activate)
+
+        self.getDataPhases()
+
+        self.isEndSession()
+
+        return self.context
+
+    def isEndSession(self):
+        current_rep = self.session.tecnica.repeticion - self.skip_repetition
+        max_rep = self.session.tecnica.repeticiones_max - self.skip_repetition
+        self.context["finished"] = current_rep >= max_rep
+
+    def getDataPhases(self):
+        curren_repetition = self.session.tecnica.repeticion
+
+        if curren_repetition == 1:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+            self.context["repeticion"] = 0
+
+        elif curren_repetition == 2:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+            self.context["second_phase"] = self.getDataSecondPhase()
+            self.context["repeticion"] = 0
+
+        elif curren_repetition >= 3:
+            self.context["fisrt_phase"] = self.getDataFirstPhase()
+            self.context["second_phase"] = self.getDataSecondPhase()
+            self.context["data_ratings"] = self.getDataRatings()
+            self.context["repeticion"] = self.session.tecnica.repeticion - self.skip_repetition
+
+        return self.context
+
+    def getDataFirstPhase(self):
+        lists_testers = ListaPalabras.objects.filter(
+            tecnica=self.session.tecnica,
+            es_final=False
+        )
+
+        result = []
+        for list in lists_testers:
+            try:
+                username = list.catador.user.username
+            except Exception:
+                username = None
+
+            words_qs = list.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words
+            })
+
+        return result
+
+    def getDataSecondPhase(self):
+        lists_testers = ListaPalabras.objects.filter(
+            tecnica=self.session.tecnica,
+            es_final=True
+        )
+
+        result = []
+        for list in lists_testers:
+            try:
+                username = list.catador.user.username
+            except Exception:
+                username = None
+
+            words_qs = list.palabras.all()
+            words = []
+            for p in words_qs:
+                nombre = getattr(p, 'nombre_palabra', None)
+                words.append({
+                    'id': getattr(p, 'id', None),
+                    'nombre_palabra': nombre
+                })
+
+            result.append({
+                'username': username,
+                'words': words
+            })
+            
+        return result
+
+    def getDataRatings(self):
+        technique = self.session.tecnica
+
+        if technique.repeticion > 3:
+            return self.getDataRatingsFinal()
+
+        elif technique.repeticion == 3:
+            return self.getDataRatingsInitial()
+
+    def getStatus(self, rep: int, activate: bool):
+        status = ""
+
+        if rep == 0 and not activate:
+            status = "Listo para crear listas iniciales"
+
+        elif rep == 1 and activate:
+            status = "En primera fase, creación de listas iniciales"
+        elif rep == 1 and not activate:
+            status = "Listo para crear listas finales"
+
+        elif rep == 2 and activate:
+            status = "En segunda fase, creación de listas finales"
+        elif rep == 2 and not activate:
+            status = "Listo para calificaciones"
+
+        elif rep > 2 and not activate:
+            status = "Listo para calificaciones"
+        elif rep > 2 and activate:
+            status = "Catadores calificando"
+
+        return status
+
+    def getDataRatingsInitial(self):
+        ratings = list(Calificacion.objects.filter(id_tecnica=self.session.tecnica, num_repeticion=3))
+            
+        if ratings:
+            raw_data = DatoController.getWordValuesForConvecional(
+                technique=self.session.tecnica,
+                ratings=ratings
+            )
+            
+            structured_data = defaultdict(lambda: defaultdict(list))
+            
+            for item in raw_data:
+                prod_code = item["producto_code"]
+                username = item["usuario_catador"]
+                
+                structured_data[prod_code][username].append({
+                    "palabra": item["nombre_palabra"],
+                    "valor": item["dato_valor"]
+                })
+
+        return defaultdict_to_dict(structured_data)
+
+    def getDataRatingsFinal(self):
+        lists_words_testers = self.context["second_phase"]
+        technique = self.session.tecnica
+
+        ratings_for_tester = []
+
+        for list_tester in lists_words_testers:
+            tester_username = list_tester["username"]
+            # Se recuperan las calificaciones
+            ratings_for_repetition = []
+
+            ratings = list(Calificacion.objects.filter(
+                id_tecnica=technique, id_catador__user__username=tester_username))
+
+            if not ratings:
+                continue
+
+            data = DatoController.getWordValuesPF(
+                ratings=ratings, technique=technique, tester=Catador.objects.get(user__username=tester_username))
+
+            ratings_for_repetition = defaultdict(lambda: defaultdict(list))
+
+            # Estructurar los datos
+            for item in data:
+                rep = item["repeticion"]
+                prod = item["producto_code"]
+
+                ratings_for_repetition[rep-2][prod].append({
+                    "nombre_palabra": item["nombre_palabra"],
+                    "dato_valor": item["dato_valor"]
+            })
+
+            ratings_for_tester.append(
+                {
+                    "tester": tester_username,
+                    "ratings": defaultdict_to_dict(
+                        ratings_for_repetition),
+                    "words": list_tester["words"]
+                }
+            )
+
+        return ratings_for_tester

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

@@ -0,0 +1,7 @@
+from tecnicas.models import SesionSensorial
+from .details_controller import DetallesController
+
+
+class DetallesRATAController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)

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

@@ -0,0 +1,91 @@
+from .details_controller import DetallesController
+from tecnicas.models import SesionSensorial, GrupoProducto, Producto, Participacion
+from collections import defaultdict
+
+
+class DetallesSortController(DetallesController):
+    def __init__(self, session: SesionSensorial):
+        super().__init__(session)
+        self.url_template = "tecnicas/manage_sesions/details-session-sort.html"
+        self.url_next = "cata_system:monitor_sesion"
+
+    def getContext(self):
+        technique = self.session.tecnica
+
+        finished = False
+        status = ""
+
+        if technique.repeticion < technique.repeticiones_max and not self.session.activo:
+            status = "En espera para iniciar la sesión"
+        elif technique.repeticion >= technique.repeticiones_max and not self.session.activo:
+            status = "Esta sesión ha sido finalizada"
+            finished = True
+        else:
+            status = "La sesión está en progreso"
+
+        self.context = {
+            "sesion": self.session,
+            "technique": technique,
+            "status": status,
+            "finished": finished
+        }
+
+        self.context["data_groups"] = {
+            "data": self.setDataSort(),
+            "testers": self.setHeaders()
+        }
+
+        return self.context
+
+    def setDataSort(self):
+        data = []
+        technique = self.session.tecnica
+
+        products = Producto.objects.filter(id_tecnica=technique)
+
+        groups = GrupoProducto.objects.select_related("catador").filter(
+            tecnica=technique
+        )
+
+        if len(groups):
+            self.context["there_data"] = True
+        else:
+            self.context["there_data"] = False
+            return []
+
+        for product in products:
+            product_data = {
+                "codigo_producto": product.codigoProducto,
+                "palabras": {}
+            }
+
+            related_groups = groups.filter(productos=product).select_related(
+                "catador__user"
+            ).prefetch_related("palabras")
+
+            data_words = defaultdict(set)
+
+            for group in related_groups:
+                catador_username = group.catador.user.username
+
+                for word in group.palabras.all():
+                    data_words[catador_username].add(word.nombre_palabra)
+
+            product_data["palabras"] = {
+                username: list(words)
+                for username, words in data_words.items()
+            }
+
+            data.append(product_data)
+
+        return data
+
+    def setHeaders(self):
+        participacions = list(Participacion.objects.filter(
+            tecnica=self.session.tecnica
+        ).only("catador").select_related("catador__user"))
+
+        testers = [
+            participacion.catador.user.username for participacion in participacions]
+
+        return testers

tecnicas/controllers/views_controller/session_management/details_controller.py

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

tecnicas/controllers/views_controller/session_management/{monitor_controller.py → monitor/monitor_controller.py}

@@ -1,8 +1,7 @@
 from django.http import HttpRequest
-from django.shortcuts import render
-from tecnicas.models import SesionSensorial, Producto, EsAtributo, EsVocabulario
-from tecnicas.controllers import ParticipacionController, SesionController
-from tecnicas.utils import controller_error
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Producto, EsAtributo, EsVocabulario, Participacion
 
 
 class MonitorController():
@@ -12,9 +11,21 @@ class MonitorController():
     def __init__(self, session: SesionSensorial):
         self.sensorial_session = session
 
+    def controllPostFinishSession(self, request: HttpRequest):
+        (is_all_end, message) = self.checkAllFinish()
+        if not is_all_end:
+            self.setContext()
+            self.context["error"] = message
+            return render(request, self.url_view, self.context)
+        self.finishSession()
+        return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
+
+    def checkAllFinish(self) -> (bool, str):
+        return (False, "Función sin implementar")
+
     def setContext(self):
-        self.participations = ParticipacionController.getParticipationsInTechinique(
-            self.sensorial_session.tecnica)
+        self.participations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica)
 
         self.context = {
             "code_session": self.sensorial_session.codigo_sesion,
@@ -26,7 +37,7 @@ class MonitorController():
             "use_technique": self.sensorial_session.tecnica.tipo_tecnica.nombre_tecnica
         }
 
-    def controlGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
+    def controllGetResponse(self, request: HttpRequest,  error: str = "", message: str = ""):
         self.setContext()
 
         if error != "" or error:
@@ -36,7 +47,7 @@ class MonitorController():
 
         return render(request, self.url_view, self.context)
 
-    def getExpectedRatingsEscalasRapida(self):
+    def getExpectedRatings(self):
         num_products = Producto.objects.filter(
             id_tecnica=self.sensorial_session.tecnica).count()
         style_words = self.sensorial_session.tecnica.id_estilo
@@ -52,8 +63,6 @@ class MonitorController():
         return num_products * num_words
 
     def finishSession(self):
-        response = SesionController.finishRepetion(self.sensorial_session)
-        if isinstance(response, dict):
-            return controller_error(response["error"])
-        self.sensorial_session.refresh_from_db()
+        self.sensorial_session.activo = False
+        self.sensorial_session.save()
         return self.sensorial_session

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

@@ -1,6 +1,3 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from django.urls import reverse
 from tecnicas.models import Dato, Participacion
 from tecnicas.controllers import SesionController
 from .monitor_controller import MonitorController
@@ -12,23 +9,10 @@ class MonitorEscalasController(MonitorController):
         self.url_view = "tecnicas/manage_sesions/monitor-sesion.html"
         self.previus_view = "cata_system:detalles_sesion"
 
-    def controllPostFinishSession(self, request: HttpRequest):
-        self.setContext()
-        (is_all_end, message) = self.checkAllFinish()
-        if not is_all_end:
-            self.context["error"] = message
-            return render(request, self.url_view, self.context)
-        response = self.finishSession()
-        if isinstance(response, dict):
-            self.context["error"] = response["error"]
-            return render(request, self.url_view, self.context)
-        self.context["message"] = message
-        return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
-
     def checkAllFinish(self):
         technique = self.sensorial_session.tecnica
 
-        expected_ratings_repetition = self.getExpectedRatingsEscalasRapida()
+        expected_ratings_repetition = self.getExpectedRatings()
 
         all_participations = list(
             Participacion.objects.filter(tecnica=technique))

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

@@ -0,0 +1,35 @@
+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):
+        technique = self.sensorial_session.tecnica
+        technique.repeticion = 1
+        technique.save()
+        self.sensorial_session.activo = False
+        self.sensorial_session.save()
+        return self.sensorial_session

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

@@ -0,0 +1,72 @@
+from tecnicas.models import Dato, Participacion, Catador, ListaPalabras, Producto
+from tecnicas.controllers import SesionController
+from .monitor_controller import MonitorController
+
+
+class MonitorPFController(MonitorController):
+    def __init__(self, session: SesionController):
+        super().__init__(session)
+        self.url_view = "tecnicas/manage_sesions/monitor-session-pf.html"
+        self.previus_view = "cata_system:detalles_sesion"
+
+    def checkAllFinish(self):
+        rep = self.sensorial_session.tecnica.repeticion
+
+        finish_data = ()
+
+        if rep == 1 or rep == 2:
+            finish_data = self.checkFinishFirstPhase()
+        elif rep >= 3:
+            finish_data = self.checkFinishRepetition()
+
+        return finish_data
+
+    def checkFinishFirstPhase(self):
+        num_paricipations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica).count()
+        if num_paricipations < self.sensorial_session.tecnica.limite_catadores:
+            return (False, "No se ha alcanzado el número máximo de catadores")
+
+        unfinished_participations = Participacion.objects.filter(
+            tecnica=self.sensorial_session.tecnica, finalizado=False).count()
+        if unfinished_participations:
+            return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")
+
+    def checkFinishRepetition(self) -> tuple[bool, str]:
+        technique = self.sensorial_session.tecnica
+
+        # Revisar numero de catadores sea alcanzado
+        all_participations = list(
+            Participacion.objects.filter(tecnica=technique))
+        if len(all_participations) < technique.limite_catadores:
+            return (False, "No se ha alcanzado el número máximo de Catadores")
+
+        # Revisar que cada catador haya terminado de calificar sus palabras
+        for particiapation in all_participations:
+            expected_ratings_repetition = self.getExpectedRatings(
+                tester=particiapation.catador)
+
+            num_ratings_now = Dato.objects.filter(
+                id_calificacion__num_repeticion=technique.repeticion,
+                id_calificacion__id_catador=particiapation.catador,
+                id_calificacion__id_tecnica=technique
+            ).count()
+
+            if num_ratings_now < expected_ratings_repetition:
+                return (False, "No todos los catadores han finalizado su evaluación")
+
+        return (True, "Puedes finalizar la sesión")
+
+    def getExpectedRatings(self, tester: Catador):
+        num_words = ListaPalabras.objects.get(
+            tecnica=self.sensorial_session.tecnica,
+            catador=tester,
+            es_final=True
+        ).palabras.all().count()
+
+        num_products = Producto.objects.filter(
+            id_tecnica=self.sensorial_session.tecnica).count()
+
+        return num_products * num_words

tecnicas/controllers/views_controller/session_management/{monitor_rata_controller.py → monitor/monitor_rata_controller.py}

@@ -1,6 +1,3 @@
-from django.http import HttpRequest
-from django.shortcuts import render, redirect
-from django.urls import reverse
 from tecnicas.models import Dato, Participacion
 from tecnicas.controllers import SesionController
 from .monitor_controller import MonitorController
@@ -12,23 +9,10 @@ class MonitorRATAController(MonitorController):
         self.url_view = "tecnicas/manage_sesions/monitor-sesion.html"
         self.previus_view = "cata_system:detalles_sesion"
 
-    def controllPostFinishSession(self, request: HttpRequest):
-        self.setContext()
-        (is_all_end, message) = self.checkAllFinish()
-        if not is_all_end:
-            self.context["error"] = message
-            return render(request, self.url_view, self.context)
-        response = self.finishSession()
-        if isinstance(response, dict):
-            self.context["error"] = response["error"]
-            return render(request, self.url_view, self.context)
-        self.context["message"] = message
-        return redirect(reverse(self.previus_view, kwargs={"session_code": self.sensorial_session.codigo_sesion}))
-
     def checkAllFinish(self):
         technique = self.sensorial_session.tecnica
 
-        expected_ratings_repetition = self.getExpectedRatingsEscalasRapida()
+        expected_ratings_repetition = self.getExpectedRatings()
 
         all_participations = list(
             Participacion.objects.filter(tecnica=technique))

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

@@ -0,0 +1,27 @@
+from tecnicas.models import SesionSensorial
+from tecnicas.models import Participacion
+from .monitor_controller import MonitorController
+
+
+class MonitorSortController(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):
+        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")

tecnicas/controllers/views_controller/sessions_tester/{init_session_tester_controller.py → init_session/init_session_controller.py}

@@ -1,96 +1,23 @@
-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, Dato
-from tecnicas.controllers import ParticipacionController
+from django.db import transaction
+from tecnicas.models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, EsVocabulario, Dato, ListaPalabras
 from tecnicas.utils import controller_error, shuffleArray
 
 
-class InitSessionTesterController():
+class InitSessionController():
     tester: Catador
     session: SesionSensorial
     order: Orden | dict
-    current_direction = "tecnicas/forms_tester/init_session.html"
+    current_direction: str
+    current_direction = "tecnicas/forms_tester/init_scales_test.html"
     escalas_direction = "cata_system:session_convencional"
 
     def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
         self.tester = user_tester
         self.session = sensorial_session
 
-    def controllGetEscalas(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        order = self.checkAndAssignOrder()
-        if isinstance(order, dict):
-            context["error"] = order["error"]
-            return render(request, self.current_direction, context)
-
-        is_end = self.isEndedSessionEscalas()
-
-        request.session["id_order"] = order.id
-        context["has_ended"] = is_end
-
-        if is_end:
-            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-
-        if "error" in request.GET:
-            context["error"] = request.GET["error"]
-
-        return render(request, self.current_direction, context)
-
-    def controllPostEscalas(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        if request.POST["action"] == "start_posting":
-            parameters = {
-                "code_sesion": self.session.codigo_sesion
-            }
-
-            is_end = self.isEndedSessionEscalas()
-            if is_end:
-                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-                return render(request, self.current_direction, context)
-
-            update_participation = ParticipacionController.enterSession(
-                tester=request.user.user_catador, session=self.session)
-            if isinstance(update_participation, dict):
-                context["error"] = update_participation["error"]
-                return render(request, self.current_direction, context)
-
-            request.session["id_participation"] = update_participation.id
-            return redirect(reverse(self.escalas_direction, kwargs=parameters))
-        elif request.POST["action"] == "exit_session":
-            response = ParticipacionController.outSession(
-                tester=request.user.user_catador, session=self.session)
-            if isinstance(response, dict):
-                context["error"] = response["error"]
-            return render(request, self.current_direction, context)
-        else:
-            context["error"] = "Acción sin especificar"
-            return render(request, self.current_direction, context)
-
-    def controllGetRATA(self, request: HttpRequest):
-        context = {
-            "session": self.session,
-            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
-        }
-
-        is_end = self.isEndedSessionEscalas()
-
-        context["has_ended"] = is_end
-
-        if is_end:
-            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
-
-        return render(request, self.current_direction, context)
-
     def assignOrder(self):
         with transaction.atomic():
             orders_without_tester = list(Orden.objects.select_for_update().filter(
@@ -117,7 +44,7 @@ class InitSessionTesterController():
                 return create
         return self.order_to_assign
 
-    def isEndedSessionEscalas(self):
+    def isEndedSession(self):
         try:
             participation = Participacion.objects.get(
                 catador=self.tester, tecnica=self.session.tecnica)

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

@@ -0,0 +1,82 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Catador, SesionSensorial, Orden
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionEscalasController(InitSessionController):
+    tester: Catador
+    session: SesionSensorial
+    order: Orden | dict
+
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_scales_test.html"
+        self.escalas_direction = "cata_system:session_convencional"
+        self.cata_direction = "cata_system:session_cata"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        order = self.checkAndAssignOrder()
+        if isinstance(order, dict):
+            context["error"] = order["error"]
+            return render(request, self.current_direction, context)
+
+        is_end = self.isEndedSession()
+
+        request.session["id_order"] = order.id
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, context)
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        if request.POST["action"] == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            is_end = self.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
+
+            if self.session.tecnica.tipo_tecnica.nombre_tecnica == "cata":
+                return redirect(reverse(self.cata_direction, kwargs=parameters))
+
+            return redirect(reverse(self.escalas_direction, kwargs=parameters))
+
+        elif request.POST["action"] == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return render(request, self.current_direction, context)
+
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)

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

@@ -0,0 +1,80 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Participacion, TecnicaModalidad
+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()
+        }
+
+        self.setStatusSession()
+
+        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)
+
+    def setStatusSession(self):
+        technique_mode = TecnicaModalidad.objects.get(
+            tecnica=self.session.tecnica).modalidad.nombre
+
+        if technique_mode == "sin modalidad":
+            self.context["status"] = "La sesión usa Napping"
+        else:
+            self.context["status"] = f"La sesión usa Napping con modalidad {technique_mode}"

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

@@ -0,0 +1,144 @@
+from django.http import HttpRequest
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from tecnicas.models import Participacion, Producto, Dato, ListaPalabras
+from tecnicas.controllers import ParticipacionController
+from .init_session_controller import InitSessionController
+
+
+class InitSessionPFController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_pf_test.html"
+        self.pf_direction = "cata_system:session_pf"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        (is_end, message, rep_show) = self.isEndedSession()
+
+        context["has_ended"] = is_end
+        context["activity"] = message
+        context["repetition"] = rep_show
+
+        if "error" in request.GET:
+            context["error"] = request.GET["error"]
+
+        return render(request, self.current_direction, context)
+
+    def controllPost(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        action = request.POST["action"]
+
+        if action == "start_posting":
+            parameters = {
+                "code_sesion": self.session.codigo_sesion
+            }
+
+            (is_end, message, rep_show) = self.isEndedSession()
+            if is_end:
+                return self.controllGet(request)
+
+            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.pf_direction, kwargs=parameters))
+
+        elif action == "exit_session":
+            response = ParticipacionController.outSession(
+                tester=request.user.user_catador, session=self.session)
+            if isinstance(response, dict):
+                context["error"] = response["error"]
+            return self.controllGet(request)
+
+        else:
+            context["error"] = "Acción sin especificar"
+            return render(request, self.current_direction, context)
+
+    def isEndedSession(self) -> tuple[bool, str, int]:
+        rep = self.session.tecnica.repeticion
+
+        is_end = False
+        message = ""
+        repetitiom_show = 0
+
+        if rep == 1:
+            is_end = self.endedSessionMakeList()
+            message = "Ya has creado la Lista de palabras inicial" if is_end else "Debes crear tu lista de palabras inicial"
+            repetitiom_show = 0
+        elif rep == 2:
+            is_end = self.endedSessionMakeList()
+            message = "Ya has creado la Lista de palabras final" if is_end else "Debes crear tu lista de palabras final"
+            repetitiom_show = 0
+        elif rep >= 3:
+            is_end = self.endedSessionRepetition()
+            message = "Has finalizado con el proceso de calificación" if is_end else "Debe hacer tu proceso de calificación"
+            repetitiom_show = rep - 2
+        else:
+            message = "Parece que la repetición es cero, no es posible hacer algo ahora mismo"
+
+        return (is_end, message, repetitiom_show)
+
+    def endedSessionMakeList(self):
+        try:
+            return Participacion.objects.get(
+                catador=self.tester, tecnica=self.session.tecnica).finalizado
+        except Participacion.DoesNotExist:
+            print("No se ha encontrado la participación")
+            return False
+
+    def endedSessionRepetition(self):
+        try:
+            participation = Participacion.objects.get(
+                catador=self.tester, tecnica=self.session.tecnica)
+            self.session.refresh_from_db()
+
+            # ////////////////////////////////////////////////////////////// #
+            #
+            # 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
+            #
+            # ////////////////////////////////////////////////////////////// #
+
+            if participation.finalizado:
+                num_products = Producto.objects.filter(
+                    id_tecnica=self.session.tecnica).count()
+
+                num_words = ListaPalabras.objects.get(
+                    tecnica=self.session.tecnica,
+                    catador=self.tester,
+                    es_final=True
+                ).palabras.all().count()
+
+                expected_ratings_repetition = num_products * num_words
+
+                technique = self.session.tecnica
+                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
+
+                return is_end
+
+            else:
+                return participation.finalizado
+
+        except Participacion.DoesNotExist:
+            print("No se ha encontrado la participación")
+            return False

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

@@ -0,0 +1,24 @@
+from django.http import HttpRequest
+from django.shortcuts import render
+from .init_session_controller import InitSessionController
+
+
+class InitSessionRATAController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_scales_test.html"
+
+    def controllGet(self, request: HttpRequest):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        is_end = self.isEndedSession()
+
+        context["has_ended"] = is_end
+
+        if is_end:
+            context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+
+        return render(request, self.current_direction, context)

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

@@ -0,0 +1,77 @@
+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 InitSessionSortController(InitSessionController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_direction = "tecnicas/forms_tester/init_test_sort.html"
+        self.sort_direction = "cata_system:session_sort"
+
+    def controllGet(self, request: HttpRequest, error=""):
+        context = {
+            "session": self.session,
+            "type_technique": self.session.tecnica.tipo_tecnica.nombre_tecnica
+        }
+
+        is_end = self.isEndedSession()
+
+        context["has_ended"] = is_end
+
+        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 isEndedSession(self):
+        participation = Participacion.objects.get(
+            catador=self.tester, tecnica=self.session.tecnica)
+
+        return participation.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.sort_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

@@ -1,4 +1,4 @@
-from django.http import HttpRequest, JsonResponse
+from django.http import HttpRequest
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from django.db import transaction
@@ -12,6 +12,7 @@ class LoginSessionTesterController():
     taster_participation: Participacion
     current_direcction = "tecnicas/forms_tester/login_session.html"
     destinity_direcction = "cata_system:catador_init_session"
+    context = {}
 
     def __init__(self):
         self.tester = Catador()
@@ -28,17 +29,18 @@ class LoginSessionTesterController():
             return controller_error("Credenciales inválidas")
 
     def validateEntryEscalas(self, request=HttpRequest):
-        context = {}
+        self.context = {}
         if not self.session.activo:
-            context["error"] = "La sesión no está activa actualmente"
-            return render(request, self.current_direcction, context)
+            self.context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, self.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)
+                self.context["error"] = "Usted ya esta dentro de la sesión"
+                return render(request, self.current_direcction, self.context)
+
             except Participacion.DoesNotExist:
                 with transaction.atomic():
                     code_session = self.session.codigo_sesion
@@ -50,8 +52,8 @@ class LoginSessionTesterController():
                         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)
+                        self.context["error"] = "La sesión ha alcanzado el número máximo de catadores"
+                        return render(request, self.current_direcction, self.context)
 
                     self.taster_participation = Participacion.objects.create(
                         tecnica=self.session.tecnica,
@@ -63,21 +65,21 @@ class LoginSessionTesterController():
                 }
                 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)
+            self.context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, self.context)
 
-    def validateEntryRATA(self, request: HttpRequest):
-        context = {}
+    def validateEntryRataCata(self, request: HttpRequest):
+        self.context = {}
         if not self.session.activo:
-            context["error"] = "La sesión no está activa actualmente"
-            return render(request, self.current_direcction, context)
+            self.context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, self.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)
+                self.context["error"] = "Usted ya esta dentro de la sesión"
+                return render(request, self.current_direcction, self.context)
             except Participacion.DoesNotExist:
                 with transaction.atomic():
                     code_session = self.session.codigo_sesion
@@ -95,5 +97,67 @@ class LoginSessionTesterController():
                 }
                 return redirect(reverse(self.destinity_direcction, kwargs=params))
         else:
-            context["error"] = "Imposible acceder a esta sesión"
-            return render(request, self.current_direcction, context)
+            self.context["error"] = "Imposible acceder a esta sesión"
+            return render(request, self.current_direcction, self.context)
+
+    def validateEntryLimitTesters(self, request: HttpRequest):
+        self.context = {}
+        if not self.session.activo:
+            self.context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, self.context)
+
+        if self.session.tecnica.repeticion == 1:
+            return self.entrySessionLimitTesters(request)
+
+        else:
+            self.context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, self.context)
+
+    def validateEntryNapping(self, request: HttpRequest):
+        self.context = {}
+        if not self.session.activo:
+            self.context["error"] = "La sesión no está activa actualmente"
+            return render(request, self.current_direcction, self.context)
+
+        if self.session.tecnica.repeticion == 0:
+            return self.entrySessionLimitTesters(request)
+
+        else:
+            self.context["error"] = "Ya no es posible ingresar a la sesión"
+            return render(request, self.current_direcction, self.context)
+
+    def entrySessionLimitTesters(self, request: HttpRequest):
+        try:
+            self.taster_participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=self.tester)
+            self.context["error"] = "Usted ya esta dentro de la sesión"
+            return render(request, self.current_direcction, self.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:
+                self.context["error"] = str(e)
+                return render(request, self.current_direcction, self.context)

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

@@ -0,0 +1,28 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import SesionSensorial, Catador, Participacion
+from tecnicas.controllers import ParticipacionController
+
+
+class GenetalTestController():
+    previus_directory = "cata_system:catador_init_session"
+    context = {}
+    current_directory: str
+
+    def __init__(self, sensorial_session: SesionSensorial, user_tester: Catador):
+        self.tester = user_tester
+        self.session = sensorial_session
+
+    def controllPost(self, request: HttpRequest):
+        action = request.POST["action"]
+
+        if action == "finish_session":
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        else:
+            return self.controllGet(request, error="Acción no permitida")

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

@@ -0,0 +1,55 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Producto, Participacion, Palabra, Calificacion
+from tecnicas.controllers import PalabrasController, ParticipacionController
+from .general_test_controller import GenetalTestController
+
+
+class TestCataController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/test_cata.html"
+
+    def controllGet(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
+                )
+            except Calificacion.DoesNotExist:
+                # Si no hay calificacion mandamos el producto actual y todas la palabras
+                use_product = current_product
+                use_words = words
+                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
+
+        return render(request, self.current_directory, self.context)

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

@@ -0,0 +1,242 @@
+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, Modalidad, Palabra, GrupoProducto
+from tecnicas.forms import ListWordsForm
+from tecnicas.utils import noValidTechnique
+from tecnicas.controllers import ParticipacionController
+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"
+        self.napping_puf_test = "tecnicas/forms_tester/test_napping_puf.html"
+        self.sort_direction = "tecnicas/forms_tester/test_napping_sort.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).modalidad.nombre
+
+        if name_mode_activate == "sin modalidad":
+            self.context["mode"] = "sin modalidad"
+            return self.nappingTest(request)
+
+        if name_mode_activate == "perfil ultra flash":
+            self.context["mode"] = "perfil ultra flash"
+            return self.nappingPufTest(request)
+
+        if name_mode_activate == "sorting":
+            self.context["mode"] = "sorting"
+            return self.nappingSort(request)
+
+        else:
+            return noValidTechnique(
+                name_view=self.previus_directory,
+                query_params={
+                    "error": f"Trabajando en la modalidad: {name_mode_activate}"
+                },
+                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 nappingPufTest(self, request: HttpRequest):
+        maked_previus_napping = TecnicaModalidad.objects.get(
+            tecnica=self.session.tecnica)
+
+        self.context["maked_napping"] = True if maked_previus_napping else False
+        self.context["mode"] = "perfil ultra flash"
+        self.context["form"] = ListWordsForm()
+
+        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()
+        self.setWords()
+
+        return render(request, self.napping_puf_test, self.context)
+
+    def nappingSort(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.context["form"] = ListWordsForm()
+        self.setCoordinates()
+        self.setGroups()
+
+        return render(request, self.sort_direction, 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__id")
+        )
+
+        self.context["data_points"] = list(data_points)
+
+    def setGroups(self):
+        technique = self.session.tecnica
+
+        # Get all product groups for this tester
+        grupos_producto = GrupoProducto.objects.filter(
+            tecnica=technique,
+            catador=self.participation.catador
+        ).prefetch_related('productos', 'palabras')
+
+        groups = []
+        for group in grupos_producto:
+            # Get products in this group
+            products_list = []
+            for product in group.productos.all():
+                products_list.append({
+                    'id': product.id,
+                    'codigoProducto': product.codigoProducto
+                })
+
+            # Get words for this group
+            words_list = list(group.palabras.values_list(
+                'nombre_palabra', flat=True))
+
+            groups.append({
+                'id': group.id,
+                'products': products_list,
+                'words': words_list
+            })
+
+        self.context["groups"] = groups
+
+    def setWords(self):
+        technique = self.session.tecnica
+
+        ratings = Calificacion.objects.filter(
+            num_repeticion=0,
+            id_tecnica=technique,
+            id_catador=self.participation.catador
+        ).prefetch_related('palabras', 'id_producto')
+
+        words_by_product = {}
+        for rating in ratings:
+            product_code = rating.id_producto.codigoProducto
+            words_list = list(rating.palabras.values_list(
+                'nombre_palabra', flat=True))
+            if words_list:
+                words_by_product[product_code] = words_list
+
+        self.context["words_by_product"] = words_by_product
+
+    def controllPost(self, request: HttpRequest):
+        action = request.POST.get("action")
+
+        if action == "finish_session":
+            # Get technique and mode
+            technique = self.session.tecnica
+            self.participation = Participacion.objects.get(
+                tecnica=technique, catador=request.user.user_catador)
+
+            name_mode_activate = TecnicaModalidad.objects.get(
+                tecnica=technique).modalidad.nombre
+
+            # Validate based on mode
+            validation_error = self.validateSessionCompletion(
+                technique, name_mode_activate)
+
+            if validation_error:
+                # Return to the appropriate template with error
+                if name_mode_activate == "sin modalidad":
+                    return self.nappingTest(request)
+                elif name_mode_activate == "perfil ultra flash":
+                    return self.nappingPufTest(request)
+
+            # If validation passes, finish the session
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        # For other actions, call parent's controllPost
+        return super().controllPost(request)
+
+    def validateSessionCompletion(self, technique, mode_name):
+        # Get all products in technique
+        products = Producto.objects.filter(id_tecnica=technique)
+        product_count = products.count()
+
+        # Get all ratings for this tester
+        ratings = Calificacion.objects.filter(
+            num_repeticion=0,
+            id_tecnica=technique,
+            id_catador=self.participation.catador
+        ).select_related('id_producto').prefetch_related('palabras')
+
+        # Check if all products have ratings
+        if ratings.count() != product_count:
+            missing_count = product_count - ratings.count()
+            return f"Faltan {missing_count} producto(s) por evaluar."
+
+        # Check if all ratings have DatoPunto (coordinates)
+        ratings_with_points = DatoPunto.objects.filter(
+            calificacion__in=ratings
+        ).values_list('calificacion_id', flat=True)
+
+        ratings_without_points = ratings.exclude(id__in=ratings_with_points)
+        if ratings_without_points.exists():
+            missing_products = [
+                r.id_producto.codigoProducto for r in ratings_without_points
+            ]
+            return f"Los siguientes productos no tienen coordenadas: {', '.join(missing_products)}"
+
+        # Additional validation for "perfil ultra flash" mode
+        if mode_name == "perfil ultra flash":
+            # Check that each rating has at least one word
+            ratings_without_words = []
+            for rating in ratings:
+                if rating.palabras.count() < 1:
+                    ratings_without_words.append(
+                        rating.id_producto.codigoProducto)
+
+            if ratings_without_words:
+                return f"Los siguientes productos deben tener al menos 1 palabra: {', '.join(ratings_without_words)}"
+
+        # All validations passed
+        return None

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

@@ -0,0 +1,174 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Producto, Participacion, Palabra, Calificacion, ListaPalabras, Dato
+from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
+from tecnicas.forms import ListWordsForm
+from .general_test_controller import GenetalTestController
+
+
+class TestPFController(GenetalTestController):
+    skip_phases = 2
+
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+
+    def controllGet(self, request: HttpRequest, error=""):
+        self.participation = Participacion.objects.get(
+            tecnica=self.session.tecnica, catador=request.user.user_catador)
+        self.context["session"] = self.session
+
+        if error:
+            self.context["error"] = error
+
+        rep = self.session.tecnica.repeticion
+
+        if rep == 1:
+            self.current_directory = "tecnicas/forms_tester/test_pf_list_words.html"
+            response = self.getFirstPhase(request)
+        elif rep == 2:
+            self.current_directory = "tecnicas/forms_tester/test_pf_list_words.html"
+            response = self.getSecondPhase(request)
+        elif rep >= 3:
+            self.current_directory = "tecnicas/forms_tester/test_pf_rating_list.html"
+            response = self.getRepetitionPhase(request)
+        else:
+            response = self.getErrorRepetition(request)
+
+        return response
+
+    def controllPost(self, request: HttpRequest):
+        action = request.POST["action"]
+
+        if action == "finish_session":
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        else:
+            return self.controllGet(request, error="Acción no permitida")
+
+    def getFirstPhase(self, request: HttpRequest):
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["form"] = ListWordsForm()
+        self.context["initial_phase"] = True
+
+        try:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=False
+            )
+            list_words = list(tester_list.palabras.all())
+            self.context["words"] = list_words
+        except ListaPalabras.DoesNotExist:
+            self.context["words"] = []
+
+        return render(request, self.current_directory, self.context)
+
+    def getSecondPhase(self, request: HttpRequest):
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {
+                "code_sesion": self.session.codigo_sesion
+            }
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        try:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=True
+            )
+        except ListaPalabras.DoesNotExist:
+            tester_list = ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=False
+            )
+
+        list_words = list(tester_list.palabras.all())
+
+        self.context["form"] = ListWordsForm()
+        self.context["initial_phase"] = False
+        self.context["words"] = list_words
+
+        return render(request, self.current_directory, self.context)
+
+    def getRepetitionPhase(self, request: HttpRequest):
+        '''
+        - Obtener todos los productos que se evaluan en la tecnica
+        - Obtener todas las palabras de la lista de palabras del catador
+        - Para cada palabra, comprobar que el numero de Dato sea igual al numero de Productos
+        - Si no hay datos mandar esa palabra por contexto con todos los productos
+        - De las palabras que falten tomar la primera y mandarla en el contexto
+        - Mandar todos los productos por el contexto
+        Nota: Para esta fase no hay necesidad de mandar una escala, la escala se creara en el cliente
+        '''
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        technique = self.session.tecnica
+
+        # Obtener todos los productos que se evaluan en la técnica
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        # Obtener todas las palabras de la lista del catador (preferir lista final)
+        try:
+            words = list(ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=True
+            ).palabras.all())
+        except ListaPalabras.DoesNotExist:
+            words = []
+
+        use_word: Palabra = None
+
+        # Revisar que palabra no ha sido calificada en todos los productos
+        for word in words:
+            current_num_data = Dato.objects.filter(
+                id_calificacion__num_repeticion=technique.repeticion,
+                id_calificacion__id_tecnica=technique,
+                id_calificacion__id_catador=request.user.user_catador,
+                id_palabra=word
+            ).count()
+
+            if not current_num_data:
+                use_word = word
+                break
+            elif current_num_data < len(products_in_technique):
+                self.context["error"] = "Se ha detectado una inconsistencia en los datos que se deben calificar, algunos productos no han sido calificados"
+                return render(request, self.current_directory, self.context)
+
+        if not use_word:
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
+        self.context["word"] = use_word
+        self.context["products"] = products_in_technique
+        self.context["repetition"] = technique.repeticion - self.skip_phases
+
+        return render(request, self.current_directory, self.context)
+
+    def getErrorRepetition(self, request: HttpRequest):
+        params = {
+            "code_sesion": self.session.codigo_sesion
+        }
+        return redirect(reverse(self.previus_directory, kwargs=params))

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

@@ -0,0 +1,87 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from tecnicas.models import Participacion, Producto, Calificacion, Palabra
+from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
+from .general_test_controller import GenetalTestController
+
+
+class TestRataController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+        self.current_directory = "tecnicas/forms_tester/test_convencional.html"
+
+    def controllGet(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
+                )
+            except Calificacion.DoesNotExist:
+                # Si no hay calificacion mandamos el producto actual y todas la palabras
+                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
+        
+        if self.context["type_scale"] == "continua":
+            self.context["size_scale"] = {
+                "max_size": scale.longitud * 100,
+                "middle_size": (scale.longitud * 100)/2
+            }
+
+        return render(request, self.current_directory, self.context)