Catador puede crear su lista de palabras

tecnicas/controllers/__init__.py

@@ -31,9 +31,11 @@ from .views_controller.session_management.monitor_pf_controller import MonitorPF
 
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
-from .views_controller.sessions_tester.test_scales_controller import TestScalesController
-from .views_controller.sessions_tester.test_rata_controller import TestRataController
-from .views_controller.sessions_tester.test_cata_controller import TestCataController
+
+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.init_session.init_session_escalas_controller import InitSessionEscalasController
 from .views_controller.sessions_tester.init_session.init_session_rata_controller import InitSessionRATAController

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

@@ -4,18 +4,13 @@ from django.urls import reverse
 from tecnicas.models import Participacion, Producto, Dato, ListaPalabras
 from tecnicas.controllers import ParticipacionController
 from .init_session_controller import InitSessionController
-from tecnicas.utils import controller_error
 
 
 class InitSessionPFController(InitSessionController):
-    pf_ph1_direcction = "cata_system:session_pf_ph1"
-    pf_ph2_direcction = "cata_system:session_pf_ph2"
-    pf_rep_direcction = "cata_system:session_pf_rep"
-
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
         self.current_direction = "tecnicas/forms_tester/init_session_pf.html"
-        self.pf_direction = "cata_system:session_convencional"
+        self.pf_direction = "cata_system:session_pf"
 
     def controllGet(self, request: HttpRequest):
         context = {
@@ -61,17 +56,14 @@ class InitSessionPFController(InitSessionController):
 
             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))
+            return redirect(reverse(self.pf_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)
+            return self.controllGet(request)
 
         else:
             context["error"] = "Acción sin especificar"

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

@@ -0,0 +1,137 @@
+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
+from tecnicas.controllers import ParticipacionController, PalabrasController
+from tecnicas.forms import ListWordsForm
+from .general_test_controller import GenetalTestController
+
+
+class TestPFController(GenetalTestController):
+    def __init__(self, sensorial_session, user_tester):
+        super().__init__(sensorial_session, user_tester)
+
+    def controllGet(self, request: HttpRequest):
+        self.participation = Participacion.objects.get(
+            tecnica=self.session.tecnica, catador=request.user.user_catador)
+        self.context["session"] = self.session
+
+        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:
+            response = self.getSecondPhase(request)
+        elif rep >= 3:
+            response = self.getRepetitionPhase(request)
+        else:
+            response = self.getErrorRepetition(request)
+
+        return response
+
+    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
+
+        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))
+
+        list_words = list(
+            ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=False
+            ).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):
+        technique = self.session.tecnica
+
+        products_in_technique = Producto.objects.filter(id_tecnica=technique)
+
+        words = list(
+            ListaPalabras.objects.get(
+                tecnica=self.session.tecnica,
+                catador=request.user.user_catador,
+                es_final=True
+            ).palabras.all()
+        )
+
+        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
+
+        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/forms/__init__.py

@@ -8,3 +8,5 @@ from .codes_form import CodesForm
 from .catador_form import CatadorForm
 from .word_form import WordForm
 from .vocabulary_select import VocabularioSelectForm
+
+from .list_words_form import ListWordsForm

tecnicas/forms/list_words_form.py

