Merge pull request #5 from CascoArcilla/HU9

Muestra de palabras por producto para calificar del lado del Catador

tecnicas/controllers/__init__.py

@@ -1,12 +1,17 @@
-from .tecnica_controller import TecnicaController
-from .escala_controller import EscalaController
-from .productos_controller import ProductosController
-from .ordenes_controller import OrdenesController
-from .palabras_controller import PalabrasController
-from .estilo_palabras_controller import EstiloPalabrasController
-from .palabras_controller import PalabrasController
-from .sesion_controller import SesionController
-from .calificacion_controller import CalificacionController
-from .detalles_sesion_controller import DetallesSesionController
-from .login_tester_controller import LoginTesterController
-from .main_tester_form_controller import MainTesterFormController
+from .models_controller.tecnica_controller import TecnicaController
+from .models_controller.escala_controller import EscalaController
+from .models_controller.productos_controller import ProductosController
+from .models_controller.ordenes_controller import OrdenesController
+from .models_controller.palabras_controller import PalabrasController
+from .models_controller.estilo_palabras_controller import EstiloPalabrasController
+from .models_controller.palabras_controller import PalabrasController
+from .models_controller.sesion_controller import SesionController
+from .models_controller.calificacion_controller import CalificacionController
+from .models_controller.catador_controller import CatadorController
+from .models_controller.posicion_controller import PosicionController
+from .models_controller.particiapacion_controller import ParticipacionController
+from .models_controller.dato_controller import DatoController
+
+from .views_controller.detalles_sesion_controller import DetallesSesionController
+from .views_controller.login_tester_controller import LoginTesterController
+from .views_controller.main_tester_form_controller import MainTesterFormController

tecnicas/controllers/calificacion_controller.py

@@ -1,19 +0,0 @@
-from ..models import Calificacion, Tecnica
-
-
-class CalificacionController():
-    @staticmethod
-    def getRatingsByTechnique(technique: Tecnica):
-        repetition = technique.repecion
-
-        if not repetition:
-            return {"error": "sin datos calficados aun"}
-
-        data_rating = {}
-
-        for i in range(repetition):
-            response_data = Calificacion.objects.filter(
-                id_tecnica=technique, num_repeticion=i+1)
-            data_rating[f"repeticion_{i+1}"] = response_data
-
-        return data_rating

tecnicas/controllers/models_controller/calificacion_controller.py

@@ -0,0 +1,101 @@
+from ...models import Calificacion, Tecnica, Posicion, Producto, Catador
+from ...utils import controller_error
+from collections import defaultdict
+
+
+class CalificacionController():
+    @staticmethod
+    def getRatingsByTechnique(technique: Tecnica):
+        repetition = technique.repecion
+
+        if not repetition:
+            return {"error": "sin datos calficados aun"}
+
+        data_rating = {}
+
+        for i in range(repetition):
+            response_data = Calificacion.objects.filter(
+                id_tecnica=technique, num_repeticion=i+1)
+            data_rating[f"repeticion_{i+1}"] = response_data
+
+        return data_rating
+
+    @staticmethod
+    def getRatings(
+            technique: Tecnica = None,
+            id_technique: int = None,
+            repetition: int = None,
+            product: Producto = None,
+            id_product: int = None,
+            tester: Catador = None,
+            id_tester: int = None,
+            user_tester: str = None,):
+        if repetition is None:
+            return controller_error("Es necesario especificar la repetición")
+
+        filters = {"num_repeticion": repetition}
+
+        if technique is not None:
+            filters["id_tecnica"] = technique
+        elif id_technique is not None:
+            filters["id_tecnica__id"] = id_technique
+        else:
+            return controller_error("Es necesario especificar la técnica")
+
+        if product is not None:
+            filters["id_producto"] = product
+        elif id_product is not None:
+            filters["id_producto__id"] = id_product
+
+        if tester is not None:
+            filters["id_catador"] = tester
+        elif id_tester is not None:
+            filters["id_catador__id"] = id_tester
+        elif user_tester is not None:
+            filters["id_catador__usuarioCatador"] = user_tester
+
+        ratings = list(Calificacion.objects.filter(**filters).select_related(
+            "id_producto",
+            "id_tecnica",
+            "id_catador",
+        ))
+
+        return ratings
+
+    @staticmethod
+    def checkProducsWithoutRating(
+            positions: list[Posicion] = None,
+            user_cata: str = None,
+            repetition: int = None,
+            technique: Tecnica = None,
+            id_technique: int = None,
+            num_words: int = None):
+        check_products = [position.id_producto for position in positions]
+
+        filters = {
+            "user_tester": user_cata,
+            "repetition": repetition
+        }
+
+        if technique is not None:
+            filters["technique"] = technique
+        elif id_technique is not None:
+            filters["id_technique"] = id_technique
+
+        ratings = CalificacionController.getRatings(**filters)
+
+        if len(ratings) == 0:
+            return positions
+
+        ratings_dict = defaultdict(list)
+
+        for rat in ratings:
+            ratings_dict[rat.id_producto.id].append(rat)
+
+        for index, product in enumerate(check_products):
+            rating_of_product = ratings_dict.get(product.id, [])
+
+            if rating_of_product < num_words or len(rating_of_product) == 0:
+                return positions[index]
+
+        return controller_error("Sin productos por calificar")

tecnicas/controllers/models_controller/catador_controller.py

@@ -0,0 +1,10 @@
+from ...models import Catador
+from ...utils import controller_error
+
+class CatadorController:
+    def getTesterByUsername(username:str):
+        try:
+            tester = Catador.objects.get(usuarioCatador=username)
+            return tester
+        except Catador.DoesNotExist:
+            return controller_error("No se encontró el Catador")

