Merge pull request #41 from CascoArcilla/HU5

Descarga de datos con nappging y remover modicacion de vocabularios

tecnicas/controllers/__init__.py

@@ -56,6 +56,7 @@ from .views_controller.sessions_tester.init_session.init_session_sort_controller
 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 .api_controller.rating_sacales_controller import RatingScalesController

tecnicas/controllers/models_controller/dato_controller.py

@@ -36,18 +36,18 @@ class DatoController():
             return controller_error(e.message)
 
     def setValue(self):
-        if isinstance(self.value_rating, bool):
+        type_technique = self.data.id_calificacion.id_tecnica.tipo_tecnica
+        if type_technique == "cata":
             self.value_data = ValorBooleano(valor=self.value_rating)
 
         else:
             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)
 

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -96,7 +96,9 @@ class PanelCodesController():
         }
 
         if form_codes.is_valid():
-            request.session["form_codes"] = codes
+            # 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"
@@ -133,7 +135,9 @@ class PanelCodesController():
         }
 
         if form_codes.is_valid():
-            request.session["form_codes"] = codes
+            # 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"

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

@@ -3,7 +3,11 @@ 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
+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
 
@@ -13,11 +17,10 @@ class DetallesNappingController(DetallesController):
         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.context["session"] = self.session
 
         self.defineStatus()
         self.setIsEndSession()
@@ -41,7 +44,6 @@ class DetallesNappingController(DetallesController):
             self.context["status"] = "Sesión con en curso"
 
     def controllPostResponse(self, request: HttpRequest, action: str):
-        print(action)
         if action == "start_sin_modalidad":
             response = self.startNapping(request=request)
 
@@ -51,6 +53,9 @@ class DetallesNappingController(DetallesController):
         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(
@@ -225,3 +230,279 @@ class DetallesNappingController(DetallesController):
         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/sessions_tester/tests_forms/test_rata_controller.py

@@ -77,5 +77,11 @@ class TestRataController(GenetalTestController):
 
         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)

tecnicas/controllers/views_controller/vocabulary_manage/create_vocabulary_controller.py

@@ -19,13 +19,6 @@ class CreateVocabularyController():
             "form_word": WordForm(),
             "words": []
         }
-
-        if "name_voca" in request.GET:
-            current = Vocabulario.objects.get(
-                nombre_vocabulario=request.GET["name_voca"])
-            self.context["name_vacabulary"] = current.nombre_vocabulario
-            self.context["words"] = current.palabras.all()
-
         return render(request, self.current_url, self.context)
 
     def controllPost(self, request: HttpRequest):
@@ -39,72 +32,28 @@ class CreateVocabularyController():
             return render(request, self.current_url, self.context)
 
         new_vocabulary_name = request.POST.get("nombre_vocabulario").strip()
-        is_update = request.POST.get("is_update")
-
-        print(is_update)
-
-        if is_update:
-            if "original_name" not in request.POST:
-                self.context["error"] = "Nombre original de vocabulario requerido"
-                return render(request, self.current_url, self.context)
 
-            original_name = request.POST["original_name"].strip()
-
-            if original_name != new_vocabulary_name:
-                if Vocabulario.objects.filter(nombre_vocabulario=new_vocabulary_name).exists():
-                    self.context["error"] = "Ya existe un vocabulario con el nombre pasado"
-                    return render(request, self.current_url, self.context)
+        try:
+            new_vocababulary = Vocabulario.objects.create(
+                nombre_vocabulario=new_vocabulary_name)
+        except IntegrityError:
+            self.context["error"] = "Ya existe un vocabulario con ese nombre"
+            return render(request, self.current_url, self.context)
 
+        words_json = request.POST.get("words", "")
+        if words_json:
             try:
-                current_vocababulary = Vocabulario.objects.get(
-                    nombre_vocabulario=original_name)
-            except Vocabulario.DoesNotExist:
-                self.context["error"] = "No existe un vocabulario con ese nombre"
-                return render(request, self.current_url, self.context)
-
-            words_json = request.POST.get("words", "")
-            if words_json:
-                try:
-                    words_list = json.loads(words_json)
+                words_list = json.loads(words_json)
 
