Merge pull request #28 from CascoArcilla/HU3

tecnicas/admin.py

@@ -6,7 +6,7 @@ from .models import Catador, Presentador
 
 from .models import Tecnica, SesionSensorial
 
-from .models import EsAtributo, Palabra
+from .models import EsAtributo, Palabra, Vocabulario
 
 from .models import Etiqueta, Escala, EtiquetasEscala
 
@@ -31,6 +31,7 @@ admin.site.register(SesionSensorial)
 
 admin.site.register(EsAtributo)
 admin.site.register(Palabra)
+admin.site.register(Vocabulario)
 
 admin.site.register(Escala)
 admin.site.register(EtiquetasEscala)

tecnicas/controllers/__init__.py

@@ -28,7 +28,10 @@ from .views_controller.session_management.monitor_rata_controller import Monitor
 from .views_controller.sessions_tester.login_session_tester_controller import LoginSessionTesterController
 from .views_controller.sessions_tester.init_session_tester_controller import InitSessionTesterController
 from .views_controller.sessions_tester.convencional_scales_controller import ConvencionalScalesController
+from .views_controller.sessions_tester.list_sessions_tester_controller import ListSessionsTesterController
+
+from .views_controller.vocabulary_manage.create_vocabulary_controller import CreateVocabularyController
+from .views_controller.vocabulary_manage.list_vocabulary_controller import ListVocabularyController
 
 from .views_controller.api_rating_controller import ApiRatingController
 from .views_controller.tester_list_controller import TesterListController
-from .views_controller.list_sessions_tester_controller import ListSessionsTesterController

tecnicas/controllers/models_controller/palabras_controller.py

@@ -22,17 +22,16 @@ class PalabrasController():
     @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())
+            words = list(technique.tecnica_esatributo.palabras.all())
+            if not words:
+                return controller_error("Técnica sin palabras")
             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:
+            words = list(
+                technique.tecnica_esvacabulario.id_vocabulario.palabras.all())
+            if not words:
                 return controller_error("Técnica sin palabras con vocabulario")
+            return words
 
     @staticmethod
     def getWordsWithoutData(recoreded_data: list[Dato], words: list[Palabra]):

tecnicas/controllers/views_controller/create_session/panel_create_controller.py

@@ -2,6 +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 EsVocabulario, Vocabulario
 from tecnicas.controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
 from tecnicas.utils import deleteDataSession
 
@@ -21,139 +22,155 @@ class PanelCreateController():
             if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
                 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 #
+                    #
+                    # ////////////////////////////////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    controllerTechnique = TecnicaController()
+                    controllerTechnique.setTechniqueFromBasicData(
+                        basic=data_basic)
+                    technique = controllerTechnique.saveTechnique()
+                    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
+                    }
 
-            with transaction.atomic():
-                # ////////////////////////////////////////////////////// #
-                #
-                # First step: Create technique and scale with their tags #
-                #
-                # ////////////////////////////////////////////////////// #
-                data_basic = request.session["form_basic"]
-                controllerTechnique = TecnicaController()
-                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
-                technique = controllerTechnique.saveTechnique()
-                if not technique:
-                    return general_error("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):
-                    return general_error(scale["error"])
-
-                dict_tags = request.session["form_tags"]
-                saved_related_tags = controllerScale.realteTags(dict_tags)
-                if "error" in saved_related_tags:
-                    return general_error(saved_related_tags["error"])
-
-                # ////////////////////////////////////////////////////////// #
-                #
-                # Second step: Create orders, productos and set the position #
-                #
-                # ////////////////////////////////////////////////////////// #
-                data_codes = request.session["form_codes"]
-
-                list_codes_dict = data_codes["product_codes"]
-
-                codes = []
-                for product in list_codes_dict:
-                    code = next(iter(product.values()))
-                    codes.append(code)
-
-                controllerProducts = ProductosController(
-                    codes=codes,
-                    technique=technique
-                )
-
-                controllerProducts.setProductsNoSave()
-                saved_prodcuts = controllerProducts.saveProducts()
-                if isinstance(saved_prodcuts, dict):
-                    return general_error(saved_prodcuts["error"])
-
-                raw_sort_codes = data_codes["sort_codes"]
-                controllerOrdes = OrdenesController(
-                    raw_orders=raw_sort_codes,
-                    list_products=saved_prodcuts,
-                    technique=technique
-                )
-
-                controllerOrdes.setOrdersToSave()
-                saved_orders = controllerOrdes.saveOrders()
-                if isinstance(saved_orders, dict):
-                    return general_error(saved_orders["error"])
-
-                seded_positions = controllerOrdes.setPositions()
-                if isinstance(seded_positions, dict):
-                    return general_error(seded_positions["error"])
-
-                saved_postions = controllerOrdes.savePositions()
-                if isinstance(saved_postions, dict):
-                    return general_error(saved_prodcuts["error"])
-
-                # /////////////////////////////////////////////////////// #
-                #
-                # Third step: Create relations technique with Words Style #
-                #
-                # /////////////////////////////////////////////////////// #
-                ids_words = request.session["form_words"]
-                words_controller = PalabrasController(ids=ids_words)
-
-                words_to_use = words_controller.setWords()
-                if isinstance(words_to_use, dict):
-                    return general_error(words_to_use["error"])
-
-                style_controller = EstiloPalabrasController(
-                    technique=technique, words=words_to_use)
-
-                instace_style = style_controller.createAndSaveInstaceStyle()
-                if isinstance(instace_style, dict):
-                    return general_error(instace_style["error"])
-
-                words_using = style_controller.relatedWords()
-                if isinstance(words_using, dict):
-                    return general_error(words_using["error"])
-
-                # //////////////////////////////////////////////////////// #
-                #
-                # Fourth step: Create session and relat with the technique #
-                #
-                # //////////////////////////////////////////////////////// #
-                session_controller = SesionController(
-                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                    technique=technique,
-                    creator=request.user.user_presentador
-                )
-
-                setting_session = session_controller.setSession()
-                if isinstance(setting_session, dict):
-                    return general_error(setting_session["error"])
-
-                saved_session = session_controller.saveSession()
-                if isinstance(saved_session, dict):
-                    return general_error(saved_session["error"])
-
-                context = {
-                    "message": "sesión creada",
-                    "data": {
-                        "codigo_sesion": saved_session.codigo_sesion,
-                        "nombre_sesion": saved_session.nombre_sesion
+                    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"])
+
+                    # ////////////////////////////////////////////////////////// #
+                    #
+                    # Second step: Create orders, productos and set the position #
+                    #
+                    # ////////////////////////////////////////////////////////// #
+                    data_codes = request.session["form_codes"]
+
+                    list_codes_dict = data_codes["product_codes"]
+
+                    codes = []
+                    for product in list_codes_dict:
+                        code = next(iter(product.values()))
+                        codes.append(code)
+
+                    controllerProducts = ProductosController(
+                        codes=codes,
+                        technique=technique
+                    )
+
+                    controllerProducts.setProductsNoSave()
+                    saved_prodcuts = controllerProducts.saveProducts()
+                    if isinstance(saved_prodcuts, dict):
+                        raise ValueError(saved_prodcuts["error"])
+
+                    raw_sort_codes = data_codes["sort_codes"]
+                    controllerOrdes = OrdenesController(
+                        raw_orders=raw_sort_codes,
+                        list_products=saved_prodcuts,
+                        technique=technique
+                    )
+
+                    controllerOrdes.setOrdersToSave()
+                    saved_orders = controllerOrdes.saveOrders()
+                    if isinstance(saved_orders, dict):
+                        raise ValueError(saved_orders["error"])
+
+                    seded_positions = controllerOrdes.setPositions()
+                    if isinstance(seded_positions, dict):
+                        raise ValueError(seded_positions["error"])
+
+                    saved_postions = controllerOrdes.savePositions()
+                    if isinstance(saved_postions, dict):
+                        raise ValueError(saved_prodcuts["error"])
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+                    if style_words == "atributos":
+                        ids_words = request.session["form_words"]
+                        words_controller = PalabrasController(ids=ids_words)
+
+                        words_to_use = words_controller.setWords()
+                        if isinstance(words_to_use, dict):
+                            raise ValueError(words_to_use["error"])
+
+                        style_controller = EstiloPalabrasController(
+                            technique=technique, words=words_to_use)
+
+                        instace_style = style_controller.createAndSaveInstaceStyle()
+                        if isinstance(instace_style, dict):
+                            raise ValueError(instace_style["error"])
+
+                        words_using = style_controller.relatedWords()
+                        if isinstance(words_using, dict):
+                            raise ValueError(words_using["error"])
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        vocabulary = Vocabulario.objects.get(
+                            nombre_vocabulario=name_vocabulary)
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session_controller = SesionController(
+                        name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        technique=technique,
+                        creator=request.user.user_presentador
+                    )
+
+                    setting_session = session_controller.setSession()
+                    if isinstance(setting_session, dict):
+                        raise ValueError(setting_session["error"])
+
+                    saved_session = session_controller.saveSession()
+                    if isinstance(saved_session, dict):
+                        raise ValueError(saved_session["error"])
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": saved_session.codigo_sesion,
+                            "nombre_sesion": saved_session.nombre_sesion
+                        }
                     }
-                }
 
