Correccion de GET en fase 3 de PF

tecnicas/controllers/models_controller/escala_controller.py

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

tecnicas/controllers/views_controller/create_session/panel_basic_controller.py

@@ -167,15 +167,12 @@ class PanelBasicController():
             print(form.cleaned_data)
             values = {}
             for name, value in form.cleaned_data.items():
-                if name == "tipo_escala":
-                    values[name] = value.id
-                else:
-                    values[name] = value
+                values[name] = value
 
             values["name_tecnica"] = name_tecnica
             request.session['form_basic'] = values
             response = redirect(
-                reverse(PanelBasicController.url_next_panel_tags))
+                reverse(PanelBasicController.url_next_panel_codes))
         else:
             response = render(request, PanelBasicController.url_panel_basic_pf, {
                 "form_sesion": form, "error": "Información no valida"})

tecnicas/controllers/views_controller/create_session/panel_codes_controller.py

@@ -80,7 +80,7 @@ class PanelCodesController():
         return render(request, PanelCodesController.url_current_panel, context_codes_form)
 
     @staticmethod
-    def controllPostRATA(request: HttpRequest, is_rata: True):
+    def controllPostRATA(request: HttpRequest, is_rata=True):
         codes = []
         context_codes_form = {}
 

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

@@ -2,7 +2,7 @@ from django.http import HttpRequest, JsonResponse
 from django.db import transaction
 from django.shortcuts import render
 from tecnicas.utils import general_error
-from tecnicas.models import EsAtributo, EsVocabulario, Vocabulario, Tecnica, TipoTecnica, EstiloPalabra, Producto, Palabra, SesionSensorial
+from tecnicas.models import EsAtributo, EsVocabulario, Vocabulario, Tecnica, TipoTecnica, EstiloPalabra, Producto, Palabra, SesionSensorial, Escala, TipoEscala, EtiquetasEscala
 from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
 from tecnicas.utils import deleteDataSession
 
@@ -289,9 +289,9 @@ class PanelCreateController():
                     #
                     # //////////////////////////////////////////////////////// #
                     session = SesionSensorial.objects.create(
-                        name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                        technique=technique,
-                        creator=request.user.user_presentador
+                        nombre_sesion=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else "",
+                        tecnica=technique,
+                        creadoPor=request.user.user_presentador
                     )
 
                     if not session:
@@ -448,48 +448,41 @@ class PanelCreateController():
     @staticmethod
     def controllPostPF(request: HttpRequest):
         if request.POST.get('action') == 'create_session':
-            if not request.session.get("form_codes") or not request.session.get("form_tags"):
+            if not request.session.get("form_codes"):
                 deleteDataSession(request)
                 return general_error("No se ha especificado información necesaria para la creación de la sesión, por favor, vuelve a intentarlo")
             try:
                 with transaction.atomic():
-                    # ////////////////////////////////////////////////////// #
+                    # ////////////////////////////////////// #
                     #
-                    # First step: Create technique and scale with their tags #
+                    # First step: Create technique and scale #
                     #
-                    # ////////////////////////////////////////////////////// #
+                    # ////////////////////////////////////// #
                     data_basic = request.session["form_basic"]
-                    data_basic["numero_repeticiones"] = 0
+                    phases_before_reptition = 2
 
                     technique = Tecnica.objects.create(
                         tipo_tecnica=TipoTecnica.objects.get(
                             nombre_tecnica=data_basic["name_tecnica"]),
                         id_estilo=EstiloPalabra.objects.get(
                             nombre_estilo="vocabulario"),
-                        repeticiones_max=data_basic["numero_repeticiones"],
+                        repeticiones_max=data_basic["numero_repeticiones"] + phases_before_reptition,
                         limite_catadores=data_basic["numero_catadores"],
-                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Presentador",
+                        instrucciones=data_basic["instrucciones"] or "Espere instrucciones del Analista",
                     )
 
                     if not technique:
                         raise ValueError("Error al guardar la técnica")
 