-                    ids = [int(w.get("id", 0))
-                           for w in words_list if str(w.get("id", "")).isdigit()]
+                ids = [int(w.get("id", 0))
+                       for w in words_list if str(w.get("id", "")).isdigit()]
 
-                    words = Palabra.objects.filter(id__in=ids)
+                words = Palabra.objects.filter(id__in=ids)
 
-                    current_vocababulary.palabras.set(words)
-                    current_vocababulary.nombre_vocabulario = new_vocabulary_name
-                    current_vocababulary.save()
-                except (json.JSONDecodeError, ValueError):
-                    self.context["error"] = 'Ocurrió un error al revisar las palabras, revise “Ver vocabularios”, para reasignar las palabras'
-                    return render(request, self.current_url, self.context)
-
-            self.context["message"] = 'Vocabulario creado con éxito, puedes revisarlo en "Ver vocabularios"'
-            return render(request, self.current_url, self.context)
-        elif not is_update:
-            try:
-                new_vocababulary = Vocabulario.objects.create(
-                    nombre_vocabulario=new_vocabulary_name)
-            except IntegrityError:
-                self.context["error"] = "Ya existe un vocabulario con ese nombre"
+                new_vocababulary.palabras.add(*words)
+            except (json.JSONDecodeError, ValueError):
+                self.context["error"] = 'Ocurrió un error al revisar las palabras, revise “Ver vocabularios”, para reasignar las palabras'
                 return render(request, self.current_url, self.context)
 
-            words_json = request.POST.get("words", "")
-            if words_json:
-                try:
-                    words_list = json.loads(words_json)
-
-                    ids = [int(w.get("id", 0))
-                           for w in words_list if str(w.get("id", "")).isdigit()]
-
-                    words = Palabra.objects.filter(id__in=ids)
-
-                    new_vocababulary.palabras.add(*words)
-                except (json.JSONDecodeError, ValueError):
-                    self.context["error"] = 'Ocurrió un error al revisar las palabras, revise “Ver vocabularios”, para reasignar las palabras'
-                    return render(request, self.current_url, self.context)
-
-            self.context["message"] = 'Vocabulario actualziado con éxito, puedes revisarlo en "Ver vocabularios"'
-            return render(request, self.current_url, self.context)
-        else:
-            pass
+        self.context["message"] = 'Vocabulario creado con éxito, puedes revisarlo en "Ver vocabularios"'
+        return render(request, self.current_url, self.context)

tecnicas/controllers/views_controller/vocabulary_manage/list_vocabulary_controller.py

@@ -40,7 +40,7 @@ class ListVocabularyController():
             return controller_error("índice inválido")
 
         if not vocabularies_in_page.object_list:
-            return controller_error("Sin registros de Participaciones")
+            return controller_error("Sin registros de Vocabularios")
 
         current_page = vocabularies_in_page.number
         is_last_page = not current_page < paginator.num_pages

tecnicas/controllers/views_controller/vocabulary_manage/view_vocabulary_controller.py

@@ -0,0 +1,28 @@
+from django.shortcuts import render
+from django.http import HttpRequest
+from tecnicas.models import Vocabulario
+
+
+class ViewVocabularyController():
+    context = {}
+    current_url = "tecnicas/manage_vocabulary/view-vocabulary.html"
+
+    def __init__(self):
+        self.context = {}
+
+    def controllGet(self, request: HttpRequest, nombre_vocabulario: str):
+        try:
+            vocabulary = Vocabulario.objects.get(
+                nombre_vocabulario=nombre_vocabulario)
+            
+            self.context = {
+                "vocabulary": vocabulary,
+                "words": vocabulary.palabras.all().order_by('nombre_palabra')
+            }
+            
+        except Vocabulario.DoesNotExist:
+            self.context = {
+                "error": f"No existe un vocabulario con el nombre '{nombre_vocabulario}'"
+            }
+
+        return render(request, self.current_url, self.context)

tecnicas/forms/catador_form.py

@@ -138,8 +138,6 @@ class CatadorForm(forms.Form):
         username = cleaned_data.get("nombre_usuario")
         is_update = cleaned_data.get("is_update")
 