-                # ////////////////////////////////// #
-                #
-                # Final step: Delete date in session #
-                #
-                # ////////////////////////////////// #
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date in session #
+                    #
+                    # ////////////////////////////////// #
 
-                deleteDataSession(request)
-                return JsonResponse(context)
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+            except ValueError as e:
+                return general_error(f"Error: {e}")
         else:
             return general_error("No se ha establecido acción")
 
@@ -163,112 +180,131 @@ class PanelCreateController():
             if not request.session.get("form_tags") or not request.session.get("form_codes") or not request.session.get("form_words"):
                 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 #
+                    #
+                    # ////////////////////////////////////////////////////// #
+                    data_basic = request.session["form_basic"]
+                    data_basic["numero_catadores"] = 0
+                    data_basic["numero_repeticiones"] = 1
+                    controllerTechnique = TecnicaController()
+                    controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
+                    technique = controllerTechnique.saveTechnique()
+                    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
+                    }
 
-            with transaction.atomic():
-                # ////////////////////////////////////////////////////// #
-                #
-                # First step: Create technique and scale with their tags #
-                #
-                # ////////////////////////////////////////////////////// #
-                data_basic = request.session["form_basic"]
-                data_basic["numero_catadores"] = 0
-                data_basic["numero_repeticiones"] = 1
-                controllerTechnique = TecnicaController()
-                controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
-                technique = controllerTechnique.saveTechnique()
-                if not technique:
-                    return general_error("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):
-                    return general_error(scale["error"])
-
-                dict_tags = request.session["form_tags"]
-                saved_related_tags = controllerScale.realteTags(dict_tags)
-                if "error" in saved_related_tags:
-                    return general_error(saved_related_tags["error"])
-
-                # ////////////////////////////////////////////// #
-                #
-                # Second step: Create productos with their codes #
-                #
-                # ////////////////////////////////////////////// #
-                codes = request.session["form_codes"]
-
-                controllerProducts = ProductosController(
-                    codes=codes,
-                    technique=technique
-                )
-
-                controllerProducts.setProductsNoSave()
-                saved_prodcuts = controllerProducts.saveProducts()
-                if isinstance(saved_prodcuts, dict):
-                    return general_error(saved_prodcuts["error"])
-
-                # /////////////////////////////////////////////////////// #
-                #
-                # Third step: Create relations technique with Words Style #
-                #
-                # /////////////////////////////////////////////////////// #
-                ids_words = request.session["form_words"]
-                words_controller = PalabrasController(ids=ids_words)
-
-                words_to_use = words_controller.setWords()
-                if isinstance(words_to_use, dict):
-                    return general_error(words_to_use["error"])
-
-                style_controller = EstiloPalabrasController(
-                    technique=technique, words=words_to_use)
-
-                instace_style = style_controller.createAndSaveInstaceStyle()
-                if isinstance(instace_style, dict):
-                    return general_error(instace_style["error"])
-
-                words_using = style_controller.relatedWords()
-                if isinstance(words_using, dict):
-                    return general_error(words_using["error"])
-
-                # //////////////////////////////////////////////////////// #
-                #
-                # Fourth step: Create session and relat with the technique #
-                #
-                # //////////////////////////////////////////////////////// #
-                session_controller = SesionController(
-                    name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
-                    technique=technique,
-                    creator=request.user.user_presentador
-                )
-
-                setting_session = session_controller.setSession()
-                if isinstance(setting_session, dict):
-                    return general_error(setting_session["error"])
-
-                saved_session = session_controller.saveSession()
-                if isinstance(saved_session, dict):
-                    return general_error(saved_session["error"])
-
-                context = {
-                    "message": "sesión creada",
-                    "data": {
-                        "codigo_sesion": saved_session.codigo_sesion,
-                        "nombre_sesion": saved_session.nombre_sesion
+                    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"])
+
+                    # ////////////////////////////////////////////// #
+                    #
+                    # Second step: Create productos with their codes #
+                    #
+                    # ////////////////////////////////////////////// #
+                    codes = request.session["form_codes"]
+
+                    controllerProducts = ProductosController(
+                        codes=codes,
+                        technique=technique
+                    )
+
+                    controllerProducts.setProductsNoSave()
+                    saved_prodcuts = controllerProducts.saveProducts()
+                    if isinstance(saved_prodcuts, dict):
+                        raise ValueError(saved_prodcuts["error"])
+
+                    # /////////////////////////////////////////////////////// #
+                    #
+                    # Third step: Create relations technique with Words Style #
+                    #
+                    # /////////////////////////////////////////////////////// #
+                    style_words = technique.id_estilo.nombre_estilo
+                    if style_words == "atributos":
+                        ids_words = request.session["form_words"]
+                        words_controller = PalabrasController(ids=ids_words)
+
+                        words_to_use = words_controller.setWords()
+                        if isinstance(words_to_use, dict):
+                            raise ValueError(words_to_use["error"])
+
+                        style_controller = EstiloPalabrasController(
+                            technique=technique, words=words_to_use)
+
+                        instace_style = style_controller.createAndSaveInstaceStyle()
+                        if isinstance(instace_style, dict):
+                            raise ValueError(instace_style["error"])
+
+                        words_using = style_controller.relatedWords()
+                        if isinstance(words_using, dict):
+                            raise ValueError(words_using["error"])
+                    elif style_words == "vocabulario":
+                        name_vocabulary = request.session["form_words"]
+                        try:
+                            vocabulary = Vocabulario.objects.get(
+                                nombre_vocabulario=name_vocabulary)
+                        except Vocabulario.DoesNotExist:
+                            raise ValueError("Vocabulario no encontrado")
+
+                        es_vocabulary = EsVocabulario.objects.create(
+                            id_tecnica=technique,
+                            id_vocabulario=vocabulary
+                        )
+                    else:
+                        raise ValueError("Estilo de palabas no permitido")
+
+                    # //////////////////////////////////////////////////////// #
+                    #
+                    # Fourth step: Create session and relat with the technique #
+                    #
+                    # //////////////////////////////////////////////////////// #
+                    session_controller = SesionController(
+                        name_session=data_basic["nombre_sesion"] if data_basic["nombre_sesion"] != "" else None,
+                        technique=technique,
+                        creator=request.user.user_presentador
+                    )
+
+                    setting_session = session_controller.setSession()
+                    if isinstance(setting_session, dict):
+                        raise ValueError(setting_session["error"])
+
+                    saved_session = session_controller.saveSession()
+                    if isinstance(saved_session, dict):
+                        raise ValueError(saved_session["error"])
+
+                    context = {
+                        "message": "sesión creada",
+                        "data": {
+                            "codigo_sesion": saved_session.codigo_sesion,
+                            "nombre_sesion": saved_session.nombre_sesion
+                        }
                     }
-                }
 
-                # ////////////////////////////////// #
-                #
-                # Final step: Delete date en session #
-                #
-                # ////////////////////////////////// #
-                deleteDataSession(request)
-                return JsonResponse(context)
+                    # ////////////////////////////////// #
+                    #
+                    # Final step: Delete date en session #
+                    #
+                    # ////////////////////////////////// #
+
+                    deleteDataSession(request)
+                    return JsonResponse(context)
+            except ValueError as e:
+                return general_error(f"Error: {e}")
         else:
             return general_error("No se ha establecido acción")

tecnicas/controllers/views_controller/create_session/panel_words_controller.py

@@ -1,5 +1,5 @@
 from django.http import HttpRequest
-from tecnicas.forms import WordForm
+from tecnicas.forms import WordForm, VocabularioSelectForm
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from tecnicas.models import Palabra
@@ -7,27 +7,36 @@ import json
 
 
 class PanelWordsController():
+    current_url_escalas_atribute = "tecnicas/create_sesion/configuracion-panel-words.html"
+    current_url_escalas_vocabulary = "tecnicas/create_sesion/conf-panel-vocabulary.html"
+
     def __init__(self):
         pass
 
     @staticmethod
-    def controllGetEscalas(request: HttpRequest):
+    def controllGetEscalasAtributes(request: HttpRequest):
         form = WordForm()
         context = {
             "form_word": form
         }
 
-        return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+        return render(request, PanelWordsController.current_url_escalas_atribute, context)
+
+    @staticmethod
+    def controllGetEscalasVocabulary(request: HttpRequest):
+        form = VocabularioSelectForm()
+        context = {"form": form}
+        return render(request, PanelWordsController.current_url_escalas_vocabulary, context)
 
     @staticmethod
-    def controllPostEscalas(request: HttpRequest):
+    def controllPostEscalasAtributes(request: HttpRequest):
         form = WordForm()
         context = {
             "form_word": form
         }
 
         if not request.POST.get("words"):
-            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+            return render(request, PanelWordsController.current_url_escalas_atribute, context)
 
         words = json.loads(request.POST.get("words"))
         context["words"] = words
@@ -36,14 +45,34 @@ class PanelWordsController():
 
         if len(ids_words) != len(set(ids_words)):
             context["error"] = "existen palabras duplicadas"
-            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+            return render(request, PanelWordsController.current_url_escalas_atribute, context)
 
         exist_words = Palabra.objects.filter(
             id__in=ids_words).count() == len(ids_words)
 
         if not exist_words:
             context["error"] = "algunas palabras no existen"
-            return render(request, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+            return render(request, PanelWordsController.current_url_escalas_atribute, context)
 
         request.session["form_words"] = ids_words
         return redirect(reverse("cata_system:creando_sesion"))
+
+    @staticmethod
+    def controllPostEscalasVocabulary(request: HttpRequest):
+        context = {}
+        if not request.POST.get("vocabulario"):
+            context["form"] = VocabularioSelectForm()
+            context["error"] = "No hay un vocabulario seleccionado"
+            return render(request, PanelWordsController.current_url_escalas_vocabulary, context)
+
+        form = VocabularioSelectForm(request.POST)
+        vocabulary: int
+        if form.is_valid():
+            vocabulary = form.cleaned_data["vocabulario"]
+        else:
+            context["form"] = VocabularioSelectForm()
+            context["error"] = "Erro al validar el vocabulario"
+            return render(request, PanelWordsController.current_url_escalas_vocabulary, context)
+
+        request.session["form_words"] = vocabulary.nombre_vocabulario
+        return redirect(reverse("cata_system:creando_sesion"))

tecnicas/controllers/views_controller/vocabulary_manage/create_vocabulary_controller.py

@@ -0,0 +1,110 @@
+from django.shortcuts import render
+from django.db import IntegrityError
+from django.http import HttpRequest
+from tecnicas.forms import WordForm
+from tecnicas.models import Vocabulario, Palabra
+import json
+
+
+class CreateVocabularyController():
+    context = {}
+    current_url = "tecnicas/manage_vocabulary/create-vocabulary.html"
+
+    def __init__(self, form_word: WordForm = WordForm(), list_words: list = []):
+        self.context["form_word"] = form_word
+        self.context["words"] = list_words
+
+    def controllGet(self, request: HttpRequest):
+        self.context = {
+            "form_word": WordForm(),
+            "words": []
+        }
+
+        if "name_voca" in request.GET:
+            current = Vocabulario.objects.get(
+                nombre_vocabulario=request.GET["name_voca"])
+            self.context["name_vacabulary"] = current.nombre_vocabulario
+            self.context["words"] = current.palabras.all()
+
+        return render(request, self.current_url, self.context)
+
+    def controllPost(self, request: HttpRequest):
+        self.context = {
+            "form_word": self.context["form_word"],
+            "words": self.context["words"],
+        }
+
+        if "nombre_vocabulario" not in request.POST:
+            self.context["error"] = "Nombre de vocabulario requerido"
+            return render(request, self.current_url, self.context)
+
+        new_vocabulary_name = request.POST.get("nombre_vocabulario").strip()
+        is_update = request.POST.get("is_update")
+
+        print(is_update)
+
+        if is_update:
+            if "original_name" not in request.POST:
+                self.context["error"] = "Nombre original de vocabulario requerido"
+                return render(request, self.current_url, self.context)
+
+            original_name = request.POST["original_name"].strip()
+
+            if original_name != new_vocabulary_name:
+                if Vocabulario.objects.filter(nombre_vocabulario=new_vocabulary_name).exists():
+                    self.context["error"] = "Ya existe un vocabulario con el nombre pasado"
+                    return render(request, self.current_url, self.context)
+
+            try:
+                current_vocababulary = Vocabulario.objects.get(
+                    nombre_vocabulario=original_name)
+            except Vocabulario.DoesNotExist:
+                self.context["error"] = "No existe un vocabulario con ese nombre"
+                return render(request, self.current_url, self.context)
+
+            words_json = request.POST.get("words", "")
+            if words_json:
+                try:
+                    words_list = json.loads(words_json)
+
+                    ids = [int(w.get("id", 0))
+                           for w in words_list if str(w.get("id", "")).isdigit()]
+
+                    words = Palabra.objects.filter(id__in=ids)
+
+                    current_vocababulary.palabras.set(words)
+                    current_vocababulary.nombre_vocabulario = new_vocabulary_name
+                    current_vocababulary.save()
+                except (json.JSONDecodeError, ValueError):
+                    self.context["error"] = 'Ocurrió un error al revisar las palabras, revise “Ver vocabularios”, para reasignar las palabras'
+                    return render(request, self.current_url, self.context)
+
+            self.context["message"] = 'Vocabulario creado con éxito, puedes revisarlo en "Ver vocabularios"'
+            return render(request, self.current_url, self.context)
+        elif not is_update:
+            try:
+                new_vocababulary = Vocabulario.objects.create(
+                    nombre_vocabulario=new_vocabulary_name)
+            except IntegrityError:
+                self.context["error"] = "Ya existe un vocabulario con ese nombre"
+                return render(request, self.current_url, self.context)
+
+            words_json = request.POST.get("words", "")
+            if words_json:
+                try:
+                    words_list = json.loads(words_json)
+
+                    ids = [int(w.get("id", 0))
+                           for w in words_list if str(w.get("id", "")).isdigit()]
+
+                    words = Palabra.objects.filter(id__in=ids)
+
+                    new_vocababulary.palabras.add(*words)
+                except (json.JSONDecodeError, ValueError):
+                    self.context["error"] = 'Ocurrió un error al revisar las palabras, revise “Ver vocabularios”, para reasignar las palabras'
+                    return render(request, self.current_url, self.context)
+
+            self.context["message"] = 'Vocabulario actualziado con éxito, puedes revisarlo en "Ver vocabularios"'
+            return render(request, self.current_url, self.context)
+        else:
+            pass

tecnicas/controllers/views_controller/vocabulary_manage/list_vocabulary_controller.py

@@ -0,0 +1,48 @@
+from django.shortcuts import render
+from django.http import HttpRequest
+from django.core.paginator import Paginator, PageNotAnInteger
+from tecnicas.models import Vocabulario
+from tecnicas.utils import controller_error
+
+
+class ListVocabularyController():
+    current_url = "tecnicas/manage_vocabulary/list-vocabulary.html"
+
+    def __init__(self):
+        pass
+
+    def controllGet(self, request: HttpRequest, page: int):
+        context = {}
+
+        info_element_page = self.getVocabularys(page)
+
+        if isinstance(info_element_page, dict):
+            context["error"] = info_element_page["error"]
+            return render(request, self.current_url, context)
+
+        (vocabularies_in_page, is_last_page, current_page) = info_element_page
+
+        context["vocabularies"] = vocabularies_in_page
+        context["last_page"] = is_last_page
+        context["num_page"] = current_page
+
+        return render(request, self.current_url, context)
+
+    def getVocabularys(self, num_page: int):
+        elements_by_page = 6
+
+        queryset = Vocabulario.objects.all().order_by('-creado')
+
+        paginator = Paginator(queryset, elements_by_page)
+        try:
+            vocabularies_in_page = paginator.page(num_page)
+        except PageNotAnInteger:
+            return controller_error("índice inválido")
+
+        if not vocabularies_in_page.object_list:
+            return controller_error("Sin registros de Participaciones")
+
+        current_page = vocabularies_in_page.number
+        is_last_page = not current_page < paginator.num_pages
+
+        return (vocabularies_in_page, is_last_page, current_page)

tecnicas/forms/__init__.py

@@ -3,4 +3,5 @@ from .sesion_tags_form import SesionTagsForm
 from .etiqueta_form import EtiquetaForm
 from .codes_form import CodesForm
 from .catador_form import CatadorForm
-from .word_form import WordForm
+from .word_form import WordForm
+from .vocabulary_select import VocabularioSelectForm

tecnicas/forms/vocabulary_select.py

@@ -0,0 +1,15 @@
+from django import forms
+from tecnicas.models import Vocabulario
+
+
+class VocabularioSelectForm(forms.Form):
+    vocabulario = forms.ModelChoiceField(
+        queryset=Vocabulario.objects.all(),
+        required=True,
+        label="Selecciona un vocabulario",
+        empty_label="-- Selecciona uno --",
+        widget=forms.Select(attrs={
+            "class": "w-full border rounded p-4 bg-surface-sweet",
+            "id": "vocabulario"
+        })
+    )

tecnicas/migrations/0021_rename_nomre_vocabulario_vocabulario_nombre_vocabulario_and_more.py

@@ -0,0 +1,30 @@
+# Generated by Django 5.2.1 on 2025-11-06 21:46
+
+import django.utils.timezone
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0020_remove_catador_apellido_remove_catador_correo_and_more'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='vocabulario',
+            old_name='nomre_vocabulario',
+            new_name='nombre_vocabulario',
+        ),
+        migrations.AddField(
+            model_name='vocabulario',
+            name='creado',
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='codigo_sesion',
+            field=models.CharField(default=shortuuid.main.ShortUUID.uuid, editable=False, max_length=22, primary_key=True, serialize=False),
+        ),
+    ]

tecnicas/models/vocabulario.py

@@ -1,10 +1,13 @@
 from django.db import models
-
+from django.utils import timezone
 from .palabra import Palabra
 
+
 class Vocabulario(models.Model):
-    nomre_vocabulario = models.CharField(max_length=255, unique=True)
-    palabras = models.ManyToManyField(Palabra, related_name="vovabulario_palabras")
+    nombre_vocabulario = models.CharField(max_length=255, unique=True)
+    palabras = models.ManyToManyField(
+        Palabra, related_name="vovabulario_palabras")
+    creado = models.DateTimeField(default=timezone.now)
 
     def __str__(self):
-        return self.nomre_vocabulario
+        return self.nombre_vocabulario

tecnicas/static/js/choose-vocabulary.js

@@ -0,0 +1,67 @@
+document.addEventListener("DOMContentLoaded", () => {
+  const vocabSelect = document.getElementById("vocabulario");
+  const wordsList = document.getElementById("palabras-lista");
+  const formNextStep = document.getElementById("cts-create-session");
+  let vocabularyId = "";
+
+  vocabSelect.addEventListener("change", async (e) => {
+    const vocabId = e.target.value;
+    vocabularyId = vocabId;
+    console.log(e.target);
+    console.log(vocabId);
+
+    wordsList.innerHTML =
+      "<li class='text-gray-500 text-center'>Cargando...</li>";
+
+    if (!vocabId) {
+      wordsList.innerHTML =
+        "<li class='text-gray-500 text-center'>Selecciona un vocabulario para ver sus palabras</li>";
+      return;
+    }
+
+    url_fetch = `api/vocabulario/${vocabId}/palabras`;
+
+    try {
+      const response = await fetch(url_fetch, { method: "GET" });
+      if (!response.ok) throw new Error("Error en la petición");
+      const json_response = await response.json();
+
+      words = json_response.data.words;
+
+      if (words === 0) {
+        wordsList.innerHTML =
+          "<li class='text-center text-lg'>No hay palabras asociadas</li>";
+        return;
+      }
+
+      wordsList.innerHTML = "";
+      words.forEach((p) => {
+        const li = document.createElement("li");
+        li.textContent = p.nombre_palabra;
+        li.className =
+          "bg-surface-sweet text-black rounded font-bold text-lg px-4 py-3";
+        wordsList.appendChild(li);
+      });
+    } catch (err) {
+      wordsList.innerHTML =
+        "<li class='text-red-500 text-center text-lg'>Error al cargar las palabras</li>";
+      console.error(err);
+    }
+  });
+
+  formNextStep.addEventListener("submit", (e) => {
+    if (!vocabularyId) {
+      e.preventDefault();
+      wordsList.innerHTML =
+        "<li class='text-center text-lg'>Seleccione un Vocabulario</li>";
+      return;
+    }
+
+    const useVocabulary = document.createElement("input");
+    useVocabulary.type = "hidden";
+    useVocabulary.name = "vocabulario";
+    useVocabulary.value = vocabularyId;
+
+    formNextStep.appendChild(useVocabulary);
+  });
+});

tecnicas/static/js/created-vocabulary.js

@@ -0,0 +1,48 @@
+// **************************************
+// Create Vocabulary
+// **************************************
+async function submitSelectWords(classNanmeForm, update = false) {
+  const form = document.querySelector(`.${classNanmeForm}`);
+
+  const name_vocabulary = form.querySelector(".cts-name-voca").value;
+  if (!name_vocabulary || name_vocabulary == "") {
+    spanNotificationRed("Se requiere el nombre del vocabulario");
+    return;
+  }
+
+  if (listWordsSelect.length === 0) {
+    spanNotificationRed("Debe seleccionar al menos una palabra");
+    return;
+  }
+
+  const wordsInput = document.createElement("input");
+  wordsInput.type = "hidden";
+  wordsInput.name = "words";
+  wordsInput.value = JSON.stringify(listWordsSelect);
+
+  const [isUpdata, orinalName] = inputIsUpdateVocabulary(update);
+
+  form.appendChild(wordsInput);
+  form.appendChild(isUpdata);
+  if (orinalName) form.appendChild(orinalName);
+
+  form.submit();
+}
+
+function inputIsUpdateVocabulary(is_update = false) {
+  const isUpdata = document.createElement("input");
+  isUpdata.type = "hidden";
+  isUpdata.name = "is_update";
+  isUpdata.value = is_update;
+
+  if (is_update) {
+    const orinalName = document.querySelector(".cts-original-name").textContent;
+    const inputName = document.createElement("input");
+    inputName.type = "hidden";
+    inputName.name = "original_name";
+    inputName.value = orinalName;
+    return [isUpdata, inputName];
+  }
+
+  return [isUpdata, is_update];
+}

tecnicas/static/js/panel-words.js

@@ -28,7 +28,7 @@ async function getWordsByName(e) {
     palabra: dataForm.get("search").trim(),
   });
 