-                    data_scale = {
-                        "id_scale": data_basic["tipo_escala"],
-                        "size": data_basic["tamano_escala"],
-                        "technique": technique
-                    }
-
-                    controllerScale = EscalaController(data=data_scale)
-
-                    scale = controllerScale.saveScale()
-                    if isinstance(scale, dict):
-                        raise ValueError(scale["error"])
-
-                    dict_tags = request.session["form_tags"]
-                    saved_related_tags = controllerScale.realteTags(dict_tags)
-                    if "error" in saved_related_tags:
-                        raise ValueError(saved_related_tags["error"])
+                    created_scale = Escala.objects.create(
+                        id_tipo_escala=TipoEscala.objects.get(
+                            nombre_escala="estructurada"),
+                        longitud=data_basic["numero_productos"],
+                        tecnica=technique
+                    )
+                    
+                    if not created_scale:
+                        raise ValueError("No se ha podido crear la escala")
 
                     # ////////////////////////////////////////////// #
                     #

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

@@ -1,13 +1,15 @@
 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.models import Producto, Participacion, Palabra, Calificacion, ListaPalabras, Dato
 from tecnicas.controllers import ParticipacionController, PalabrasController, EscalaController
 from tecnicas.forms import ListWordsForm
 from .general_test_controller import GenetalTestController
 
 
 class TestPFController(GenetalTestController):
+    skip_phases = 2
+
     def __init__(self, sensorial_session, user_tester):
         super().__init__(sensorial_session, user_tester)
 
@@ -104,80 +106,64 @@ class TestPFController(GenetalTestController):
         return render(request, self.current_directory, self.context)
 
     def getRepetitionPhase(self, request: HttpRequest):
+        '''
+        - Obtener todos los productos que se evaluan en la tecnica
+        - Obtener todas las palabras de la lista de palabras del catador
+        - Para cada palabra, comprobar que el numero de Dato sea igual al numero de Productos
+        - Si no hay datos mandar esa palabra por contexto con todos los productos
+        - De las palabras que falten tomar la primera y mandarla en el contexto
+        - Mandar todos los productos por el contexto
+        Nota: Para esta fase no hay necesidad de mandar una escala, la escala se creara en el cliente
+        '''
+        self.participation.refresh_from_db()
+
+        if self.participation.finalizado:
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
+
         technique = self.session.tecnica
 
+        # Obtener todos los productos que se evaluan en la técnica
         products_in_technique = Producto.objects.filter(id_tecnica=technique)
 
-        words = list(
-            ListaPalabras.objects.get(
+        # Obtener todas las palabras de la lista del catador (preferir lista final)
+        try:
+            words = list(ListaPalabras.objects.get(
                 tecnica=self.session.tecnica,
                 catador=request.user.user_catador,
                 es_final=True
-            ).palabras.all()
-        )
-
-        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
+            ).palabras.all())
+        except ListaPalabras.DoesNotExist:
+            words = []
 
-            # Obtener los datos asociados para la calificacion para ver que palabras quedan por calificar
-            recoreded_data = rating.dato_calificacion.all()
+        use_word: Palabra = None
 
-            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))
+        # Revisar que palabra no ha sido calificada en todos los productos
+        for word in words:
+            current_num_data = Dato.objects.filter(
+                id_calificacion__num_repeticion=technique.repeticion,
+                id_calificacion__id_tecnica=technique,
+                id_calificacion__id_catador=request.user.user_catador,
+                id_palabra=word
+            ).count()
 
-        scale = EscalaController.getScaleByTechnique(technique=technique)
-        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
-
-        self.context["product"] = use_product
-        self.context["words"] = use_words
-        
-        self.context["scale"] = scale
-        self.context["type_scale"] = scale.id_tipo_escala.nombre_escala
-        self.context["tags"] = use_tags
+            if not current_num_data:
+                use_word = word
+                break
+            elif current_num_data < len(products_in_technique):
+                self.context["error"] = "Se ha detectado una inconsistencia en los datos que se deben calificar, algunos productos no han sido calificados"
+                return render(request, self.current_directory, self.context)
 
