Guardado de datos de grupos en sesion con Sort

tecnicas/admin.py

@@ -14,7 +14,7 @@ from .models import Producto, Participacion
 
 from .models import Orden, Posicion
 
-from .models import Dato, ValorDecimal, ValorBooleano, Calificacion, ListaPalabras
+from .models import Dato, ValorDecimal, ValorBooleano, Calificacion, ListaPalabras, GrupoProducto
 
 # Register your models here.
 admin.site.register(CategoriaTecnica)
@@ -47,3 +47,4 @@ admin.site.register(ValorDecimal)
 admin.site.register(ValorBooleano)
 admin.site.register(Calificacion)
 admin.site.register(ListaPalabras)
+admin.site.register(GrupoProducto)

tecnicas/controllers/__init__.py

@@ -57,3 +57,4 @@ 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

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/static/js/test-sort.js

@@ -397,4 +397,112 @@ function getItemWord(wordName, code) {
 //////// Save data
 //////
 ////
-*/
+*/
+
+async function saveData() {
+    const keysDataGrups = Object.keys(DATA_GRUPS);
+    const allCodesProducts = new Set()
+
+    products.forEach((productElement) => {
+        allCodesProducts.add(productElement.getAttribute("data-code"))
+    })
+
+    if (keysDataGrups.length === 0) {
+        spanNotifaction("No hay grupos para guardar")
+        return false;
+    }
+
+    const data = []
+    let thereError = false;
+    const codesProducts = []
+
+    keysDataGrups.forEach((key) => {
+        if (thereError) return
+
+        const dataGrup = DATA_GRUPS[key];
+        if (!dataGrup) {
+            spanNotifaction("No hay datos para guardar")
+            thereError = true;
+            return
+        }
+
+        if (dataGrup.products.length === 0) {
+            spanNotifaction("Los grupos deben tener por lo menos un producto para guardar")
+            thereError = true;
+            return
+        }
+
+        if (dataGrup.words.length === 0) {
+            spanNotifaction("Los grupos deben tener por lo menos una palabra para guardar")
+            thereError = true;
+            return
+        }
+
+        const words = dataGrup.words;
+        const products = dataGrup.products;
+
+        codesProducts.push(...products.map((product) => product.code))
+
+        data.push({
+            words,
+            products
+        })
+    })
+
+    if (thereError) return false;
+
+    const currentCodesProducts = new Set(codesProducts)
+    const difference = symmetricDifference(currentCodesProducts, allCodesProducts)
+
+    if (difference.size > 0) {
+        spanNotifaction("Falta un producto que debe ser ordenado")
+        return false
+    }
+
+    const URL = "/cata/testers/api/rating-sort"
+    const csrfToken = document.querySelector('[name=csrfmiddlewaretoken]').value;
+
+    try {
+        const response = await fetch(URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-CSRFToken": csrfToken,
+            },
+            body: JSON.stringify(data),
+        })
+
+        if (!response.ok) {
+            spanNotifaction("Error en la respuesta del servidor")
+            return false;
+        }
+
+        const result = await response.json()
+
+        if (result.error) {
+            spanNotifaction(result.error)
+            return false
+        } else {
+            spanNotifaction(result.message, false)
+            return true
+        }
+    } catch (error) {
+        spanNotifaction("Error en proceso de guardar los datos")
+        return false
+    }
+}
+
+const buttonSaveData = document.getElementById("save-progress")
+buttonSaveData.addEventListener("click", saveData)
+
+function symmetricDifference(setA, setB) {
+    let _difference = new Set(setA);
+    for (let elem of setB) {
+        if (_difference.has(elem)) {
+            _difference.delete(elem);
+        } else {
+            _difference.add(elem);
+        }
+    }
+    return _difference;
+}

tecnicas/urls.py

@@ -147,4 +147,8 @@ urlpatterns = [
     path("testers/api/ratingword/pf/list",
          views.apiListWordsPF,
          name="api_rating_word_pf_list"),
+
+    path("testers/api/rating-sort",
+         views.ratingSort,
+         name="api_rating_sort"),
 ]

tecnicas/views/__init__.py

@@ -28,6 +28,7 @@ from .apis.api_words import wordsVocabulary
 from .apis.api_list_words_pf import apiListWordsPF
 from .apis.rating_word_scales import ratingWordScales
 from .apis.rating_word_cata import ratingWordCata
+from .apis.rating_sort import ratingSort
 
 from .tester_forms.init_tester_form import initTesterForm
 from .tester_forms.panel_main_tester import mainPanelTester

tecnicas/views/apis/rating_sort.py

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