Implementacion de combinacion de datos para napping sin modalidad con datos de cata, rata o escalas

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/session_management/details/details_controller.py

@@ -14,6 +14,7 @@ class DetallesController():
 
     def controllGetResponse(self, request: HttpRequest, error: str = "", message: str = ""):
         context = self.getContext()
+        print(context)
 
         if error != "" or error:
             context["error"] = error

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()
@@ -51,6 +54,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 +231,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/templates/tecnicas/components/table-napping-combined.html

@@ -0,0 +1,100 @@
+{% 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="generic-donwload-table" class="min-w-max w-full text-sm text-center border-collapse">
+            <thead class="bg-surface-sweet font-semibold">
+                <tr>
+                    <th class="py-2 px-3 border border-surface-general">Producto</th>
+                    {% for tester in testers %}
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        X{{ forloop.counter }}
+                    </th>
+                    <th class="py-2 px-3 border border-surface-general uppercase">
+                        Y{{ forloop.counter }}
+                    </th>
+                    {% endfor %}
+                    {% 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-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 src="{% static 'js/download-table-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">