-        self.context["repetition"] = technique.repeticion - 2
+        if not use_word:
+            self.participation = Participacion.objects.get(
+                tecnica=self.session.tecnica, catador=request.user.user_catador)
+            ParticipacionController.finishSession(self.participation)
+            params = {"code_sesion": self.session.codigo_sesion}
+            return redirect(reverse(self.previus_directory, kwargs=params))
 
-        if self.context["type_scale"] == "continua":
-            self.context["size_scale"] = {
-                "max_size": scale.longitud * 100,
-                "middle_size": (scale.longitud * 100)/2
-            }
+        self.context["word"] = use_word
+        self.context["products"] = products_in_technique
+        self.context["repetition"] = technique.repeticion - self.skip_phases
 
         return render(request, self.current_directory, self.context)
 

tecnicas/forms/create_session/sesion_basic_pf_form.py

@@ -19,18 +19,12 @@ class SesionBasicPFForm(forms.Form):
         "placeholder": "Solo números"
     }), required=True)
 
+    numero_repeticiones = forms.IntegerField(widget=forms.NumberInput(attrs={
+        "class": "bg-surface-ligt p-1 border-b-1 text-center w-full",
+        "placeholder": "Solo números"
+    }), required=True)
+
     instrucciones = forms.CharField(max_length=255, widget=forms.TextInput(attrs={
         "class": "bg-surface-ligt border-b-1 text-center w-full p-1",
         "placeholder": "Este campo es opcional"
     }), required=False)
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.fields['tipo_escala'] = forms.ModelChoiceField(queryset=TipoEscala.objects.all(), widget=forms.RadioSelect(attrs={
-            "class": "uppercase text-lg tracking-wider font-medium p-2 px-4 active:px-5 transition-all rounded-xl bg-blue-500 text-white",
-        }), required=True, initial=TipoEscala.objects.first())
-
-        self.fields['tamano_escala'] = forms.IntegerField(widget=forms.HiddenInput(attrs={
-            "class": "cts-size-input",
-        }), required=True)

tecnicas/templates/tecnicas/create_sesion/panel-basic-pf.html

@@ -41,6 +41,13 @@
                         </p>
                         {{ form_sesion.numero_catadores }}
                     </label>
+                    <label for="{{ form_sesion.numero_repeticiones.id_for_label }}"
+                        class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
+                        <p class="tracking-normal text-base font-bold">
+                            Número de repeticiones:
+                        </p>
+                        {{ form_sesion.numero_repeticiones }}
+                    </label>
                 </section>
                 <section class="flex justify-center items-center mt-2">
                     <label for="{{form_sesion.instrucciones.id_for_label}}"
@@ -51,55 +58,6 @@
                 </section>
             </article>
 