-  const url = `/cata/api/palabras?${params}`;
+  const url = `api/palabras?${params}`;
 
   try {
     const respone = await fetch(url, {

tecnicas/templates/tecnicas/components/item_vocabulary.html

@@ -0,0 +1,20 @@
+<div class='card bg-surface-ligt shadow-lg text-black sm:max-w-80 w-full flex justify-center items-center'>
+    <div class="card-body flex flex-col justify-between w-full">
+        <div class="flex flex-col gap-2">
+            <h2 class="text-xl font-bold text-right bg-btn-secondary text-white p-2 rounded">
+                {{ vocabulary.nombre_vocabulario }}
+            </h2>
+            <div class="text-lg bg-surface-alter-card p-2 rounded">
+                <p class="font-bold">Creado en:</p>
+                <p>{{ vocabulary.creado }}</p>
+            </div>
+        </div>
+        <div>
+            <a href="{% url 'cata_system:crear_vocabulario' %}?name_voca={{vocabulary.nombre_vocabulario}}">
+                <button class="btn bg-btn-primary border-0 block w-full btn-push">
+                    Revisar Vocabulario
+                </button>
+            </a>
+        </div>
+    </div>
+</div>

tecnicas/templates/tecnicas/create_sesion/conf-panel-vocabulary.html

@@ -0,0 +1,62 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content text-black lg:w-4xl">
+        <h2 class="text-2xl font-bold text-center bg-surface-card p-4 rounded-lg">
+            Elegir vocabulario
+        </h2>
+
+        <form method="get" id="form-vocabulario" class="bg-surface-card rounded-lg p-6">
+            <label for="{{ form.vocabulario.id_for_label }}"
+                class="text-lg w-fit font-medium tracking-wide w-full space-y-4">
+                <p class="tracking-normal text-xl font-bold">Seleccione un vocabulario</p>
+                {{ form.vocabulario }}
+            </label>
+        </form>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
+        <div id="palabras-container" class="rounded-lg p-3 min-h-24 max-h-64 overflow-y-auto bg-surface-card">
+            <h3 class="text-xl font-semibold">Palabras asociadas:</h3>
+            <ul id="palabras-lista" class="flex flex-wrap gap-4">
+                <li class="text-center text-lg">Selecciona un vocabulario para ver sus palabras</li>
+            </ul>
+        </div>
+
+        <section>
+            <form action="" method="post" id="cts-create-session" class="flex justify-center mt-4">
+                {% csrf_token %}
+                <article class="cs-escalas-radio w-full flex flex-col gap-4">
+                    <section class="flex max-sm:flex-col flex-wrap items-center justify-center gap-4">
+                        <button type="submit" name="start"
+                            class="cts-btn-general cts-btn-primary btn-push flex-1 w-full">
+                            Crear sesión
+                        </button>
+                        <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
+                            <button type="button" class="cts-btn-general cts-btn-secondary btn-push w-full">
+                                Paso anterior
+                            </button>
+                        </a>
+                    </section>
+                    <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
+                        <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
+                            Cancelar la creación
+                        </button>
+                    </a>
+                </article>
+            </form>
+        </section>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/choose-vocabulary.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/main-panel.html

@@ -6,13 +6,13 @@
 {% block content %}
 <article class="cts-container-main">
     <article class="cts-wrap-content">
-        <header class="flex flex-col flex-wrap justify-center items-center gap-8">
+        <header class="flex flex-col flex-wrap justify-center items-center space-y-8">
             <section class="bg-surface-card p-8 rounded-md w-full shadow-lg">
                 <h1 class="text-black text-4xl font-bold text-center max-sm:text-2xl">Panel Principal</h1>
             </section>
             <section
-                class="flex flex-wrap justify-center max-sm:gap-4 items-center p-8 w-full bg-surface-card rounded-md shadow-lg">
-                <section class="flex flex-col text-black flex-1 flex-wrap gap-4">
+                class="flex max-sm:flex-col flex-wrap justify-center max-sm:gap-4 items-center p-8 w-full bg-surface-card rounded-md shadow-lg">
+                <section class="flex flex-col text-black flex-1 flex-wrap gap-4 w-full">
                     <fieldset class="fieldset rounded-box border px-3 pb-3 rounded-2xl">
                         <legend class="text-black fieldset-legend px-1.5">Nombre Presentador</legend>
                         <p class="text-3xl max-sm:text-2xl font-medium">{{ name }}</p>
@@ -23,9 +23,9 @@
                         <p class="text-3xl max-sm:text-2xl font-medium">{{ cumple }}</p>
                     </fieldset>
                 </section>
-                <section class="flex-1 flex justify-center">
+                <section class="flex-1 flex justify-center max-sm:w-full">
                     <button type="button"
-                        class="btn btn-active text-xl tracking-wider font-bold text-black btn-error py-8 px-12 border-b-red-600 btn-push"
+                        class="text-black cts-btn-general cts-btn-error btn-push max-sm:w-full"
                         onclick="exit_sesion('frm-exit')">
                         Salir del sistema
                     </button>
@@ -37,32 +37,29 @@
         {% include "./components/error-message.html" with message=error %}
         {% endif %}
 
-        <article class="w-full flex flex-col gap-7 items-center min-sm:mt-7 mt-4 bg-surface-card rounded-lg shadow-lg">
-            <article
-                class="w-5xl max-lg:w-3xl max-md:w-auto p-8 flex flex-col justify-around items-center gap-4 flex-wrap text-3xl max-sm:text-2xl">
-                <section class="flex flex-row flex-wrap gap-4 w-full">
-                    <a href="{% url 'cata_system:seleccion_tecnica' %}" class="flex-1 w-full">
-                        <button
-                            class="w-full text-black bg-btn-primary font-medium rounded-xl px-8 py-4 text-center border-b-green-800 btn-push">
-                            Iniciar Sesión <br> Sensorial
-                        </button>
-                    </a>
-                    <a href="{% url 'cata_system:panel_catadores' %}" class="flex-1 w-full">
-                        <button
-                            class="w-full text-black bg-btn-secondary font-medium rounded-xl px-8 py-4 text-center border-b-pink-800 btn-push">
-                            Gestión de <br>catadores
-                        </button>
-                    </a>
-                </section>
-
-                <section class="flex flex-row flex-wrap gap-4 w-f ull justify-center">
-                    <a href="{% url 'cata_system:panel_sesiones' page=1 %}">
-                        <button
-                            class="text-black bg-btn-tertiary font-medium rounded-xl px-8 py-4 text-center border-b-pink-800 btn-push">
-                            Gestión de sesiones<br>sensoriales
-                        </button>
-                    </a>
-                </section>
+        <article class="w-full py-6 p-2 sm:p-4 md:p-8 bg-surface-card rounded-lg shadow-lg">
+            <article class="grid grid-cols-2 gap-6 w-5xl max-lg:w-3xl max-md:w-auto text-3xl max-sm:text-2xl 
+         max-md:grid-cols-1 justify-items-center items-start place-items-stretch">
+                <a href="{% url 'cata_system:seleccion_tecnica' %}" class="w-full">
+                    <button class="w-full text-black cts-btn-general cts-btn-tertiary btn-push">
+                        Iniciar Sesión <br> Sensorial
+                    </button>
+                </a>
+                <a href="{% url 'cata_system:panel_catadores' %}" class="w-full">
+                    <button class="w-full text-black cts-btn-general cts-btn-tertiary btn-push">
+                        Gestión de <br>catadores
+                    </button>
+                </a>
+                <a href="{% url 'cata_system:panel_sesiones' page=1 %}" class="w-full">
+                    <button class="w-full text-black cts-btn-general cts-btn-tertiary btn-push">
+                        Gestión de sesiones<br>sensoriales
+                    </button>
+                </a>
+                <a href="{% url 'cata_system:panel_vocabulario' %}" class="w-full h-full">
+                    <button class="w-full h-full text-black cts-btn-general cts-btn-tertiary btn-push">
+                        Gestión de vocabularios
+                    </button>
+                </a>
             </article>
         </article>
     </article>

tecnicas/templates/tecnicas/manage_vocabulary/create-vocabulary.html

@@ -0,0 +1,139 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Crear vocabulario{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article
+        class="ct-notification-red absolute max-md:fixed bottom-0 mb-4 left-1/2 -translate-x-1/2 bg-red-400 text-white p-2 px-4 rounded-lg text-center font-bold hidden uppercase traking-wide">
+    </article>
+    <article
+        class="ct-notification-green absolute max-md:fixed bottom-0 mb-4 left-1/2 -translate-x-1/2 bg-green-600 text-white p-2 px-4 rounded-lg text-center font-medium hidden uppercase">
+    </article>
+
+    <article class="cts-wrap-content text-black lg:w-4xl space-y-4">
+        <h1 class="w-full text-center font-bold text-4xl bg-surface-card py-8 rounded-lg">Crear vocabulario</h1>
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+        {% endif %}
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
+        <article class="rounded-lg space-y-4 w-full">
+            <form action="" method="post" class="cts-craed-vocabulary bg-surface-card p-4 rounded-lg">
+                {% csrf_token %}
+                <label for="nombre_vocabulario" class="font-bold text-2xl mb-2 block">Nombre del vocabulario</label>
+                {% if name_vacabulary %}
+                <input id="nombre_vocabulario" name="nombre_vocabulario" type="text" required
+                    class="cts-name-voca p-2 px-4 bg-surface-ligt rounded-lg w-full text-lg font-medium"
+                    placeholder="Ingrese un nombre" value="{{ name_vacabulary }}">
+                {% else %}
+                <input id="nombre_vocabulario" name="nombre_vocabulario" type="text" required
+                    class="cts-name-voca p-2 px-4 bg-surface-ligt rounded-lg w-full text-lg font-medium"
+                    placeholder="Ingrese un nombre">
+                {% endif %}
+                <p class="text-lg mt-2 font-semibold">Debajo puede buscar y seleccionar palabras para asignarlas a
+                    este vocabulario.</p>
+            </form>
+
+            <article class="flex flex-col md:flex-row gap-5 justify-between">
+                <section class="flex-3/5 flex flex-col gap-4 min-h-96 max-h-96">
+                    <form action="" method="get" class="ct-serach-words bg-surface-card p-4 rounded-lg">
+                        {% csrf_token %}
+                        <p class="text-lg font-semibold mb-2">
+                            Dejar en blaco para buscar las primeras 10 palabras
+                        </p>
+                        <section class="flex flex-row gap-2">
+                            <label for="search" class="w-full">
+                                <input type="text" name="search" id="search" placeholder="Buscar palabra"
+                                    class="p-2 px-4 bg-surface-ligt rounded-lg w-full text-lg font-medium">
+                            </label>
+                            <button type="submit"
+                                class="font-bold rounded-lg text-xl px-3 text-center cts-btn-tertiary btn-push">
+                                Buscar
+                            </button>
+                        </section>
+                    </form>
+                    <p class="ct-error-words hidden capitalize bg-red-600 text-center text-2xl p-1.5 rounded">
+                        error</p>
+                    <ul class="ct-palabras-encontradas gap-2 grid-cols-2 overflow-y-auto">
+                        <div class="flex justify-center items-center">
+                            <img src="{% static 'img/lupa.svg' %}" alt="lupa de busqueda" style="width: 50%;">
+                        </div>
+                    </ul>
+                </section>
+
+                <section
+                    class="flex-1/3 bg-surface-card p-4 rounded-lg text-center min-h-96 max-h-96 flex flex-col overflow-hidden">
+                    <div>
+                        <p class="text-xl font-bold pb-3">Lista de palabras</p>
+                        <hr class="mb-3">
+                    </div>
+                    <ul class="ct-palabras-usadas flex flex-col gap-3 overflow-y-auto max-h-full">
+                        {% if not words %}
+                        <img src="{% static 'img/list.svg' %}" alt="lista de palabras" class="ct-img-list">
+                        {% endif %}
+                        {% for word in words %}
+                        <li
+                            class="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">
+                            <p class="ct-word-received" id="{{ word.id }}">{{ 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 w-fit capitalize active:border-red-500 border-red-800 bg-red-500">➖</button>
+                        </li>
+                        {% endfor %}
+                    </ul>
+                </section>
+            </article>
+
+            <form method="post" action="" class="ct-form-new-word p-4 bg-surface-card rounded-lg">
+                {% csrf_token %}
+                <p class="mb-2 font-bold text-2xl">¿No encuentras una palabra?</p>
+                <section class="flex gap-4 flex-wrap justify-center">
+                    <label for="{{ form_word.nombre_palabra.id_for_label }}"
+                        class="font-medium w-fit text-xl flex-1 *:w-full *:h-full">
+                        {{ form_word.nombre_palabra }}
+                    </label>
+                    <button class="cts-btn-general-compress cts-btn-primary btn-push p-2 flex-1" type="submit">
+                        Crear y agregar a la lista
+                    </button>
+                </section>
+                <p class="ct-error-word mb-4 font-bold bg-red-500 text-md capitalize text-center rounded hidden">
+                    error
+                </p>
+            </form>
+
+            {% if name_vacabulary %}
+            <p class="hidden cts-original-name">{{ name_vacabulary }}</p>
+            {% endif %}
+
+            <article class="flex justify-center gap-4 mt-4">
+                {% if name_vacabulary %}
+                <button type="button" name="start" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full"
+                    onclick="submitSelectWords('cts-craed-vocabulary', true)">
+                    Actualizar vocabulario
+                </button>
+                {% else %}
+                <button type="button" name="start" class="cts-btn-general cts-btn-primary btn-push flex-1 w-full"
+                    onclick="submitSelectWords('cts-craed-vocabulary')">
+                    Crear vocabulario
+                </button>
+                {% endif %}
+                <a href="{% url 'cata_system:panel_vocabulario' %}" class="flex-1 w-full">
+                    <button type="button" class="cts-btn-general cts-btn-error btn-push w-full">
+                        Cancelar
+                    </button>
+                </a>
+            </article>
+        </article>
+
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/panel-words.js' %}"></script>
+<script src="{% static 'js/created-vocabulary.js' %}"></script>
+{% endblock %}

tecnicas/templates/tecnicas/manage_vocabulary/list-vocabulary.html

@@ -0,0 +1,57 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Panel Sesiones{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content">
+        <header class="text-center flex flex-row max-sm:flex-col gap-8 items-center w-full">
+            <div class="bg-surface-card p-4 text-black shadow-lg rounded-xl flex-1">
+                <h1 class="font-bold text-2xl">Revisa los vocabularios existentes</h1>
+            </div>
+            <div class="flex-1 flex justify-end items-center">
+                <a href="{% url 'cata_system:panel_vocabulario' %}" class="w-fit">
+                    <button class="cts-btn-general cts-btn-error btn-push">
+                        Panel Vocabulario
+                    </button>
+                </a>
+            </div>
+        </header>
+        {% if message %}
+        {% include "../components/error-message.html" with message=message %}
+        {% endif %}
+
+        {% if error %}
+        {% include "../components/error-message.html" with message=error %}
+
+        {% else %}
+        <section class="grid grid-cols-3 max-lg:grid-cols-2 max-sm:grid-cols-1 w-full gap-4 justify-center">
+            {% for vocabu in vocabularies %}
+            {% include "../components/item_vocabulary.html" with vocabulary=vocabu %}
+            {% endfor %}
+        </section>
+
+        <section class="flex justify-center items-center gap-2">
+            <div class="join space-x-2">
+                {% if num_page != 1 %}
+                <a href="{% url 'cata_system:panel_sesiones' page=num_page|add:-1 %}" class="w-fit">
+                    <button class="join-item btn bg-btn-secondary py-1">
+                        <img class="h-full" src="{% static 'img/less-than.svg' %}" alt="menor que">
+                    </button>
+                </a>
+                {% endif %}
+                <button class="join-item btn bg-btn-secondary">Page {{ num_page }}</button>
+                {% if not last_page %}
+                <a href="{% url 'cata_system:panel_sesiones' page=num_page|add:1 %}" class="w-fit">
+                    <button class="join-item btn bg-btn-secondary py-1">
+                        <img class="h-full" src="{% static 'img/greater-than.svg' %}" alt="mayor que">
+                    </button>
+                </a>
+                {% endif %}
+            </div>
+        </section>
+        {% endif %}
+    </article>
+</article>
+{% endblock %}

tecnicas/templates/tecnicas/manage_vocabulary/panel-vocabulary.html

@@ -0,0 +1,42 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Gestionar Catadores{% endblock %}
+
+{% block content %}
+<article class="cts-container-main">
+    <article class="cts-wrap-content">
+        <header class="flex gap-4">
+            <div class="bg-surface-card p-8 text-2xl text-black font-bold rounded-lg text-center block">
+                <h1>Panel de vocabularios</h1>
+            </div>
+            <a href="{% url 'cata_system:index' %}" class="block flex-1">
+                <button
+                    class="w-full h-full text-black cts-btn-general cts-btn-error btn-push">
+                    Ir al Panel principal
+                </button>
+            </a>
+        </header>
+        <section class="flex flex-col gap-7">
+                <div class="w-full h-40 rounded-lg max-sm:hidden">
+                    <img src="{% static 'img/letters.webp' %}" alt="varias personas en fila"
+                        class="w-full h-full object-cover rounded-xl">
+                </div>
+                <a href="{% url 'cata_system:crear_vocabulario' %}" class="flex-1">
+                    <button class="w-full h-full cts-btn-general cts-btn-primary btn-push">
+                        ➕ Crear Vocabulario
+                    </button>
+                </a>
+                <a href="{% url 'cata_system:lista_vocabulario' num_page=1 %}" class="flex-1">
+                    <button class="w-full h-full cts-btn-general cts-btn-tertiary btn-push">
+                        📋 Ver vocabularios
+                    </button>
+                </a>
+                <div class="w-full h-40 rounded-lg min-sm:hidden">
+                    <img src="{% static 'img/letters.webp' %}" alt="varias personas en fila"
+                        class="w-full h-full object-cover rounded-xl">
+                </div>
+            </section>
+    </article>
+</article>
+{% endblock %}

tecnicas/urls.py

@@ -44,6 +44,18 @@ urlpatterns = [
          views.createSession,
          name="creando_sesion"),
 
+    # Gestion de Vocabularios
+    path("presenter/panel-vocabulario",
+         views.vocabularyMenu,
+         name="panel_vocabulario"),
+
+    path("presenter/crear-vocabulario",
+         views.createVocabulary,
+         name="crear_vocabulario"),
+
+    path("presenter/lista-vocabulario/<int:num_page>",
+         views.listVocabulary,
+         name="lista_vocabulario"),
 
     # Gestion de catadores
     path("presenter/panel-catadores",
@@ -100,14 +112,18 @@ urlpatterns = [
 
 
     # APIs
-    path("api/nueva-etiqueta",
+    path("presenter/api/nueva-etiqueta",
          views.newTag,
          name="nueva_etiqueta"),
 
-    path("api/palabras",
+    path("presenter/api/palabras",
          views.words,
          name="api_palabras"),
 
+    path("presenter/api/vocabulario/<int:vocab_id>/palabras",
+         views.wordsVocabulary,
+         name="api_palabras_vocabulary"),
+
     path("testers/api/ratingword",
          views.reatingWord,
          name="api_rating_word"),

tecnicas/views/__init__.py

@@ -18,8 +18,13 @@ from .tester_management.tester_create import testerCreate
 from .tester_management.tester_search import testerSearch
 from .tester_management.tester_list import testerList
 
+from .vocabulary_management.vocabulry_menu import vocabularyMenu
+from .vocabulary_management.create_vocabulary import createVocabulary
+from .vocabulary_management.list_vocabulary import listVocabulary
+
 from .apis.api_tag import newTag
 from .apis.api_words import words
+from .apis.api_words import wordsVocabulary
 from .apis.rating_word import reatingWord
 
 from .tester_forms.init_tester_form import initTesterForm

tecnicas/views/apis/api_words.py

@@ -1,9 +1,10 @@
 from django.http import HttpRequest, JsonResponse
 from tecnicas.decorators import required_presenter
-from tecnicas.models import Palabra
+from tecnicas.models import Palabra, Vocabulario
 from tecnicas.utils import general_error
 from tecnicas.forms.word_form import WordForm
 
+
 @required_presenter
 def words(req: HttpRequest):
     if req.method == "GET":
@@ -48,3 +49,21 @@ def words(req: HttpRequest):
         else:
             errors = form.errors.get("nombre_palabra")
             return general_error(errors[0])
+
+
+@required_presenter
+def wordsVocabulary(req: HttpRequest, vocab_id: int):
+    if req.method == "GET":
+        vocabulary = Vocabulario.objects.filter(id=vocab_id).first()
+        if not vocabulary:
+            return JsonResponse([])
+        palabras = vocabulary.palabras.all().values("id", "nombre_palabra")
+        response_json = {
+            "ok": True,
+            "data": {
+                "words": list(palabras)
+            }
+        }
+        return JsonResponse(response_json)
+    else:
+        return JsonResponse({"error": "Este método no es permitido"})

tecnicas/views/sessions_config/configuration_panel_words.py

@@ -1,6 +1,7 @@
 from django.http import HttpRequest, JsonResponse
 from django.shortcuts import redirect
 from django.urls import reverse
+from tecnicas.models import EstiloPalabra
 from tecnicas.controllers import PanelWordsController
 from tecnicas.utils import deleteDataSession
 
@@ -12,18 +13,30 @@ def configurationPanelWords(req: HttpRequest):
                         "?error=datos requeridos no encontrados")
 
     basic_data = req.session["form_basic"]
+    style_words = EstiloPalabra.objects.get(id=basic_data["estilo_palabras"])
 
     if req.method == "GET":
         if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
-            response = PanelWordsController.controllGetEscalas(req)
+            if style_words.nombre_estilo == "atributos":
+                response = PanelWordsController.controllGetEscalasAtributes(req)
+            elif style_words.nombre_estilo == "vocabulario":
+                response = PanelWordsController.controllGetEscalasVocabulary(req)
+            else:
+                response = redirect(
+                    reverse("cata_system:seleccion_tecnica") + "?error=Estilo de palabras no valida")
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")
-
         return response
     elif req.method == "POST":
         if basic_data["name_tecnica"] == "escalas" or basic_data["name_tecnica"] == "rata":
-            response = PanelWordsController.controllPostEscalas(req)
+            if style_words.nombre_estilo == "atributos":
+                response = PanelWordsController.controllPostEscalasAtributes(req)
+            elif style_words.nombre_estilo == "vocabulario":
+                response = PanelWordsController.controllPostEscalasVocabulary(req)
+            else:
+                response = redirect(
+                    reverse("cata_system:seleccion_tecnica") + "?error=Estilo de palabras no valida")
         else:
             response = redirect(
                 reverse("cata_system:seleccion_tecnica") + "?error=Técnica no valida")

tecnicas/views/vocabulary_management/create_vocabulary.py

@@ -0,0 +1,19 @@
+from django.shortcuts import render
+from django.http import HttpRequest
+from tecnicas.forms import WordForm
+from tecnicas.controllers import CreateVocabularyController
+
+
+def createVocabulary(req: HttpRequest):
+    view_controller = CreateVocabularyController()
+    if req.method == "GET":
+        response = view_controller.controllGet(req)
+        return response
+
+    elif req.method == "POST":
+        response = view_controller.controllPost(req)
+        return response
+
+    else:
+        context = {"error": "Método no permitido"}
+        return render(req, "tecnicas/manage_vocabulary/create-vocabulary.html", context)

tecnicas/views/vocabulary_management/list_vocabulary.py

@@ -0,0 +1,11 @@
+from django.http import HttpRequest
+from tecnicas.controllers import ListVocabularyController
+
+
+def listVocabulary(req: HttpRequest, num_page: int):
+    controll_view = ListVocabularyController()
+    if req.method == "GET":
+        response = controll_view.controllGet(req, num_page)
+        return response
+    else:
+        pass

tecnicas/views/vocabulary_management/vocabulry_menu.py

@@ -0,0 +1,4 @@
+from django.shortcuts import render
+
+def vocabularyMenu(req):
+    return render(req, "tecnicas/manage_vocabulary/panel-vocabulary.html")