tecnicas/controllers/models_controller/dato_controller.py

@@ -0,0 +1,16 @@
+from ...models import Calificacion, Dato
+from ...utils import controller_error
+
+
+class DatoController():
+    @staticmethod
+    def getRerecordedData(ratings: list[Calificacion]):
+        if not ratings:
+            return []
+        
+        ids_ratings = [rat.id for rat in ratings]
+
+        recoreded_data = list(Dato.objects.filter(
+            id_calificacion_id__in=ids_ratings))
+        
+        return recoreded_data

tecnicas/controllers/{escala_controller.py → models_controller/escala_controller.py}

@@ -1,6 +1,6 @@
-from ..models import Etiqueta, EtiquetasEscala, Escala, TipoEscala
+from ...models import Etiqueta, EtiquetasEscala, Escala, TipoEscala, Tecnica
 from django.db import DatabaseError
-from ..utils import controller_error
+from ...utils import controller_error
 
 
 class EscalaController():
@@ -68,3 +68,31 @@ class EscalaController():
         except DatabaseError as error:
             self.deleteRelationshipsWithLabels()
             return controller_error("error guardar relacion etiqueta escala")
+
+    @staticmethod
+    def getScaleByTechnique(technique: Tecnica = None, id_technique: int = None):
+        if technique is not None:
+            scale = Escala.objects.select_related("id_tipo_escala").only(
+                "id_tipo_escala", "longitud").get(tecnica=technique)
+            return scale
+
+        if id_technique is not None:
+            scale = Escala.objects.select_related("id_tipo_escala").only(
+                "id_tipo_escala", "longitud").get(tecnica_id=id_technique)
+            return scale
+
+    @staticmethod
+    def getRelatedTagsInScale(scale: Escala = None, id_scale: int = None):
+        if scale is not None:
+            scale_tags = list(EtiquetasEscala.objects.filter(
+                id_escala=scale).select_related("id_etiqueta"))
+            if len(scale_tags) == 0:
+                return controller_error("Imposible obtener las etiquetas")
+            return scale_tags
+
+        if id_scale is not None:
+            scale_tags = list(EtiquetasEscala.objects.filter(
+                id_escala_id=scale).select_related("id_etiqueta"))
+            if len(scale_tags) == 0:
+                return controller_error("Imposible obtener las etiquetas")
+            return scale_tags

tecnicas/controllers/{estilo_palabras_controller.py → models_controller/estilo_palabras_controller.py}

@@ -1,6 +1,6 @@
-from ..models import EsAtributo, Tecnica, Palabra
+from ...models import EsAtributo, Tecnica, Palabra
 from django.db import DatabaseError
-from ..utils import controller_error
+from ...utils import controller_error
 
 
 class EstiloPalabrasController():

tecnicas/controllers/{ordenes_controller.py → models_controller/ordenes_controller.py}

@@ -1,5 +1,5 @@
-from ..models import Orden, Posicion, Producto, Tecnica
-from ..utils import controller_error
+from ...models import Orden, Posicion, Producto, Tecnica
+from ...utils import controller_error
 from django.db import DatabaseError
 
 
@@ -74,3 +74,11 @@ class OrdenesController():
             return self.positions
         except DatabaseError as error:
             return controller_error("error al guardar las posiciones")
+
+    @staticmethod
+    def getOrderById(id: int):
+        try:
+            order = Orden.objects.get(id=id)
+            return order
+        except Orden.DoesNotExist:
+            return controller_error("No existe orden")

tecnicas/controllers/models_controller/palabras_controller.py

@@ -0,0 +1,47 @@
+from ...models import Palabra, Tecnica, EsAtributo, EsVocabulario, Dato
+from django.db import DatabaseError
+from ...utils import controller_error
+
+
+class PalabrasController():
+    ids_words: list[int]
+    words: list[Palabra]
+
+    def __init__(self, ids: list[int]):
+        self.ids_words = ids
+
+    def setIdsWords(self, new_ids: list[int]):
+        self.ids_words = new_ids
+
+    def setWords(self):
+        self.words = []
+        searched_words = list(Palabra.objects.filter(id__in=self.ids_words))
+        if not len(searched_words):
+            return controller_error("no se han encontrado registros")
+        return self.words
+
+    @staticmethod
+    def getWordsInTechnique(technique: Tecnica):
+        if technique.id_estilo.nombre_estilo == "atributos":
+            es_atribute = EsAtributo.objects.get(id_tecnica=technique)
+            words = list(es_atribute.palabras.all())
+            return words
+        elif technique.id_estilo.nombre_estilo == "vocabulario":
+            try:
+                palabras = Palabra.objects.filter(
+                    vocabulario__esvocabulario__id_tecnica=technique
+                )
+                return list(palabras.distinct()) if palabras.exists() else controller_error("Técnica sin palabras con vocabulario")
+            except Exception as e:
+                return controller_error("Técnica sin palabras con vocabulario")
+
+    @staticmethod
+    def getWordsWithoutData(recoreded_data: list[Dato], words: list[Palabra]):
+        qualified_words = [data.id_palabra for data in recoreded_data]
+
+        if set(qualified_words) == set(words):
+            return controller_error("No hay palabras por usar")
+
+        words_without_use = list(set(words).difference(set(qualified_words)))
+
+        return words_without_use

tecnicas/controllers/models_controller/particiapacion_controller.py