-            <article class="cs-escalas-radio flex flex-col gap-4">
-                <h2 class="text-2xl font-bold">Selecciona una escala</h2>
-                <section class="flex flex-row gap-4 justify-around flex-wrap">
-                    {% for escala in form_sesion.tipo_escala %}
-                    <label for="{{escala.id_for_label}}"
-                        class="ct-radio-escala uppercase text-lg tracking-wider font-bold p-2 px-4 rounded-xl cts-btn-primary btn-push">
-                        {{ escala.tag }}
-                        {{ escala.choice_label }}
-                    </label>
-                    {% endfor %}
-                    {% if form_sesion.tipo_escala.errors %}
-                    <div class="w-full text-center text-red-600 text-xl font-medium tracking-wide">
-                        {{ form_sesion.tipo_escala.errors }}
-                    </div>
-                    {% endif %}
-                </section>
-
-                <section class="py-2 px-5 flex flex-col justify-center items-center gap-2 relative">
-                    <label for="{{ form_sesion.tamano_escala.id_for_label }}"
-                        class="ct-size-scale text-xl flex flex-col items-center px-2 font-bold">
-                        <p>Establece número de segmentos:</p>
-                        {{ form_sesion.tamano_escala }}
-                    </label>
-                    <div class="flex justify-around max-sm:flex-col gap-8 cts-options-size-scale">
-                        <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="5"
-                                class="radio radio-lg checked:bg-pink-500" />
-                            <span class="mt-2 text-xl text-gray-700 font-medium">5</span>
-                        </label>
-                        <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="7"
-                                class="radio radio-lg checked:bg-pink-500" />
-                            <span class="mt-2 text-xl text-gray-700 font-medium">7</span>
-                        </label>
-                        <label class="flex flex-col items-center cursor-pointer">
-                            <input type="radio" name="option_size_scale" value="9"
-                                class="radio radio-lg checked:bg-pink-500" />
-                            <span class="mt-2 text-xl text-gray-700 font-medium">9</span>
-                        </label>
-                    </div>
-                    {% if form_sesion.tamano_escala.errors %}
-                    <article
-                        class="w-fit rounded px-2 py-0.5 text-center text-white text-sm font-medium tracking-wide bg-red-500">
-                        {{ form_sesion.tamano_escala.errors }}
-                    </article>
-                    {% endif %}
-                </section>
-            </article>
-
             <article class="w-full flex max-sm:flex-col flex-wrap items-center justify-center gap-4">
                 <button type="submit" class="cts-btn-general cts-btn-primary btn-push flex-1/4 w-full">
                     Continuar

tecnicas/templates/tecnicas/forms_tester/test_pf_rating_list.html

@@ -73,20 +73,11 @@
                     Fase <span class="cts-phase-pf" data-phase="3">3</span>:
                 </p>
                 <p class="text-xl font-bold text-center">
-                    Calificación de listas
+                    Evaluación de Atributos
                 </p>
             </section>
 
             <section class="flex items-center justify-center flex-wrap gap-4">
-                <div class="bg-surface-ligt p-2 rounded-lg flex-1">
-                    <p class="text-lg font-bold text-center">
-                        Producto:
-                    </p>
-                    <p class="text-2xl font-bold text-center ct-product-rating">
-                        <span class="code-product">{{ product }}</span>
-                        <span class="hidden id-product">{{ product.id }}</span>
-                    </p>
-                </div>
                 <div class="bg-surface-ligt p-2 rounded-lg flex-1">
                     <p class="text-lg font-bold text-center">
                         Repetición:
@@ -105,25 +96,21 @@
             </section>
         </article>
 
-        <article
-            class="scales-container [&>*:not(:last-child)]:mb-5 min-lg:grid min-lg:items-start grid-cols-2 gap-3 justify-center items-center">
-            {% with path_con="../components/form-scale-continue.html" path_str="../components/form-scale-structure.html" %}
-                {% if type_scale == "continua" %}
-                    {% for word in words %}
-                        {% include path_con with word=word tags=tags scale=scale size_scale=size_scale %}
-                    {% endfor %}
-                {% elif type_scale == "estructurada" %}
-                    {% for word in words %}
-                        {% include path_str with word=word tags=tags scale=scale %}
+        <article class="rounded flex flex-col gap-4">
+            <p>Palabra a evaluar: {{ word }}</p>
+            <div>
+                <p>Productos a ordenar:</p>
+                <ul>
+                    {% for product in products %}
+                    <li>{{ product }}</li>
                     {% endfor %}
-                {% endif %}
-            {% endwith %}
+                </ul>
+            </div>
         </article>
     </article>
 </article>
 {% endblock %}
 
 {% block extra_js %}
-<script src="{% static 'js/created-scale.js' %}"></script>
 <script src="{% static 'js/actions-form.js' %}"></script>
 {% endblock %}