@@ -0,0 +1,50 @@
+from django import forms
+import re
+
+
+class ListWordsForm(forms.Form):
+    regex = re.compile(r'^[a-zñ]{3,}$')
+
+    def __init__(self, *args, new_words=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        new_words = new_words or []
+
+        if not new_words:
+            self.fields['nombre_palabra'] = forms.CharField(
+                label='Nombre de la palabra',
+                max_length=255,
+                widget=forms.TextInput(attrs={
+                    'placeholder': 'Escribe una palabra',
+                    'class': 'cts-input-list-word bg-surface-ligt p-1 border-b-1 text-center w-full',
+                    'pattern': self.regex.pattern,
+                    'title': 'Solo letras minúsculas y la letra ñ, no poner acentos. No se permiten mayúsculas ni caracteres especiales. Mínimo 3 letras',
+                })
+            )
+        else:
+            for index, name in enumerate(new_words, start=1):
+                self.fields[f'nombre_palabra_{index}'] = forms.CharField(
+                    label=f'Palabra {index}',
+                    max_length=255,
+                    initial=name,
+                    widget=forms.TextInput(attrs={
+                        'placeholder': 'Escribe una palabra',
+                        'class': 'cts-input-list-word bg-surface-ligt p-1 border-b-1 text-center w-full',
+                        'pattern': self.regex.pattern,
+                        'title': 'Solo letras minúsculas y la letra ñ. No se permiten mayúsculas ni caracteres especiales.'
+                    })
+                )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        errores = []
+
+        for field_name, value in cleaned_data.items():
+            if not self.regex.match(value):
+                errores.append(f"'{value}' contiene caracteres no permitidos.")
+            elif len(value) > 255:
+                errores.append(f"'{value}' excede los 255 caracteres.")
+
+        if errores:
+            raise forms.ValidationError(errores)
+
+        return cleaned_data

tecnicas/static/js/pf-make-list.js

@@ -0,0 +1,143 @@
+const FORM_DESCRIBE = document.querySelector(".cts-form-pf-word");
+const BOX_WORDS = document.querySelector(".cts-box-words");
+const IMG_LIST = document.querySelector(".cts-img-list");
+const ERROR_INPUT_WORD = document.querySelector(".error-input-word");
+
+const WORDS = [];
+const STYLES_LI = [
+  "cts-item-words",
+  "bg-gray-400",
+  "text-black",
+  "rounded",
+  "font-bold",
+  "text-lg",
+  "px-4",
+  "py-3",
+  "flex",
+  "flex-wrap",
+  "flex-row",
+  "flex-1",
+  "min-w-fit",
+  "justify-center",
+  "items-center",
+  "gap-3",
+];
+
+const STYLES_BTN = [
+  "cts-remove-word",
+  "px-4",
+  "border-b-2",
+  "active:border-b-0",
+  "active:border-t-2",
+  "transition-all",
+  "rounded-xl",
+  "font-black",
+  "w-fit",
+  "capitalize",
+  "active:border-red-500",
+  "border-red-800",
+  "bg-red-500",
+];
+
+const itemWord = (wordName, index) => {
+  const btn = document.createElement("button");
+  btn.setAttribute("data-index", index);
+  btn.classList.add(...STYLES_BTN);
+  btn.textContent = "➖";
+
+  const ph = document.createElement("p");
+  ph.classList.add("ct-word-received");
+  ph.textContent = wordName;
+
+  const li = document.createElement("li");
+  li.setAttribute("id", `word-${index}`);
+  li.classList.add(...STYLES_LI);
+
+  li.appendChild(ph);
+  li.appendChild(btn);
+
+  return li;
+};
+
+function initWordsFromBox() {
+  if (!BOX_WORDS) return;
+  const current_words = BOX_WORDS.querySelectorAll(".cts-item-words");
+  if (!current_words.length) return;
+
+  WORDS.length = 0;
+  current_words.forEach((li) => {
+    const p = li.querySelector(".ct-word-received");
+    const text = p ? p.textContent.trim() : li.textContent.trim();
+    if (text) WORDS.push(text);
+  });
+  renderWords();
+}
+
+function renderWords() {
+  if (!BOX_WORDS) return;
+  if (!WORDS.length) {
+    BOX_WORDS.innerHTML = "";
+    IMG_LIST.classList.remove("hidden");
+    BOX_WORDS.appendChild(IMG_LIST);
+    return;
+  }
+
+  BOX_WORDS.innerHTML = "";
+  WORDS.forEach((word, index) => {
+    let liElement = itemWord(word, index);
+    BOX_WORDS.appendChild(liElement);
+  });
+
+  const removeButtons = BOX_WORDS.querySelectorAll("button.cts-remove-word");
+  removeButtons.forEach((btn) => {
+    btn.addEventListener("click", (e) => {
+      const idx = parseInt(btn.dataset.index);
+      if (!Number.isNaN(idx)) {
+        WORDS.splice(idx, 1);
+        renderWords();
+      }
+    });
+  });
+}
+
+function setupDescribeFormToAddWord() {
+  if (!FORM_DESCRIBE) return;
+  FORM_DESCRIBE.addEventListener("submit", (e) => {
+    e.preventDefault();
+
+    if (!FORM_DESCRIBE.reportValidity()) {
+      return;
+    }
+
+    const input = FORM_DESCRIBE.querySelector('input[type="text"]');
+    if (!input) return;
+
+    const value = input.value.trim();
+    if (!value) return;
+
+    if (WORDS.includes(value)) {
+      notifactionError("Esa palabra ya está en la lista");
+      return;
+    }
+
+    WORDS.push(value);
+    renderWords();
+
+    input.value = "";
+    input.focus();
+  });
+}
+
+function notifactionError(messageError) {
+  ERROR_INPUT_WORD.textContent = messageError;
+  ERROR_INPUT_WORD.classList.remove("hidden");
+  setTimeout(() => {
+    ERROR_INPUT_WORD.textContent = "";
+    ERROR_INPUT_WORD.classList.add("hidden");
+  }, 3000);
+}
+
+window.addEventListener("DOMContentLoaded", () => {
+  initWordsFromBox();
+  setupDescribeFormToAddWord();
+});

tecnicas/templates/tecnicas/forms_tester/test_pf_list_words.html

@@ -0,0 +1,129 @@
+{% extends 'tecnicas/layouts/base.html' %}
+
+{% load static %}
+
+{% block title %}Convencional{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black max-w-4xl">
+        <header class="text-center flex-row w-full items-stretch flex justify-around flex-wrap gap-2">
+            <h1 class="rounded font-bold text-2xl bg-surface-ligt p-4 flex-1">
+                Sesión usando <br>técnica
+                <span class="uppercase">{{ session.tecnica.tipo_tecnica }}</span>
+            </h1>
+            <button class="cts-btn-general cts-btn-error btn-push" onclick="exit_sesion('form-actions')">
+                Salir de la sesión
+            </button>
+        </header>
+
+        <article class="hidden">
+            <form action="{% url 'cata_system:catador_init_session' code_sesion=session.codigo_sesion %}" method="post"
+                class="form-actions">
+                {% csrf_token %}
+                <input type="hidden" name="action" class="action-input">
+            </form>
+        </article>
+
+        <section class="hidden">
+            <input type="hidden" value="{{ session.tecnica.id }}" name="id-tecnica" class="ct-input-id-tech">
+        </section>
+
+        {% if error %}
+        <hr>
+        <article class="bg-red-600 p-4 text-white rounded-xl ct-notification-error">
+            <p class="block font-sans text-white text-xl antialiased font-bold uppercase tracking-wider text-center">
+                {{ error }}
+            </p>
+        </article>
+        {% endif %}
+
+        <article class="rounded flex flex-col gap-4">
+            <section class="flex items-center justify-center bg-surface-ligt p-2 rounded-lg">
+                <p class="text-lg font-medium text-center">
+                    {{ session.tecnica.instrucciones }}
+                </p>
+            </section>
+            <section class="flex items-center justify-center flex-wrap gap-4 bg-surface-ligt p-2 rounded-lg">
+                {% if initial_phase %}
+                <p class="text-xl font-bold text-center">
+                    Fase 1:
+                </p>
+                <p class="text-xl font-bold text-center">
+                    Lista inicial
+                </p>
+                {% else %}
+                <p class="text-xl font-bold text-center">
+                    Fase 2:
+                </p>
+                <p class="text-xl font-bold text-center">
+                    Lista Final
+                </p>
+                {% endif %}
+            </section>
+        </article>
+
+        <article class="cts-list-words">
+            <article class="flex gap-4 flex-wrap">
+                <section class="bg-surface-card p-4 rounded-lg text-center space-y-4 sm:w-[300px] w-full flex-shrink-0">
+                    <h3 class="text-xl font-bold border-b-1">Describe el producto</h3>
+
+                    <form action="" method="get" class="cts-form-pf-word flex gap-4 flex-col">
+                        <label for="{{ form.nombre_palabra.id_for_label }}" class="text-left">
+                            <p class="text-lg font-semibold">
+                                {{ form.nombre_palabra.label }}:
+                            </p>
+                            {{ form.nombre_palabra }}
+                            <small>
+                                Solo letras minúsculas y la letra ñ, no poner acentos. No se permiten mayúsculas ni
+                                caracteres especiales. Mínimo 3 letras
+                            </small>
+                        </label>
+                        <button type="submit" class="cts-btn-general-compress cts-btn-primary btn-push w-full py-2">
+                            Agregar
+                        </button>
+                        <p class="error-input-word p-2 bg-red-500 rounded-lg hidden text-white font-semibold">
+                        </p>
+                    </form>
+                </section>
+
+                <section
+                    class="bg-surface-card p-4 rounded-lg text-center w-[400px] max-w-[400px] h-[400px] min-h-[400px] max-h-[600px] flex-shrink-0 overflow-y-auto">
+                    <div>
+                        <p class="text-xl font-bold pb-3">Lista de palabras</p>
+                        <hr>
+                    </div>
+
+                    <ul class="cts-box-words flex flex-col gap-3 overflow-y-auto mt-4">
+                        {% if not words %}
+                        <img src="{% static 'img/list.svg' %}" alt="lista de palabras" class="cts-img-list h-[300px]">
+                        {% endif %}
+
+                        {% for word in words %}
+                        <img src="{% static 'img/list.svg' %}" alt="lista de palabras"
+                            class="cts-img-list h-[300px] hidden">
+
+                        <li class="cts-item-words bg-gray-400 text-black rounded font-bold text-lg 
+                       px-4 py-3 flex flex-wrap flex-row min-w-fit justify-center items-center gap-3">
+                            <p class="ct-word-received">{{ word.nombre_palabra }}</p>
+
+                            <button class="px-4 border-b-2 active:border-b-0 active:border-t-2 
+                           transition-all rounded-xl font-black capitalize 
+                           active:border-red-500 border-red-800 bg-red-500">
+                                ➖
+                            </button>
+                        </li>
+                        {% endfor %}
+                    </ul>
+                </section>
+            </article>
+
+        </article>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/pf-make-list.js' %}"></script>
+<script src="{% static 'js/actions-form.js' %}"></script>
+{% endblock %}

tecnicas/urls.py

@@ -114,6 +114,10 @@ urlpatterns = [
          views.cataTest,
          name="session_cata"),
 
+    path("testers/init-session/<str:code_sesion>/perfil-flash",
+         views.pfTest,
+         name="session_pf"),
+
 
     # APIs
     path("presenter/api/nueva-etiqueta",

tecnicas/views/__init__.py

@@ -34,3 +34,4 @@ from .tester_forms.login_session import loginSessionTester
 from .tester_forms.sessions_list_tester import sessionsListTester
 from .tester_forms.convencional_scales import convencionalScales
 from .tester_forms.cata_test import cataTest
+from .tester_forms.pf_test import pfTest

tecnicas/views/tester_forms/cata_test.py

@@ -1,7 +1,6 @@
 from django.http import HttpRequest
 from tecnicas.models import SesionSensorial
 from tecnicas.controllers import TestCataController
-from tecnicas.utils import noValidTechnique
 
 
 def cataTest(req: HttpRequest, code_sesion: str):

tecnicas/views/tester_forms/init_tester_form.py

@@ -42,10 +42,9 @@ def initTesterForm(req: HttpRequest, code_sesion: str):
             response = view_controller.controllPost(request=req)
 
         elif type_technique == "perfil flash":
-            # view_controller = InitSessionPFController(
-            #     sensorial_session=session, user_tester=req.user.user_catador)
-            # response = view_controller.controllPost(request=req)
-            response = JsonResponse({"message": "Aun estamos probando esta funcion"})
+            view_controller = InitSessionPFController(
+                sensorial_session=session, user_tester=req.user.user_catador)
+            response = view_controller.controllPost(request=req)
         else:
             context = {
                 "session": session,

tecnicas/views/tester_forms/pf_test.py

@@ -0,0 +1,11 @@
+from django.http import HttpRequest
+from tecnicas.models import SesionSensorial
+from tecnicas.controllers import TestPFController
+
+
+def pfTest(req: HttpRequest, code_sesion: str):
+    if req.method == "GET":
+        session = SesionSensorial.objects.get(codigo_sesion=code_sesion)
+        controll_view = TestPFController(
+            sensorial_session=session, user_tester=req.user.user_catador)
+        return controll_view.controllGet(request=req)