@@ -0,0 +1,36 @@
+from ...models import Participacion
+from ...utils import controller_error
+
+
+class ParticipacionController():
+    @staticmethod
+    def enterSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.finalizado = False
+            participation.activo = True
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")
+        
+    @staticmethod
+    def finishSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.finalizado = True
+            participation.activo = False
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")
+        
+    @staticmethod
+    def outSession(id_participation: int):
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+            participation.activo = False
+            participation.save()
+            return participation
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")

tecnicas/controllers/models_controller/posicion_controller.py

@@ -0,0 +1,20 @@
+from ...utils import controller_error
+from ...models import Orden, Posicion
+
+
+class PosicionController():
+    @staticmethod
+    def getPostionsInOrder(order: Orden = None, id_order: id = None):
+        if order is not None:
+            positions = list(Posicion.objects.filter(id_orden=order))
+            if not positions:
+                return controller_error("No existe orden")
+            return positions
+
+        if id_order is not None:
+            positions = list(Posicion.objects.filter(id_orden_id=id_order))
+            if not positions:
+                return controller_error("No existe orden")
+            return positions
+
+        return controller_error("No se define búsqueda")

tecnicas/controllers/{presentador_controller.py → models_controller/presentador_controller.py}

@@ -1,5 +1,5 @@
-from ..models import Presentador
-from ..utils import controller_error
+from ...models import Presentador
+from ...utils import controller_error
 
 
 class PresentadorController():

tecnicas/controllers/{productos_controller.py → models_controller/productos_controller.py}

@@ -1,6 +1,6 @@
 from django.db import DatabaseError
-from ..utils import controller_error
-from ..models import Producto, Tecnica
+from ...utils import controller_error
+from ...models import Producto, Tecnica
 
 
 class ProductosController():
@@ -37,3 +37,17 @@ class ProductosController():
             return self.list_product
         except DatabaseError as error:
             return controller_error("error al guardar los productos")
+
+    @staticmethod
+    def getProductsByTechniqe(technique: Tecnica = None, id_technique: int = None):
+        if technique is not None:
+            products = list(Producto.objects.filter(id_tecnica=technique))
+            if not products:
+                return controller_error("No existen productos en esta técnica")
+            return products
+        
+        if id_technique is not None:
+            products = list(Producto.objects.filter(id_tecnica_id=id_technique))
+            if not products:
+                return controller_error("No existen productos en esta técnica")
+            return products

tecnicas/controllers/{sesion_controller.py → models_controller/sesion_controller.py}

@@ -1,7 +1,7 @@
 from django.db import DatabaseError
 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
-from ..models import Tecnica, Presentador, SesionSensorial
-from ..utils import controller_error
+from ...models import Tecnica, Presentador, SesionSensorial
+from ...utils import controller_error
 
 
 class SesionController():
@@ -91,6 +91,14 @@ class SesionController():
             return session
         except SesionSensorial.DoesNotExist:
             return controller_error("La sesión ya no existe")
+        
+    @staticmethod
+    def getSessionByCode(code: str):
+        try:
+            session = SesionSensorial.objects.get(codigo_sesion=code)
+            return session
+        except SesionSensorial.DoesNotExist:
+            return controller_error("La sesión ya no existe")
 
     @staticmethod
     def getNumberSessionsByCreator(user_name: str):

tecnicas/controllers/{tecnica_controller.py → models_controller/tecnica_controller.py}

@@ -1,6 +1,6 @@
-from ..models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
+from ...models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
 from django.db import DatabaseError
-from ..utils import controller_error
+from ...utils import controller_error
 
 
 class TecnicaController():

tecnicas/controllers/palabras_controller.py

@@ -1,31 +0,0 @@
-from ..models import Palabra, Tecnica, EsAtributo
-from django.db import DatabaseError
-from ..utils import controller_error
-
-
-class PalabrasController():
-    ids_words: list[int]
-    words: list[Palabra]
-
-    def __init__(self, ids: list[int]):
-        self.ids_words = ids
-
-    def setIdsWords(self, new_ids: list[int]):
-        self.ids_words = new_ids
-
-    def setWords(self):
-        self.words = []
-        try:
-            searched_words = Palabra.objects.filter(id__in=self.ids_words)
-            if not len(searched_words):
-                return controller_error("no se han encontrado registros")
-            self.words = searched_words
-            return self.words
-        except DatabaseError as error:
-            return controller_error("error al guardar buscar palabras")
-
-    @staticmethod
-    def getWordsInTechnique(technique: Tecnica):
-        es_atributo = EsAtributo.objects.get(id_tecnica=technique)
-        words = es_atributo.palabras.all()
-        return words

tecnicas/controllers/{detalles_sesion_controller.py → views_controller/detalles_sesion_controller.py}

@@ -1,6 +1,6 @@
-from ..models import SesionSensorial, Presentador, Tecnica
-from . import CalificacionController, PalabrasController
-from ..utils import controller_error
+from ...models import SesionSensorial, Presentador, Tecnica
+from .. import CalificacionController, PalabrasController
+from ...utils import controller_error
 
 
 class DetallesSesionController():

tecnicas/controllers/{login_tester_controller.py → views_controller/login_tester_controller.py}

@@ -1,5 +1,5 @@
-from ..models import Catador, SesionSensorial, Participacion
-from ..utils import controller_error
+from ...models import Catador, SesionSensorial, Participacion
+from ...utils import controller_error
 from django.db import transaction
 
 
@@ -18,7 +18,7 @@ class LoginTesterController():
             self.session = SesionSensorial.objects.get(
                 codigo_sesion=code_session)
 
-            return True
+            return (self.tester, self.session)
         except (Catador.DoesNotExist, SesionSensorial.DoesNotExist):
             return controller_error("Credenciales inválidas")
 