-        print(username, is_update)
-
         if not is_update:
             if User.objects.filter(username__iexact=username).exists():
                 raise forms.ValidationError(

tecnicas/forms/codes_form.py

@@ -9,3 +9,11 @@ class CodesForm(forms.Form):
             self.fields[f'producto_{index+1}'] = forms.CharField(max_length=3, required=True, min_length=3, initial=code, label=f"codigo {index+1}", widget=forms.TextInput(attrs={
                 "class": "ct-code bg-surface-ligt p-1 border-b-1 text-center w-full disabled:bg-surface-general uppercase"
             }))
+
+    def clean(self):
+        cleaned_data = super().clean()
+        # Convert all product codes to uppercase
+        for field_name, value in cleaned_data.items():
+            if field_name.startswith('producto_') and value:
+                cleaned_data[field_name] = value.upper()
+        return cleaned_data

tecnicas/static/js/created-vocabulary.js

@@ -1,7 +1,7 @@
 // **************************************
 // Create Vocabulary
 // **************************************
-async function submitSelectWords(classNanmeForm, update = false) {
+async function submitSelectWords(classNanmeForm) {
   const form = document.querySelector(`.${classNanmeForm}`);
 
   const name_vocabulary = form.querySelector(".cts-name-voca").value;
@@ -20,29 +20,7 @@ async function submitSelectWords(classNanmeForm, update = false) {
   wordsInput.name = "words";
   wordsInput.value = JSON.stringify(listWordsSelect);
 
-  const [isUpdata, orinalName] = inputIsUpdateVocabulary(update);
-
   form.appendChild(wordsInput);
-  form.appendChild(isUpdata);
-  if (orinalName) form.appendChild(orinalName);
 
   form.submit();
 }
-
-function inputIsUpdateVocabulary(is_update = false) {
-  const isUpdata = document.createElement("input");
-  isUpdata.type = "hidden";
-  isUpdata.name = "is_update";
-  isUpdata.value = is_update;
-
-  if (is_update) {
-    const orinalName = document.querySelector(".cts-original-name").textContent;
-    const inputName = document.createElement("input");
-    inputName.type = "hidden";
-    inputName.name = "original_name";
-    inputName.value = orinalName;
-    return [isUpdata, inputName];
-  }
-
-  return [isUpdata, is_update];
-}

tecnicas/templates/tecnicas/components/item_vocabulary.html

@@ -10,9 +10,9 @@
             </div>
         </div>
         <div>
-            <a href="{% url 'cata_system:crear_vocabulario' %}?name_voca={{vocabulary.nombre_vocabulario}}">
+            <a href="{% url 'cata_system:ver_vocabulario' nombre_vocabulario=vocabulary.nombre_vocabulario %}">
                 <button class="btn bg-btn-primary border-0 block w-full btn-push">
-                    Revisar Vocabulario
+                    Ver Detalles
                 </button>
             </a>
         </div>

tecnicas/templates/tecnicas/components/table-napping-combined.html

@@ -0,0 +1,174 @@
+{% load static %}
+{% load custom_filters %}
+<article class="space-y-4 text-black">
+    <!-- Session B Information -->
+    <div class="bg-surface-card p-4 rounded-lg space-y-2">
+        <h3 class="font-bold text-lg">Información de la Sesión B</h3>
+        <div class="grid grid-cols-2 max-sm:grid-cols-1 gap-2 text-sm">
+            <p><span class="font-semibold">Código:</span> {{ session_b.codigo_sesion }}</p>
+            <p><span class="font-semibold">Técnica:</span> {{ technique_type }}</p>
+            <p><span class="font-semibold">Nombre:</span> {{ session_b.nombre_sesion|default:"Sin nombre" }}</p>
+            <p><span class="font-semibold">Catadores:</span> {{ testers|length }}</p>
+            
+            {% if combined_data.vocabulary_info %}
+            <p class="col-span-2 max-sm:col-span-1">
+                <span class="font-semibold">Vocabulario:</span> {{ combined_data.vocabulary_info.nombre }}
+            </p>
+            {% endif %}
+            
+            {% if combined_data.scale_info %}
+            <p><span class="font-semibold">Escala:</span> {{ combined_data.scale_info.type }}</p>
+            <p><span class="font-semibold">Longitud:</span> {{ combined_data.scale_info.size }}</p>
+            {% endif %}
+            
+            {% if combined_data.num_repetitions %}
+            <p><span class="font-semibold">Repeticiones:</span> {{ combined_data.num_repetitions }}</p>
+            {% endif %}
+            
+            <p class="col-span-2 max-sm:col-span-1">
+                <span class="font-semibold">Palabras utilizadas:</span> 
+                {{ combined_data.all_words|join:", " }}
+            </p>
+        </div>
+    </div>
+
+    <!-- Combined Data Table -->
+    <div class="overflow-x-auto rounded-lg border border-surface-general">
+        <table id="combined-table-download" class="min-w-max w-full text-sm text-center border-collapse">
+            <thead class="bg-surface-sweet font-semibold">
+                <tr>
+                    <th class="py-2 px-3 border border-surface-general">Producto</th>
+                    {% for tester in testers %}
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        X{{ forloop.counter }}
+                    </th>
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        Y{{ forloop.counter }}
+                    </th>
+                    {% endfor %}
+                    {% for word in combined_data.all_words %}
+                    <th class="py-2 px-3 border border-surface-general capitalize">
+                        {{ word }}
+                    </th>
+                    {% endfor %}
+                </tr>
+            </thead>
+            <tbody class="bg-surface-ligt divide-y divide-gray-200">
+                {% for product, coordinates_tester in coordinates_no_mode.items %}
+                <tr>
+                    <td class="py-2 px-3 border border-surface-general">{{ product }}</td>
+                    {% for tester in testers %}
+                    {% with points=coordinates_tester|get_item:tester.user.username %}
+                    <td class="py-2 px-3 border border-surface-general">
+                        {{ points.px }}
+                    </td>
+                    <td class="py-2 px-3 border border-surface-general">
+                        {{ points.py }}
+                    </td>
+                    {% endwith %}
+                    {% endfor %}
+                    {% for word in combined_data.all_words %}
+                    <td class="py-2 px-3 border border-surface-general">
+                        {% if combined_data.word_frequencies %}
+                            {% with freq=combined_data.word_frequencies|get_item:product|get_item:word %}
+                                {% if freq %}{{ freq }}{% else %}0{% endif %}
+                            {% endwith %}
+                        {% elif combined_data.word_averages %}
+                            {% with avg=combined_data.word_averages|get_item:product|get_item:word %}
+                                {% if avg %}{{ avg|floatformat:2 }}{% else %}0.00{% endif %}
+                            {% endwith %}
+                        {% else %}
+                            0
+                        {% endif %}
+                    </td>
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+
+    <div class="flex justify-end">
+        <button id="download-combined-csv-btn" class="cts-btn-general cts-btn-primary btn-push"
+            data-session-name="{{ session.nombre_sesion }}_combinado_{{ session_b.codigo_sesion }}" 
+            data-session-code="{{ session.codigo_sesion }}">
+            Descargar datos combinados en CSV
+        </button>
+    </div>
+</article>
+
+<script>
+(function() {
+  const btn = document.getElementById("download-combined-csv-btn");
+  if (!btn) return;
+
+  btn.addEventListener("click", function () {
+    const table = document.getElementById("combined-table-download");
+    if (!table) {
+      console.warn("No se encontró la tabla combinada para descargar.");
+      return;
+    }
+
+    // helper to trim and normalize cell text
+    const cellText = (cell) => {
+      if (!cell) return "";
+      return String(cell.textContent || "").trim();
+    };
+
+    // Collect headers
+    const headers = [];
+    const ths = table.querySelectorAll("thead th");
+    ths.forEach((th) => headers.push(cellText(th)));
+
+    // Collect rows
+    const rows = [];
+    const trs = table.querySelectorAll("tbody tr");
+    trs.forEach((tr) => {
+      const cols = [];
+      const tds = tr.querySelectorAll("td");
+      tds.forEach((td) => cols.push(cellText(td)));
+      rows.push(cols);
+    });
+
+    // Convert to CSV string (escape quotes, wrap in quotes if needed)
+    const escapeValue = (val) => {
+      if (val == null) return "";
+      const normalVal = val.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+      const needsQuotes = /[",\n,]/.test(normalVal);
+      let v = String(normalVal).replace(/"/g, '""');
+      if (needsQuotes) v = `"${v}"`;
+      return v;
+    };
+
+    const lines = [];
+    if (headers.length) lines.push(headers.map(escapeValue).join(","));
+    rows.forEach((r) => lines.push(r.map(escapeValue).join(",")));
+
+    const csvContent = lines.join("\n");
+
+    // File name: data_{nombre_sesion or codigo_sesion}
+    const rawName = (btn.dataset.sessionName || "").trim();
+    const code = (btn.dataset.sessionCode || "").trim() || "session";
+    const namePart = rawName
+      ? rawName.replace(/[^a-zA-Z0-9-_áéíóúÁÉÍÓÚ ]/g, "").replace(/\s+/g, "_")
+      : code;
+    const fileName = `data_${namePart}.csv`;
+
+    // Create blob and force download
+    const blob = new Blob([csvContent], { type: "text/csv;charset=UTF-8;" });
+    if (navigator.msSaveBlob) {
+      navigator.msSaveBlob(blob, fileName);
+    } else {
+      const link = document.createElement("a");
+      const url = URL.createObjectURL(blob);
+      link.setAttribute("href", url);
+      link.setAttribute("download", fileName);
+      link.style.visibility = "hidden";
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      URL.revokeObjectURL(url);
+    }
+  });
+})();
+</script>

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

@@ -38,4 +38,14 @@
             </tbody>
         </table>
     </div>
-</article>
+
+    <div class="flex justify-end">
+        <button id="download-csv-btn" class="cts-btn-general cts-btn-primary btn-push"
+            data-session-name="{{ session.nombre_sesion }}" data-session-code="{{ session.codigo_sesion }}">
+            Descargar datos en CSV
+        </button>
+    </div>
+</article>
+
+{% load static %}
+<script src="{% static 'js/download-table-csv.js' %}"></script>

tecnicas/templates/tecnicas/components/table-napping-puf.html

@@ -50,4 +50,14 @@
             </tbody>
         </table>
     </div>
+
+    <div class="flex justify-end">
+        <button id="download-csv-btn" class="cts-btn-general cts-btn-primary btn-push"
+            data-session-name="{{ session.nombre_sesion }}" data-session-code="{{ session.codigo_sesion }}">
+            Descargar datos en CSV
+        </button>
+    </div>
 </article>
+
+{% load static %}
+<script src="{% static 'js/download-table-csv.js' %}"></script>

tecnicas/templates/tecnicas/components/table-napping-sorting.html

@@ -44,4 +44,14 @@
             </tbody>
         </table>
     </div>
+
+    <div class="flex justify-end">
+        <button id="download-csv-btn" class="cts-btn-general cts-btn-primary btn-push"
+            data-session-name="{{ session.nombre_sesion }}" data-session-code="{{ session.codigo_sesion }}">
+            Descargar datos en CSV
+        </button>
+    </div>
 </article>
+
+{% load static %}
+<script src="{% static 'js/download-table-sort-csv.js' %}"></script>

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

@@ -203,6 +203,49 @@
         {% include "../components/error-message.html" with message='Sin datos por mostrar aún' %}
         {% endif %}
 
+        {% if mode == "sin modalidad" and finished %}
+        <p class="text-black font-bold text-2xl border-b-2">
+            Combinar datos con otra sesión
+        </p>
+        <article class="space-y-4 text-black bg-surface-card p-4 rounded-2xl">
+            <p class="text-lg">
+                Puede combinar los datos de esta sesión de Napping con otra sesión que use CATA, RATA o Escalas.
+                Ambas sesiones deben tener los mismos productos y catadores
+            </p>
+            
+            <form method="post" class="space-y-4">
+                {% csrf_token %}
+                <input type="hidden" name="action" value="combine_sessions">
+                
+                <div class="flex flex-col gap-2">
+                    <label for="session_b_code" class="font-semibold">
+                        Código de la sesión a combinar:
+                    </label>
+                    <div class="flex gap-2 max-sm:flex-col">
+                        <input 
+                            type="text" 
+                            id="session_b_code" 
+                            name="session_b_code" 
+                            class="flex-1 px-4 py-2 border border-surface-general rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+                            placeholder="Ingrese el código de sesión"
+                            required
+                        >
+                        <button type="submit" class="cts-btn-general cts-btn-primary btn-push">
+                            Validar y Combinar
+                        </button>
+                    </div>
+                </div>
+            </form>
+        </article>
+        {% endif %}
+
+        {% if combined_data %}
+        <p class="text-black font-bold text-2xl border-b-2 mt-8">
+            Datos Combinados (Napping + {{ session_b_technique_type }})
+        </p>
+        {% include "../components/table-napping-combined.html" with session=session session_b=session_b technique_type=session_b_technique_type combined_data=combined_data testers=testers coordinates_no_mode=coordinates_no_mode %}
+        {% endif %}
+
 
         <form action="" method="post" class="form-action-session hidden">
             <input type="hidden" name="action" class="action-option">

tecnicas/templates/tecnicas/manage_vocabulary/create-vocabulary.html

@@ -26,15 +26,9 @@
             <form action="" method="post" class="cts-craed-vocabulary bg-surface-card p-4 rounded-lg">
                 {% csrf_token %}
                 <label for="nombre_vocabulario" class="font-bold text-2xl mb-2 block">Nombre del vocabulario</label>
-                {% if name_vacabulary %}
-                <input id="nombre_vocabulario" name="nombre_vocabulario" type="text" required
-                    class="cts-name-voca p-2 px-4 bg-surface-ligt rounded-lg w-full text-lg font-medium"
-                    placeholder="Ingrese un nombre" value="{{ name_vacabulary }}">
-                {% else %}
                 <input id="nombre_vocabulario" name="nombre_vocabulario" type="text" required
                     class="cts-name-voca p-2 px-4 bg-surface-ligt rounded-lg w-full text-lg font-medium"
                     placeholder="Ingrese un nombre">
-                {% endif %}
                 <p class="text-lg mt-2 font-semibold">Debajo puede buscar y seleccionar palabras para asignarlas a
                     este vocabulario.</p>
             </form>
@@ -105,22 +99,11 @@
                 </p>
             </form>
 
-            {% if name_vacabulary %}
-            <p class="hidden cts-original-name">{{ name_vacabulary }}</p>
-            {% endif %}
-
             <article class="flex justify-center gap-4 mt-4">
-                {% if name_vacabulary %}
-                <button type="button" name="start" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full"
-                    onclick="submitSelectWords('cts-craed-vocabulary', true)">
-                    Actualizar vocabulario
-                </button>
-                {% else %}
                 <button type="button" name="start" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full"
                     onclick="submitSelectWords('cts-craed-vocabulary')">
                     Crear vocabulario
                 </button>
-                {% endif %}
                 <a href="{% url 'cata_system:panel_vocabulario' %}" class="flex-1 w-full">
                     <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
                         Cancelar

tecnicas/templates/tecnicas/manage_vocabulary/panel-vocabulary.html

@@ -19,7 +19,7 @@
         </header>
         <section class="flex flex-col gap-7">
                 <div class="w-full h-40 rounded-lg max-sm:hidden">
-                    <img src="{% static 'img/letters.webp' %}" alt="varias personas en fila"
+                    <img src="{% static 'img/words.webp' %}" alt="varias personas en fila"
                         class="w-full h-full object-cover rounded-xl">
                 </div>
                 <a href="{% url 'cata_system:crear_vocabulario' %}" class="flex-1">
@@ -33,7 +33,7 @@
                     </button>
                 </a>
                 <div class="w-full h-40 rounded-lg min-sm:hidden">
-                    <img src="{% static 'img/letters.webp' %}" alt="varias personas en fila"
+                    <img src="{% static 'img/words.webp' %}" alt="varias personas en fila"
                         class="w-full h-full object-cover rounded-xl">
                 </div>
             </section>

tecnicas/templates/tecnicas/manage_vocabulary/view-vocabulary.html

@@ -0,0 +1,85 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Ver Vocabulario{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content">
+        <header class="text-center flex flex-row max-sm:flex-col gap-8 items-center w-full mb-6">
+            <div class="bg-surface-card p-4 text-black shadow-lg rounded-xl flex-1">
+                <h1 class="font-bold text-2xl">Detalles del Vocabulario</h1>
+            </div>
+            <div class="flex-1 flex justify-end items-center">
+                <a href="{% url 'cata_system:lista_vocabulario' num_page=1 %}" class="w-fit">
+                    <button class="cts-btn-general cts-btn-secondary btn-push">
+                        Volver a la Lista
+                    </button>
+                </a>
+            </div>
+        </header>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        
+        <div class="flex justify-center mt-6">
+            <a href="{% url 'cata_system:lista_vocabulario' num_page=1 %}">
+                <button class="cts-btn-general cts-btn-primary btn-push">
+                    Ir a Lista de Vocabularios
+                </button>
+            </a>
+        </div>
+
+        {% else %}
+        <section class="bg-surface-card p-6 rounded-lg shadow-lg space-y-6 text-black">
+            <!-- Información del Vocabulario -->
+            <div class="space-y-4">
+                <div class="bg-surface-alter-card p-4 rounded-lg">
+                    <p class="font-bold text-xl mb-2">Nombre del Vocabulario:</p>
+                    <p class="text-2xl font-semibold text-btn-primary">{{ vocabulary.nombre_vocabulario }}</p>
+                </div>
+
+                <div class="bg-surface-alter-card p-4 rounded-lg">
+                    <p class="font-bold text-lg mb-2">Fecha de Creación:</p>
+                    <p class="text-lg">{{ vocabulary.creado|date:"d/m/Y H:i" }}</p>
+                </div>
+
+                <div class="bg-surface-alter-card p-4 rounded-lg">
+                    <p class="font-bold text-lg mb-2">Total de Palabras:</p>
+                    <p class="text-lg">{{ words|length }}</p>
+                </div>
+            </div>
+
+            <!-- Lista de Palabras -->
+            <div class="mt-6">
+                <h2 class="font-bold text-2xl mb-4 text-center">Palabras del Vocabulario</h2>
+                <hr class="mb-4">
+                
+                {% if words %}
+                <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+                    {% for word in words %}
+                    <div class="bg-gray-200 text-black rounded-lg font-medium text-lg px-4 py-3 text-center shadow">
+                        {{ word.nombre_palabra }}
+                    </div>
+                    {% endfor %}
+                </div>
+                {% else %}
+                <div class="text-center py-8">
+                    <p class="text-xl text-gray-500">Este vocabulario no tiene palabras asociadas</p>
+                </div>
+                {% endif %}
+            </div>
+        </section>
+
+        <!-- Botón adicional para volver -->
+        <div class="flex justify-center mt-6">
+            <a href="{% url 'cata_system:lista_vocabulario' num_page=1 %}" class="w-full max-w-md">
+                <button class="cts-btn-general cts-btn-error btn-push w-full">
+                    Volver a la Lista
+                </button>
+            </a>
+        </div>
+        {% endif %}
+    </article>
+</article>
+{% endblock %}

tecnicas/urls.py

@@ -53,6 +53,10 @@ urlpatterns = [
          views.createVocabulary,
          name="crear_vocabulario"),
 
+    path("presenter/ver-vocabulario/<str:nombre_vocabulario>",
+         views.viewVocabulary,
+         name="ver_vocabulario"),
+
     path("presenter/lista-vocabulario/<int:num_page>",
          views.listVocabulary,
          name="lista_vocabulario"),

tecnicas/views/__init__.py

@@ -20,6 +20,7 @@ from .tester_management.tester_list import testerList
 
 from .vocabulary_management.vocabulry_menu import vocabularyMenu
 from .vocabulary_management.create_vocabulary import createVocabulary
+from .vocabulary_management.view_vocabulary import viewVocabulary
 from .vocabulary_management.list_vocabulary import listVocabulary
 
 from .apis.api_tag import newTag

tecnicas/views/vocabulary_management/view_vocabulary.py

@@ -0,0 +1,13 @@
+from django.shortcuts import render
+from django.http import HttpRequest
+from tecnicas.controllers import ViewVocabularyController
+
+
+def viewVocabulary(req: HttpRequest, nombre_vocabulario: str):
+    view_controller = ViewVocabularyController()
+    if req.method == "GET":
+        response = view_controller.controllGet(req, nombre_vocabulario)
+        return response
+    else:
+        context = {"error": "Método no permitido"}
+        return render(req, "tecnicas/manage_vocabulary/view-vocabulary.html", context)