tecnicas/controllers/{main_tester_form_controller.py → views_controller/main_tester_form_controller.py}

@@ -1,5 +1,5 @@
-from ..models import Catador, SesionSensorial, Orden
-from ..utils import controller_error, shuffleArray
+from ...models import Catador, SesionSensorial, Orden, Participacion, Producto, EsAtributo, Calificacion, EsVocabulario
+from ...utils import controller_error, shuffleArray
 from django.db import transaction
 
 
@@ -18,10 +18,10 @@ class MainTesterFormController():
 
     def assignOrder(self):
         with transaction.atomic():
-            orders_without_tester = Orden.objects.select_for_update().filter(
-                id_tecnica=self.session.tecnica, id_catador=None)
+            orders_without_tester = list(Orden.objects.select_for_update().filter(
+                id_tecnica=self.session.tecnica, id_catador=None))
 
-            if not len(orders_without_tester):
+            if not orders_without_tester:
                 return controller_error("Las ordenes se han acabado")
 
             shuffle_orders = shuffleArray(orders_without_tester)
@@ -35,7 +35,7 @@ class MainTesterFormController():
     def checkAssignOrder(self):
         if not self.tester or not self.session:
             return controller_error("Atributos no establecidos")
-        
+
         try:
             res_order = Orden.objects.get(
                 id_tecnica=self.session.tecnica, id_catador=self.tester)
@@ -43,3 +43,38 @@ class MainTesterFormController():
             return self.order
         except Orden.DoesNotExist:
             return controller_error("Catador sin orden")
+
+    def isEndedSession(self, id_participation: int, repetition: int):
+        if not self.order or not id_participation:
+            return controller_error("Se requieren datos para comprobar la finalización")
+
+        try:
+            participation = Participacion.objects.get(id=id_participation)
+
+            if participation.finalizado:
+                num_products = Producto.objects.filter(
+                    id_tecnica=self.session.tecnica).count()
+
+                style_words = self.session.tecnica.id_estilo
+
+                num_words: int
+
+                if style_words.nombre_estilo == "atributos":
+                    e_atribues = EsAtributo.objects.get(
+                        id_tecnica=self.session.tecnica)
+                    num_words = e_atribues.palabras.count()
+                elif style_words.nombre_estilo == "vocabulario":
+                    e_vocabulary = EsVocabulario.objects.get(
+                        id_tecnica=self.session.tecnica)
+                    num_words = e_vocabulary.id_vocabulario.palabras.count()
+
+                num_ratings_now = Calificacion.objects.filter(
+                    id_tecnica=self.session.tecnica, id_catador=self.tester, num_repeticion=repetition).count()
+
+                num_ratings_max_by_tester = num_products * num_words
+
+                return not num_ratings_now <= num_ratings_max_by_tester
+            else:
+                return participation.finalizado
+        except Participacion.DoesNotExist:
+            return controller_error("No se ha encontrado la participación")

tecnicas/static/js/created-scale.js

@@ -0,0 +1,207 @@
+const BTN_CLASS_STYLE = [
+  "text-lg",
+  "tracking-wider",
+  "font-medium",
+  "p-2",
+  "px-4",
+  "border-b-2",
+  "active:border-b-0",
+  "active:border-t-2",
+  "active:border-blue-500",
+  "border-blue-800",
+  "transition-all",
+  "rounded-xl",
+  "bg-blue-500",
+  "text-white",
+  "w-fit",
+  "disabled:bg-amber-600",
+];
+
+function checkSendRating(word) {
+  const btnCheck = document.querySelector(`.ct-btn-check-${word}`);
+  const btnSend = document.querySelector(`.ct-btn-submit-${word}`);
+  const btnCancel = document.querySelector(`.ct-btn-cancel-${word}`);
+
+  btnCheck.classList.add("hidden");
+  btnSend.classList.remove("hidden");
+  btnCancel.classList.remove("hidden");
+}
+
+function cancelSendRating(word) {
+  const btnCheck = document.querySelector(`.ct-btn-check-${word}`);
+  const btnSend = document.querySelector(`.ct-btn-submit-${word}`);
+  const btnCancel = document.querySelector(`.ct-btn-cancel-${word}`);
+
+  btnCheck.classList.remove("hidden");
+  btnSend.classList.add("hidden");
+  btnCancel.classList.add("hidden");
+}
+
+async function sendRating(word) {
+  const containerBtn = document.querySelector(`.actions-${word}`);
+  addOrRemoveWaitSpin(containerBtn);
+
+  const formRatingWord = document.querySelector(`.form-rating-${word}`);
+
+  const dataForm = new FormData(formRatingWord);
+  const url = "/cata/testers/api/ratingword";
+
+  dataForm.set("name-word", word);
+
+  try {
+    const respone = await fetch(url, {
+      method: "POST",
+      headers: {
+        "X-CSRFToken": dataForm.get("csrfmiddlewaretoken"),
+      },
+      body: dataForm,
+    });
+
+    const jsonResponse = await respone.json();
+
+    if (jsonResponse.error) {
+      addOrRemoveWaitSpin(containerBtn, false, jsonResponse.error);
+      return;
+    }
+
+    remplaceForm(formRatingWord, jsonResponse.message);
+    if (isEndedRatingWords()) {
+      addBtnNextWord();
+    }
+  } catch (error) {
+    console.log("Error:", error);
+  }
+}
+
+function remplaceForm(oldForm, message) {
+  const articleContainer = document.createElement("article");
+  const thankYouMessage = document.createElement("p");
+  const messageResponse = document.createElement("p");
+
+  thankYouMessage.innerHTML =
+    "Palabra calificada,<br>gracias por la participación";
+  messageResponse.textContent = message;
+
+  articleContainer.classList.add(
+    "bg-gray-200",
+    "p-6",
+    "rounded-lg",
+    "mb-3",
+    "text-center"
+  );
+  thankYouMessage.classList.add("text-2xl", "font-bold");
+  messageResponse.classList.add("text-lg");
+
+  articleContainer.appendChild(thankYouMessage);
+  articleContainer.appendChild(messageResponse);
+  oldForm.replaceWith(articleContainer);
+}
+
+function addBtnNextWord() {
+  const thankYouMessage = document.createElement("p");
+  thankYouMessage.textContent = "Has finalizado con este producto";
+  thankYouMessage.classList.add("text-2xl", "font-bold", "mb-3");
+
+  const btnNesxtWord = document.createElement("button");
+  btnNesxtWord.classList.add(...BTN_CLASS_STYLE, "ct-btn-next-word");
+  btnNesxtWord.textContent = "Siguiente palabra";
+  btnNesxtWord.addEventListener("click", nextWord);
+
+  const articleContainer = document.createElement("article");
+  articleContainer.classList.add(
+    "bg-gray-200",
+    "p-6",
+    "rounded-lg",
+    "mb-3",
+    "text-center"
+  );
+
+  articleContainer.appendChild(thankYouMessage);
+  articleContainer.appendChild(btnNesxtWord);
+
+  const scalesContainer = document.querySelector(".scales-container");
+  scalesContainer.innerHTML = "";
+  scalesContainer.appendChild(articleContainer);
+}
+
+function isEndedRatingWords() {
+  const currentNumerWords = document.querySelectorAll(
+    'form[class*="form-rating-"]'
+  ).length;
+
+  return !currentNumerWords;
+}
+
+/**
+ *
+ * @param {Event} e
+ */
+function nextWord(e) {
+  location.reload();
+}
+
+function createSpinCharge() {
+  const divSpin = document.createElement("div");
+
+  divSpin.classList.add(
+    "w-10",
+    "h-10",
+    "rounded-full",
+    "border-4",
+    "border-t-4",
+    "border-gray-200",
+    "border-t-blue-600",
+    "animate-spin"
+  );
+
+  return divSpin;
+}
+
+/**
+ *
+ * @param {Element} containerBtn
+ */
+function addOrRemoveWaitSpin(containerBtn, render = true, error = false) {
+  const actions = containerBtn.querySelector(`.btns-container`);
+
+  if (render) {
+    containerBtn.innerHTML = "";
+    const spin = createSpinCharge();
+    actions.classList.add("hidden");
+    containerBtn.appendChild(spin);
+    containerBtn.appendChild(actions);
+    containerBtn.classList.remove("items-end");
+    containerBtn.classList.add("items-center");
+  }
+
+  if (!render) {
+    containerBtn.innerHTML = "";
+
+    if (error) {
+      containerBtn.appendChild(createErrorSubmit(error));
+    }
+
+    containerBtn.append(actions);
+    actions.classList.remove("hidden");
+    containerBtn.classList.remove("items-center");
+    containerBtn.classList.add("items-end");
+  }
+}
+
+function createErrorSubmit(errorMessage) {
+  const containerError = document.createElement("div");
+  containerError.classList.add(
+    "w-full",
+    "p-2",
+    "bg-red-400",
+    "font-bold",
+    "text-center",
+    "rounded-lg"
+  );
+
+  const errorP = document.createElement("p");
+  errorP.textContent = errorMessage;
+
+  containerError.appendChild(errorP);
+  return containerError;
+}

tecnicas/templates/tecnicas/forms_tester/convencional.html

@@ -0,0 +1,182 @@
+{% extends 'tecnicas/layouts/base.html' %}
+
+{% load static %}
+
+{% block title %}Convencional{% endblock %}
+
+{% block extra_css %}
+<style>
+    input[type="range"]::-webkit-slider-thumb {
+        -webkit-appearance: none;
+        appearance: none;
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        background: var(--color-blue-500);
+        cursor: pointer;
+    }
+
+    input[type="range"]::-moz-range-thumb {
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        background: #3b82f6;
+        cursor: pointer;
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<article class="w-full flex flex-col justify-center items-center bg-gray-600 mt-10 mb-10">
+    <article class="flex flex-col gap-8 bg-gray-400 p-10 rounded">
+        <header class="text-center flex-row w-full flex justify-around items-center flex-wrap gap-10">
+            <h1 class="text-white rounded font-bold text-2xl bg-gray-600 p-4 flex-1">
+                Sesión usando técnica Convencional
+            </h1>
+        </header>
+
+        {% 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="hidden">
+            <ul class="list-words">
+                {% for word in words %}
+                <li class="item-word">
+                    <p class="word-id">
+                        {{ word.id }}
+                    </p>
+                    <p class="word-name">
+                        {{ word.nombre_palabra }}
+                    </p>
+                </li>
+                {% endfor %}
+            </ul>
+
+            <ul class="list-tags">
+                {% for tag in tags %}
+                <li class="item-tag">
+                    <p class="tag-id">
+                        {{ tag.posicion }}
+                    </p>
+                    <p class="tag-name">
+                        {{ tag.id_etiqueta }}
+                    </p>
+                </li>
+                {% endfor %}
+            </ul>
+
+            <div class="scale-data">
+                <p class="scale-type">
+                    {{ scale.id_tipo_escala }}
+                </p>
+                <p class="scale-size">
+                    {{ scale.longitud }}
+                </p>
+            </div>
+        </article>
+
+        <article class="rounded flex flex-col gap-4">
+            <section class="flex items-center justify-center bg-gray-200 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">
+                <div class="bg-gray-200 p-2 rounded-lg flex-1">
+                    <p class="text-lg font-bold text-center">
+                        Producto:
+                    </p>
+                    <p class="text-2xl font-bold text-center">
+                        {{ product }}
+                    </p>
+                </div>
+                <div class="bg-gray-200 p-2 rounded-lg flex-1">
+                    <p class="text-lg font-bold text-center">
+                        Repetición:
+                    </p>
+                    <p class="text-2xl font-bold text-center">
+                        {{ session.tecnica.repecion }}
+                    </p>
+                </div>
+            </section>
+        </article>
+
+        <article class="scales-container [&>*:not(:last-child)]:mb-5 flex flex-col items-center justify-center">
+            {% if type_scale == "continua" %}
+            {% for word in words %}
+            <form action="" method="post" class="form-rating-{{word}}">
+                {% csrf_token %}
+                <article class="bg-gray-200 p-6 rounded-lg mb-3 w-fit">
+                    <label for="id-range-word-{{word}}"
+                        class="text-xl font-bold tracking-wide block mb-6 first-letter:uppercase">{{ word }}</label>
+
+                    <section class="block">
+                        <div class="relative">
+                            <input id="id-range-word-{{word}}" type="range" min="0" max="1000" value="500"
+                                name="rating-word"
+                                class="h-2 bg-gray-400 rounded-lg appearance-none cursor-pointer slider"
+                                style="width: {{scale.longitud}}cm;">
+
+                            <div class="absolute top-0 left-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
+                            </div>
+
+                            <div
+                                class="absolute top-1/5 left-1/2 w-0.5 transform -translate-x-1/2 h-4/5 bg-red-500 z-10">
+                            </div>
+
+                            <div class="absolute top-0 right-0 w-0.5 transform -translate-x-1/2 h-full bg-red-500 z-10">
+                            </div>
+                        </div>
+
+                        <div class="flex justify-between mt-4">
+                            <div class="flex flex-col items-start text-left w-[100px]">
+                                <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                                    {{ tags.0.id_etiqueta }}
+                                </span>
+                            </div>
+                            <div class="flex flex-col items-start text-center w-[100px]">
+                                <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                                    {{ tags.1.id_etiqueta }}
+                                </span>
+                            </div>
+                            <div class="flex flex-col items-start text-right w-[100px]">
+                                <span class="text-xs font-medium text-gray-700 break-words first-letter:capitalize">
+                                    {{ tags.2.id_etiqueta }}
+                                </span>
+                            </div>
+                        </div>
+                    </section>
+                </article>
+                <article class="flex flex-col justify-center gap-2 items-end actions-{{word}}">
+                    <section class="flex justify-end items-center gap-2 btns-container">
+                        <button type="button" onclick="checkSendRating('{{word}}')"
+                            class="ct-btn-check-{{word}} text-lg tracking-wider font-medium p-2 px-4 border-b-2 active:border-b-0 active:border-t-2 active:border-blue-500 border-blue-800  transition-all rounded-xl bg-blue-500 text-white w-fit disabled:bg-amber-600">
+                            ¿Guardar calificación?
+                        </button>
+                        <button type="button" onclick="sendRating('{{word}}')"
+                            class="ct-btn-submit-{{word}} text-lg tracking-wider font-medium p-2 px-4 border-b-2 active:border-b-0 active:border-t-2 active:border-green-500 border-green-800  transition-all rounded-xl bg-green-500 text-white w-fit disabled:bg-amber-600 hidden">
+                            Estoy seguro
+                        </button>
+                        <button type="button" onclick="cancelSendRating('{{word}}')"
+                            class="ct-btn-cancel-{{word}} text-lg tracking-wider font-medium p-2 px-4 border-b-2 active:border-b-0 active:border-t-2 active:border-orange-500 border-orange-800  transition-all rounded-xl bg-orange-500 text-white w-fit disabled:bg-amber-600 hidden">
+                            Cancelar
+                        </button>
+                    </section>
+                </article>
+            </form>
+            {% endfor %}
+            {% endif %}
+        </article>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/created-scale.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/forms_tester/main_tester.html

@@ -28,6 +28,16 @@
         </article>
         {% endif %}
 
+        {% if message %}
+        <hr>
+
+        <article class="bg-blue-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">
+                {{ message }}
+            </p>
+        </article>
+        {% endif %}
+
         <hr>
 
         <article
@@ -88,6 +98,12 @@
         <hr>
 
         <article class="flex flex-wrap gap-10">
+            {% if has_ended %}
+            <button
+                class="ct-btn-start-repition flex-1 uppercase text-lg tracking-wider p-4 border-b-2 active:border-b-0 active:border-t-2 active:border-green-500 border-green-800  transition-all rounded-xl bg-green-600 text-white font-bold disabled:bg-amber-600 flex flex-col justify-center items-center gap-2" disabled>
+                Finalizaste la sesión
+            </button>
+            {% else %}
             <button
                 class="ct-btn-start-repition flex-1 uppercase text-lg tracking-wider p-4 border-b-2 active:border-b-0 active:border-t-2 active:border-green-500 border-green-800  transition-all rounded-xl bg-green-600 text-white font-bold disabled:bg-amber-600 flex flex-col justify-center items-center gap-2"
                 onclick="startTest()">
@@ -96,6 +112,7 @@
                     <img src="{% static 'img/check.svg' %}" alt="flechas girando" class="invert">
                 </figure>
             </button>
+            {% endif %}
             <button
                 class="flex-1 uppercase text-lg tracking-wider p-4 border-b-2 active:border-b-0 active:border-t-2 active:border-red-500 border-red-800 transition-all rounded-xl bg-red-600 text-white font-bold disabled:bg-amber-600 flex flex-col justify-center items-center gap-2">
                 Salir se la sesión

tecnicas/templates/tecnicas/layouts/base.html

@@ -18,7 +18,7 @@
 </head>
 
 <body>
-  <main class="flex flex-col w-screen h-screen overflow-x-hidden overflow-y-scroll bg-gray-600">
+  <main class="flex flex-col w-screen max-sm:w-full h-screen overflow-x-hidden max-xs:overflow-x-scroll overflow-y-scroll bg-gray-600">
     {% block content %}{% endblock %}
   </main>
 

tecnicas/urls.py

@@ -72,6 +72,10 @@ urlpatterns = [
          views.mainTesterForm,
          name="catador_main"),
 
+    path("testers/en-session/convencional",
+         views.convencionalScales,
+         name="session_convencional"),
+
     # APIs
     path("nueva-etiqueta",
          views.newTag,
@@ -80,4 +84,8 @@ urlpatterns = [
     path("api/palabras",
          views.words,
          name="api_palabras"),
+
+    path("testers/api/ratingword",
+         views.reatingWord,
+         name="api_rating_word"),
 ]

tecnicas/views/__init__.py

@@ -18,5 +18,7 @@ from .tester_management.tester_search import testerSearch
 
 from .apis.api_tag import newTag
 from .apis.api_words import words
+from .apis.rating_word import reatingWord
 
 from .tester_forms.main_tester_form import mainTesterForm
+from .tester_forms.convencional_scales import convencionalScales

tecnicas/views/apis/rating_word.py

@@ -0,0 +1,17 @@
+from django.http import HttpRequest, JsonResponse
+
+
+def reatingWord(req:  HttpRequest):
+    if req.method == "POST":
+        if not req.POST["rating-word"]:
+            return JsonResponse({"error": "No se ha reconocido valor para la calificacion"})
+        rating = req.POST["rating-word"]
+        word = req.POST["name-word"]
+        return JsonResponse({
+            "message": "Ok",
+            "data": {
+                "word": word,
+                "rating": rating,
+                "cata_ser": req.session["cata_username"]
+            }
+        })

tecnicas/views/login_tester.py

@@ -21,6 +21,8 @@ def testerLogin(req: HttpRequest):
         if isinstance(existCredentials, dict):
             context = {"error": existCredentials["error"]}
             return render(req, "tecnicas/cata-login.html", context)
+        
+        session = existCredentials[1]
 
         taster_participation = login_controller.validateEntry()
         if isinstance(taster_participation, dict):
@@ -29,6 +31,8 @@ def testerLogin(req: HttpRequest):
 
         req.session["cata_username"] = tester_user
         req.session["code_session"] = session_code
+        req.session["id_techniqe"] = session.tecnica.id
+        req.session["id_participation"] = taster_participation.id
 
         req.session.set_expiry(20*60)
         return redirect(reverse("cata_system:catador_main"))

tecnicas/views/tester_forms/convencional_scales.py

@@ -0,0 +1,129 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect, render
+from django.urls import reverse
+from ...controllers import SesionController, PosicionController, CalificacionController, ParticipacionController, PalabrasController, EscalaController, DatoController
+
+'''
+ **** Esta vista para sesion con tecnica convencional de escalas, al entrar debe:
+ **** ****
+
+ ++++ Por el lado del servidor
+ ++++ ++++
+ * Obtner los productos que se evaluan en la tecnica
+ * Ordenar los productos segun la Poscion en que se encuentre en el Orden ya establecidos
+ * Obtner las palabras para evaluar
+    - Revisar que estilo usan
+    - Obtner las palabras si el estilo es atributos
+    - Obtner las palabras si el estilo es Vocabulario
+    - El Catador plasma sus resultados para las palabras sin importar el estilo
+ * Comprobar que productos se han calificado
+    - Revisar el numero de palabras
+    - Comenzar con el primer producto e ir revisando uno a uno
+        - Revisar el numero de calificaciones del producto
+        - Numero de calificaciones del producto == 0
+            - Continuar con la evaluacion o comezar con este producto
+        - Numero de calificaciones del producto < numero de palabras
+            - Continuar con la evaluacion
+        - Numero de calificacion == numero de palabras
+            - Pasar con el siguiente producto
+ * Si no quedan mas productos por revisar
+    - Participacion.finalizado = True
+    - Participacion.activo = False
+    - Redirigir a "catador_main"
+ * Optner la siguiente palabra sin calificar
+    - Obtener las calificaiones de producto
+    - Obtener los datos de las calificaciones
+    - Comprobar que palabras no estan tienen dato
+    - Mandar palabras para el usuario
+ * Obtener informacion de la escala para mandar
+
+ ++++ Por el lado del cliente
+ ++++ ++++
+ + Mostrar en todo momento las instrucciones en la parte superior de la pagina
+ + Mostrar la repeticion en la que esta
+ + Mostrar el producto que esta calificando
+ + Desglozar las palabras para calificar
+    - Cada palabra debe contar con su input segun el tipo
+    - Para cada input se debe poder guardar la calificacion
+    - Anstes de guardar la calificacion preguntar por la confirmacion a la hora de guardar el dato
+    - Especficar las etiquetas por debajo del input de ripo rango
+        - Para las escalas de tipo continua
+            - La longitud de la barra de la escala debe ser igual al tamaño que se especifico en la configuracion
+            - Contar con un input de tipo range
+            - Contar con etiqueta en el inicio de la barra, en el medio y al final
+            - La escala debe terner marcas al inicio, medio y final
+            - El rango de la barra debe ir de 0 a 1000
+        - Para las escalas de tipo estructurada
+            - Su longitud sera tan largo como el contendor que lo aloja
+            - La barra se divide segun el numero de etiquetas que estas posean
+            - Cata longitud debe poser una marca y solo estas seran las unicas posibles respuestas
+            - Cata segmento en el que se divide debe tener la etiqueda correspondiente por debajo
+'''
+
+
+def convencionalScales(req: HttpRequest):
+    if not "id_order" in req.session:
+        return redirect(reverse("cata_system:catador_main"))
+
+    session = SesionController.getSessionByCode(req.session["code_session"])
+    technique = session.tecnica
+
+    context = {
+        "session": session
+    }
+
+    if req.method == "GET":
+        positions = PosicionController.getPostionsInOrder(
+            id_order=req.session["id_order"])
+
+        sorted_positions = sorted(positions, key=lambda posi: posi.posicion)
+
+        words = PalabrasController.getWordsInTechnique(technique=technique)
+
+        next_position = CalificacionController.checkProducsWithoutRating(
+            positions=sorted_positions,
+            user_cata=req.session["cata_username"],
+            id_technique=req.session["id_techniqe"],
+            repetition=session.tecnica.repecion,
+            technique=technique,
+            num_words=len(words)
+        )
+
+        if isinstance(next_position, dict):
+            updated_participation = ParticipacionController.finishSession(
+                req.session["id_participation"])
+            return redirect(reverse("cata_system:catador_main"))
+
+        if isinstance(next_position, list):
+            next_position = next_position[0]
+
+        context["product"] = next_position.id_producto
+
+        ratings_product = CalificacionController.getRatings(
+            technique=technique,
+            product=next_position.id_producto,
+            repetition=technique.repecion,
+            user_tester=req.session["cata_username"]
+        )
+
+        if isinstance(ratings_product, dict):
+            context["error"] = ratings_product["error"]
+            return render(req, "tecnicas/forms_tester/convencional.html", context)
+        elif not ratings_product:
+            context["words"] = words
+        else:
+            recoreded_data = DatoController.getRerecordedData(ratings=ratings_product)
+            if not recoreded_data:
+                context["words"] = words
+            
+            words_to_use = PalabrasController.getWordsWithoutData(recoreded_data=recoreded_data, words=words)
+            context["words"] = words_to_use
+
+        scale = EscalaController.getScaleByTechnique(technique=technique)
+        context["scale"] = scale
+        context["type_scale"] = scale.id_tipo_escala.nombre_escala
+
+        use_tags = EscalaController.getRelatedTagsInScale(scale=scale)
+        context["tags"] = use_tags
+
+        return render(req, "tecnicas/forms_tester/convencional.html", context)

tecnicas/views/tester_forms/main_tester_form.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, JsonResponse
-from django.shortcuts import render
-from ...controllers import SesionController, MainTesterFormController
-from ...models import Orden
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from ...controllers import SesionController, MainTesterFormController, ParticipacionController
 
 
 def mainTesterForm(req: HttpRequest):
@@ -12,28 +12,45 @@ def mainTesterForm(req: HttpRequest):
         "session": session
     }
 
+    view_controller = MainTesterFormController(
+        req.session["code_session"], req.session["cata_username"])
+
     if req.method == "GET":
+        order = view_controller.checkAssignOrder()
+
+        if not isinstance(order, dict):
+            req.session["id_order"] = order.id
+            if view_controller.isEndedSession(id_participation=req.session["id_participation"], repetition=session.tecnica.repecion):
+                context["message"] = "El catador ha terminado de realizar su evaluación, espere instrucciones del presentador"
+                context["has_ended"] = True
+
         return render(req, "tecnicas/forms_tester/main_tester.html", context)
     elif req.method == "POST":
         if req.POST["action"] == "start_posting":
-            view_controller = MainTesterFormController(
-                req.session["code_session"], req.session["cata_username"])
+            if "id_order" in req.session:
+                update_participation = ParticipacionController.enterSession(
+                    id_participation=req.session["id_participation"])
+                if isinstance(update_participation, dict):
+                    context["error"] = update_participation["error"]
+                    return render(req, "tecnicas/forms_tester/main_tester.html", context)
 
-            order = view_controller.checkAssignOrder()
-            if not isinstance(order, dict):
-                req.session["id_order"] = order.id
-                context["error"] = "Catador tiene orden"
-                return render(req, "tecnicas/forms_tester/main_tester.html", context)
+                return redirect(reverse("cata_system:session_convencional"))
 
             order = view_controller.assignOrder()
             if isinstance(order, dict):
                 context["error"] = order["error"]
                 return render(req, "tecnicas/forms_tester/main_tester.html", context)
 
-            print(order)
-            return render(req, "tecnicas/forms_tester/main_tester.html", context)
+            update_participation = ParticipacionController.enterSession(
+                id_participation=req.session["id_participation"])
+            if isinstance(update_participation, dict):
+                context["error"] = update_participation["error"]
+                return render(req, "tecnicas/forms_tester/main_tester.html", context)
+
+            return redirect(reverse("cata_system:session_convencional"))
         elif req.POST["action"] == "close_session":
-            pass
+            req.session.flush()
+            return redirect(reverse("cata_system:catador_login"))
         else:
             context["error"] = "Acción sin especificar"
             return render(req, "tecnicas/forms_tester/main_tester.html", context)