Merge pull request #1 from CascoArcilla/HU3

Creación de Sesion Sensorial aplicando escalas simples.

.gitignore

@@ -167,6 +167,7 @@ cython_debug/
 
 # Others files
 some_test
+others_files
 
 # PyCharm
 #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can

cata_system/urls.py

@@ -16,8 +16,10 @@ Including another URLconf
 """
 from django.contrib import admin
 from django.urls import path, include
+from cata_system import views
 
 urlpatterns = [
+    path("", views.home, name="home"),
     path('cata/', include("tecnicas.urls")),
     path('admin/', admin.site.urls),
 

cata_system/views.py

@@ -0,0 +1,5 @@
+from django.http import HttpRequest
+from django.shortcuts import redirect
+
+def home(req: HttpRequest):
+    return redirect('/cata/')

tecnicas/admin.py

@@ -16,6 +16,11 @@ from .models import Palabra
 
 from .models import Etiqueta
 
+from .models import Escala
+from .models import EtiquetasEscala
+
+from .models import Producto
+
 # Register your models here.
 admin.site.register(CategoriaTecnica)
 admin.site.register(TipoEscala)
@@ -30,4 +35,9 @@ admin.site.register(Tecnica)
 admin.site.register(SesionSensorial)
 
 admin.site.register(EsAtributo)
-admin.site.register(Palabra)
+admin.site.register(Palabra)
+
+admin.site.register(Escala)
+admin.site.register(EtiquetasEscala)
+
+admin.site.register(Producto)

tecnicas/controllers/__init__.py

@@ -1,2 +1,8 @@
 from .tecnica_controller import TecnicaController
-from .escala_controller import EscalaController
+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

tecnicas/controllers/escala_controller.py

@@ -1,65 +1,70 @@
-from ..models import TipoEscala, Etiqueta, EtiquetasEscala, Escala, Tecnica
+from ..models import Etiqueta, EtiquetasEscala, Escala, TipoEscala
+from django.db import DatabaseError
+from ..utils import controller_error
 
 
 class EscalaController():
-
     scale: Escala
+    tags_relation: dict[str, EtiquetasEscala]
 
-    def __init__(self, scale):
-        self.scale = scale or None
+    def __init__(self, data):
+        self.scale = Escala(
+            id_tipo_escala=TipoEscala.objects.get(id=data["id_scale"]),
+            longitud=data["size"],
+            tecnica=data["technique"]
+        )
 
-    def setAndSaveScale(self, type_scale: TipoEscala, size: int, technique: Tecnica):
-        self.scale = Escala.objects.create(
-            id_tipo_escala=type_scale,
-            longitud=size,
-            tecnica=technique
+    def setScale(self, newData):
+        self.scale = Escala(
+            id_tipo_escala=TipoEscala.objects.get(id=newData["id_scale"]),
+            longitud=newData["size"],
+            tecnica=newData["technique"]
         )
 
-    def setScale(self, scale):
-        self.scale = scale
+    def saveScale(self):
+        try:
+            self.scale.save()
+            return self.scale
+        except DatabaseError as error:
+            return controller_error("error al guardar la escala")
 
-    def realte_tags_type_cotinue(self, tags: list):
-        tag = Etiqueta.objects.get(id=tags["punto_inicial"])
-        start_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=1
-        )
+    def deleteScale(self):
+        self.scale.delete()
 
-        tag = Etiqueta.objects.get(id=tags["punto_medio"])
-        half_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=2
-        )
+    def addAndSaveTags(self, tags: dict):
+        self.tags_relation = {}
+        if self.scale.id_tipo_escala.nombre_escala == "cotinua":
+            ok_tags = self.realte_tags_type_cotinue(tags)
+            if ok_tags["error"]:
+                return ok_tags
+            return self.tags_relation
 
-        tag = Etiqueta.objects.get(id=tags["punto_final"])
-        end_point = EtiquetasEscala.objects.create(
-            id_escala=self.scale.id,
-            id_etiqueta=tag,
-            posicion=3
-        )
+        elif self.scale.id_tipo_escala.nombre_escala == "estructurada":
+            ok_tags = self.realte_tags_type_structure(tags)
+            if ok_tags["error"]:
+                return ok_tags
+            return self.tags_relation
 
-        self.tags = [
-            ("start", start_point),
-            ("medium", half_point),
-            ("end", end_point)
-        ]
+    def deleteRelationshipsWithLabels(self):
+        for name, tag in self.tags_relation.items():
+            tag.delete()
 
-        return self.tags
+    def realteTags(self, tags: dict):
+        try:
+            index = 1
+            self.tags_relation = {}
 
-    def realte_tags_type_structure(self, tags: dict):
-        index = 1
-        self.tags = []
+            for name, id_tag in tags.items():
+                tag = Etiqueta.objects.get(id=id_tag)
+                related_tag = EtiquetasEscala.objects.create(
+                    id_escala=self.scale,
+                    id_etiqueta=tag,
+                    posicion=index
+                )
+                self.tags_relation[name] = related_tag
+                index += 1
 
-        for name, id_tag in tags.items():
-            tag = Etiqueta.objects.get(id=id_tag)
-            related_tag = EtiquetasEscala(
-                id_escala=self.scale.id,
-                id_etiqueta=tag,
-                posicion=index
-            )
-            self.tags.append((name, related_tag))
-            index += 1
-            
-        return self.tags
+            return self.tags_relation
+        except DatabaseError as error:
+            self.deleteRelationshipsWithLabels()
+            return controller_error("error guardar relacion etiqueta escala")

tecnicas/controllers/estilo_palabras_controller.py

@@ -0,0 +1,32 @@
+from ..models import EsAtributo, Tecnica, Palabra
+from django.db import DatabaseError
+from ..utils import controller_error
+
+
+class EstiloPalabrasController():
+    def __init__(self, technique: Tecnica = None, words: list[Palabra] = None):
+        self.technique = technique
+        self.list_words = words
+
+    def setTechnique(self, technique: Tecnica):
+        self.technique = technique
+
+    def setListWords(self, new_words: list[Palabra]):
+        self.list_words = new_words
+
+    def createAndSaveInstaceStyle(self):
+        try:
+            self.instanceStyle = EsAtributo.objects.create(
+                id_tecnica=self.technique)
+            return self.instanceStyle
+        except DatabaseError as error:
+            return controller_error("error al registrar el estilo con tecnica")
+
+    def relatedWords(self):
+        if not self.list_words:
+            return controller_error("no existen palabras para asociar")
+        try:
+            self.instanceStyle.palabras.add(*self.list_words)
+            return self.instanceStyle.palabras
+        except DatabaseError as error:
+            return controller_error("error al relacionar palabras con el estilo tecnica")

tecnicas/controllers/ordenes_controller.py

@@ -0,0 +1,76 @@
+from ..models import Orden, Posicion, Producto, Tecnica
+from ..utils import controller_error
+from django.db import DatabaseError
+
+
+class OrdenesController():
+    products: list[Producto]
+    technique: Tecnica
+    raw_list_orders: list[dict]
+    orders: list[Orden]
+    positions: list[Posicion]
+
+    def __init__(self, raw_orders: list[dict], list_products: list[Producto], technique: Tecnica):
+        self.products = list_products
+        self.technique = technique
+        self.raw_list_orders = raw_orders
+
+    def serRawOrders(self, new_raw_orders: list[dict]):
+        self.raw_list_orders = new_raw_orders
+
+    def setOrdersToSave(self):
+        self.orders = []
+        for raw in self.raw_list_orders:
+            self.orders.append(Orden(id_tecnica=self.technique))
+
+    def saveOrders(self):
+        if not self.orders:
+            return controller_error("no se han establecido las ordenes para guardar")
+        try:
+            for order in self.orders:
+                order.save()
+            return self.orders
+        except DatabaseError as error:
+            return controller_error("error al guardar las ordenes")
+
+    def setPositions(self):
+        codes_ids_products = {}
+        for product in self.products:
+            codes_ids_products[product.codigoProducto] = product.id
+        codes_expect = list(codes_ids_products.keys())
+
+        if len(self.orders) != len(self.raw_list_orders):
+            return controller_error("el numero de ordenes guardados no coinciden con los recibidos")
+
+        self.positions = []
+        for index, order in enumerate(self.raw_list_orders):
+            received_codes_order = list(order.keys())
+
+            if set(received_codes_order) != set(codes_expect):
+                return controller_error("las ordenes mandadas no contienen los productos esperados")
+
+            for name, position_index in order.items():
+                list_product_use = [product for product in self.products
+                                    if product.codigoProducto == name]
+
+                if len(list_product_use) != 1:
+                    return controller_error("no pueden existir dos productos que ocupen la misma posicion de un orden")
+
+                product_use = list_product_use[0]
+                new_position = Posicion(
+                    id_producto=product_use,
+                    id_orden=self.orders[index],
+                    posicion=position_index
+                )
+                self.positions.append(new_position)
+        return self.positions
+
+    def savePositions(self):
+        if not self.positions:
+            return controller_error("no se han establecido posiciones para guargar")
+        try:
+            for position in self.positions:
+                position.save()
+            return self.positions
+        except DatabaseError as error:
+            return controller_error("error al guardar las posiciones")

tecnicas/controllers/palabras_controller.py

@@ -0,0 +1,25 @@
+from ..models import Palabra
+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")

tecnicas/controllers/productos_controller.py

@@ -0,0 +1,39 @@
+from django.db import DatabaseError
+from ..utils import controller_error
+from ..models import Producto, Tecnica
+
+
+class ProductosController():
+    list_codes: list[str]
+    list_product: list[Producto]
+    technique: Tecnica
+
+    def __init__(self, codes: list[str], technique: Tecnica):
+        self.list_codes = codes
+        self.technique = technique
+
+    def setListCodes(self, new_codes: list[str]):
+        self.list_codes = new_codes
+
+    def setTechnique(self, technique: Tecnica):
+        self.technique = technique
+
+    def setProductsNoSave(self):
+        self.list_product = []
+        for code in self.list_codes:
+            product = Producto(
+                codigoProducto=code,
+                id_tecnica=self.technique
+            )
+            self.list_product.append(product)
+
+    def saveProducts(self):
+        if not self.list_product:
+            return controller_error("no se han establecido los productos para guardar")
+
+        try:
+            for product in self.list_product:
+                product.save()
+            return self.list_product
+        except DatabaseError as error:
+            return controller_error("error al guardar los productos")

tecnicas/controllers/sesion_controller.py

@@ -0,0 +1,41 @@
+from django.db import DatabaseError
+from ..models import Tecnica, Presentador, SesionSensorial
+from ..utils import controller_error
+
+
+class SesionController():
+    def __init__(self, name_session: str, technique: Tecnica, creator: Presentador):
+        self.name_session = name_session or None
+        self.technique = technique or None
+        self.presenter = creator or None
+
+    def setData(self, name_session: str, technique: Tecnica, creator: Presentador):
+        self.name_session = name_session
+        self.technique = technique
+        self.presenter = creator
+
+    def setSession(self):
+        if not self.presenter:
+            return controller_error("se requiere presentador para crear sesion")
+        elif not self.technique:
+            return controller_error("se requiere tecnica para crear sesion")
+
+        self.sensorial_session = SesionSensorial(
+            tecnica=self.technique,
+            creadoPor=self.presenter,
+        )
+
+        if self.name_session != "":
+            self.sensorial_session.nombre_sesion = self.name_session
+
+        return self.sensorial_session
+
+    def saveSession(self):
+        if not self.sensorial_session:
+            return controller_error("no se ha definido la sesion a guardar")
+
+        try:
+            self.sensorial_session.save()
+            return self.sensorial_session
+        except DatabaseError as error:
+            return controller_error("Error al crear la session sensorial")

tecnicas/controllers/tecnica_controller.py

@@ -1,16 +1,40 @@
-from ..models import TipoTecnica, CategoriaTecnica, Tecnica
+from ..models import TipoTecnica, CategoriaTecnica, Tecnica, EstiloPalabra
+from django.db import DatabaseError
+from ..utils import controller_error
 
 
 class TecnicaController():
     def setTechnique(self, **kwargs):
-        self.technique = Tecnica.objects.create(
+        self.technique = Tecnica(
             tipo_tecnica=kwargs["tipo_tecnica"],
+            id_estilo=kwargs["estilo_palabras"],
             repeticiones_max=kwargs["numero_repeticiones"] or 0,
             limite_catadores=kwargs["numero_catadores"],
             instrucciones=kwargs["instrucciones"],
-            id_estilo=kwargs["estilo_palabras"],
         )
 
+    def setTechniqueFromBasicData(self, basic):
+        self.technique = Tecnica(
+            tipo_tecnica=TipoTecnica.objects.get(id=basic["id_tecnica"]),
+            id_estilo=EstiloPalabra.objects.get(id=basic["estilo_palabras"]),
+            repeticiones_max=basic["numero_repeticiones"] or 0,
+            limite_catadores=basic["numero_catadores"],
+            instrucciones=basic["instrucciones"] or "Espere instrucciones del Presentador",
+        )
+
+    def getDataTechnique(self):
+        return self.technique.toDict()
+
+    def saveTechnique(self):
+        try:
+            self.technique.save()
+            return self.technique
+        except DatabaseError:
+            return controller_error("No se ha podido guardar la tecnica")
+
+    def deleteTechnique(self):
+        self.technique.delete()
+
     @staticmethod
     def getTypesTechnique():
         showTecnicas = {}

tecnicas/forms/__init__.py

@@ -2,4 +2,5 @@ from .sesion_basic_form import SesionBasicForm
 from .sesion_tags_form import SesionTagsForm
 from .etiqueta_form import EtiquetaForm
 from .codes_form import CodesForm
-from .catador_form import CatadorForm
+from .catador_form import CatadorForm
+from .word_form import WordForm

tecnicas/forms/word_form.py

@@ -0,0 +1,36 @@
+from django import forms
+
+from ..models import Palabra
+
+
+class WordForm(forms.ModelForm):
+    nombre_palabra = forms.CharField(
+        min_length=3,
+        max_length=255,
+        error_messages={
+            "required": "parametros requeridos",
+            "unique": "palabra repetida",  # Ojo: 'unique' lo maneja ModelForm, no aquí
+            "min_length": "la palabra es muy corta",
+            "max_length": "la palabra es muy larga",
+        },
+        widget=forms.TextInput(attrs={
+            "class": "bg-gray-300 border-b text-center text-black pb-1 rounded",
+            "placeholder": "Ingrese palabra",
+            "oninput": "this.value = this.value.toLowerCase()",
+        })
+    )
+
+    class Meta:
+        model = Palabra
+        fields = ["nombre_palabra"]
+
+    def clean_nombre_palabra(self):
+        nombre_palabra = self.cleaned_data.get('nombre_palabra')
+
+        if nombre_palabra:
+            nombre_palabra = nombre_palabra.lower().strip()
+
+        if Palabra.objects.filter(nombre_palabra=nombre_palabra).exists():
+            raise forms.ValidationError("palabra repetida")
+
+        return nombre_palabra

tecnicas/migrations/0012_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.2.1 on 2025-09-08 22:21
+
+import django.db.models.deletion
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0011_alter_escala_tecnica_and_more'),
+    ]
+
+    operations = [
+        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),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='tecnica',
+            field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='sesion_tecnica', to='tecnicas.tecnica'),
+        ),
+    ]

tecnicas/migrations/0013_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.1 on 2025-09-09 21:05
+
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0012_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        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),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='fechaCreacion',
+            field=models.DateTimeField(auto_created=True),
+        ),
+    ]

tecnicas/migrations/0014_alter_sesionsensorial_codigo_sesion_and_more.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.2.1 on 2025-09-10 00:04
+
+import django.utils.timezone
+import shortuuid.main
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tecnicas', '0013_alter_sesionsensorial_codigo_sesion_and_more'),
+    ]
+
+    operations = [
+        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),
+        ),
+        migrations.AlterField(
+            model_name='sesionsensorial',
+            name='fechaCreacion',
+            field=models.DateTimeField(default=django.utils.timezone.now),
+        ),
+    ]

tecnicas/models/escala.py

@@ -9,4 +9,4 @@ class Escala(models.Model):
     tecnica = models.OneToOneField(Tecnica, on_delete=models.CASCADE, related_name="escala_tecnica")
 
     def __str__(self):
-        return self.longitud
+        return self.id_tipo_escala.nombre_escala

tecnicas/models/etiquetas_escala.py

@@ -1,11 +1,16 @@
 from django.db import models
-
 from .escala import Escala
 from .etiqueta import Etiqueta
 
+
 class EtiquetasEscala(models.Model):
-    id_escala = models.ForeignKey(Escala, on_delete=models.CASCADE, related_name="escalas_etiqutas_escala")
+    id_escala = models.ForeignKey(
+        Escala, on_delete=models.CASCADE, related_name="escalas_etiqutas_escala")
+
+    id_etiqueta = models.ForeignKey(
+        Etiqueta, on_delete=models.CASCADE, related_name="etiqueta_etiquetas_escala")
+
+    posicion = models.IntegerField()
 
-    id_etiqueta = models.ForeignKey(Etiqueta, on_delete=models.CASCADE, related_name="etiqueta_etiquetas_escala")
-    
-    posicion = models.IntegerField()
+    def __str__(self):
+        return f"Escala {self.id_escala.id}, {self.id_etiqueta.valor_etiqueta}, posicion {self.posicion}"

tecnicas/models/orden.py

@@ -8,7 +8,13 @@ class Orden(models.Model):
     id_tecnica = models.ForeignKey(Tecnica, on_delete=models.CASCADE, related_name="orden_tecnica")
     id_catador = models.ForeignKey(Catador, on_delete=models.CASCADE, related_name="orden_catador", null=True)
 
+    def __str__(self):
+        return f"Orden ID: {self.id}"
+
 class Posicion(models.Model):
     id_producto = models.ForeignKey(Producto, on_delete=models.CASCADE, related_name="posicion_producto")
     id_orden = models.ForeignKey(Orden, on_delete=models.CASCADE, related_name="posicion_orden")
-    posicion = models.IntegerField()
+    posicion = models.IntegerField()
+
+    def __str__(self):
+        return f"Posicion ID: {self.id}"

tecnicas/models/sesion_sensorial.py

@@ -1,16 +1,20 @@
-import shortuuid
 from django.db import models
-
+from django.utils import timezone
 from .presentador import Presentador
 from .tecnica import Tecnica
+import shortuuid
+
 
 class SesionSensorial(models.Model):
-    codigo_sesion =  models.CharField(primary_key=True, default=shortuuid.uuid, editable=False, max_length=22)
+    codigo_sesion = models.CharField(
+        primary_key=True, default=shortuuid.uuid, editable=False, max_length=22)
     nombre_sesion = models.CharField(max_length=255, null=True)
-    fechaCreacion = models.DateTimeField("date published")
+    fechaCreacion = models.DateTimeField(default=timezone.now)
     activo = models.BooleanField(default=False)
-    creadoPor = models.ForeignKey(Presentador, on_delete=models.CASCADE, related_name="presentador_sesion")
-    tecnica = models.ForeignKey(Tecnica, on_delete=models.CASCADE, related_name="sesion_tecnica")
+    creadoPor = models.ForeignKey(
+        Presentador, on_delete=models.CASCADE, related_name="presentador_sesion")
+    tecnica = models.OneToOneField(
+        Tecnica, on_delete=models.CASCADE, related_name="sesion_tecnica")
 
     def __str__(self):
-        return self.codigo_sesion
+        return self.codigo_sesion

tecnicas/models/tecnica.py

@@ -3,13 +3,26 @@ from django.db import models
 from .estilo_palabra import EstiloPalabra
 from .tipo_tecnica import TipoTecnica
 
+
 class Tecnica(models.Model):
-    tipo_tecnica = models.ForeignKey(TipoTecnica, on_delete=models.CASCADE, related_name="tecnica_tipo_tecnica")
+    tipo_tecnica = models.ForeignKey(
+        TipoTecnica, on_delete=models.CASCADE, related_name="tecnica_tipo_tecnica")
     repeticiones_max = models.IntegerField(default=0)
     repecion = models.IntegerField(default=0)
     limite_catadores = models.IntegerField()
     instrucciones = models.CharField(max_length=255)
-    id_estilo = models.ForeignKey(EstiloPalabra, on_delete=models.CASCADE, related_name="estilo_tecnica")
+    id_estilo = models.ForeignKey(
+        EstiloPalabra, on_delete=models.CASCADE, related_name="estilo_tecnica")
 
     def __str__(self):
-        return self.tipo_tecnica
+        return f"{self.id} : {self.tipo_tecnica.nombre_tecnica} : {self.id_estilo.nombre_estilo}"
+
+    def toDict(self):
+        return {
+            "tipo_tecnica": self.tipo_tecnica,
+            "repeticiones_max": self.repeticiones_max,
+            "repecion": self.repecion,
+            "limite_catadores": self.limite_catadores,
+            "instrucciones": self.instrucciones,
+            "id_estilo": self.id_estilo,
+        }

tecnicas/static/js/create-session.js

@@ -0,0 +1,141 @@
+const formSubmit = document.querySelector(".ct-cretae-session-form");
+
+document.addEventListener("DOMContentLoaded", () => {
+  cretaeSession();
+});
+
+async function cretaeSession() {
+  const dataForm = new FormData(formSubmit);
+  const url = `creando-sesion`;
+
+  try {
+    const respone = await fetch(url, {
+      method: "POST",
+      headers: {
+        "X-CSRFToken": dataForm.get("csrfmiddlewaretoken"),
+      },
+      body: dataForm,
+    });
+
+    const jsonResponse = await respone.json();
+
+    if (jsonResponse.error) {
+      renderElementsResponse({ error: jsonResponse.error });
+      return;
+    }
+
+    const data = jsonResponse["data"];
+    renderElementsResponse({
+      sessionId: data["codigo_sesion"],
+      nameSession: data["nombre_sesion"],
+    });
+  } catch (error) {
+    renderElementsResponse({ error: jsonResponse.error });
+  }
+}
+
+function renderElementsResponse({
+  sessionId = "No id",
+  error = false,
+  nameSession = "",
+}) {
+  const container = document.querySelector(".ct-message-create");
+  const loadElement = document.querySelector(".ct-load-create");
+
+  const message = document.createElement("p");
+  message.classList.add("text-2xl", "text-white", "text-center", "font-bold");
+
+  const nameSessionP = document.createElement("p");
+  nameSessionP.classList.add(
+    "text-lg",
+    "text-white",
+    "text-center",
+    "font-bold"
+  );
+
+  const idSession = document.createElement("p");
+  idSession.classList.add("text-lg", "text-white", "text-center", "font-bold");
+  const pHelp = document.createElement("p");
+
+  // ******************************** //
+  // Mostrar el error que ha ocurrido //
+  // ******************************** //
+  if (error) {
+    message.textContent = "No se ha podido completar la creacion de la sesion";
+    idSession.textContent = `Error: ${error}`;
+  } else {
+    message.textContent = "La session se ha creado";
+    idSession.innerHTML = `El ID de la seesion es:<br><strong class="border-b border-white">${sessionId}</strong>`;
+    nameSessionP.textContent = `Nombre de sesion: ${nameSession}`;
+
+    pHelp.classList.add("text-lg", "text-white", "text-center");
+    pHelp.textContent =
+      "Puedes pasar este ID a los catadores para que ingresen a la sesion";
+  }
+
+  const divBtns = document.createElement("div");
+  divBtns.classList.add(
+    "flex",
+    "flex-wrap",
+    "justify-center",
+    "items-center",
+    "gap-5"
+  );
+
+  const stylesBtns = [
+    "uppercase",
+    "text-lg",
+    "tracking-wider",
+    "font-medium",
+    "p-2",
+    "px-4",
+    "border-b-2",
+    "active:border-b-0",
+    "active:border-t-2",
+    "transition-all",
+    "rounded-xl",
+    "w-fit",
+  ];
+
+  const aIndex = document.createElement("a");
+  aIndex.href = "/cata";
+  aIndex.textContent = "Volver al inicio";
+
+  aIndex.classList.add(
+    ...stylesBtns,
+    "active:border-blue-500",
+    "border-blue-800",
+    "bg-blue-500",
+    "text-white"
+  );
+
+  const aMonitor = document.createElement("a");
+  aMonitor.href = "/cata";
+  aMonitor.textContent = "Monitorear la sesion";
+
+  aMonitor.classList.add(
+    ...stylesBtns,
+    "active:border-yellow-500",
+    "border-yellow-800",
+    "bg-yellow-500",
+    "text-black"
+  );
+
+  divBtns.appendChild(aIndex);
+  if (!error) {
+    divBtns.appendChild(aMonitor);
+  }
+
+  loadElement.classList.add("hidden");
+  container.classList.remove("hidden");
+
+  container.innerHTML = "";
+
+  container.appendChild(message);
+  if (nameSession != "") {
+    container.appendChild(nameSessionP);
+  }
+  container.appendChild(idSession);
+  container.appendChild(pHelp);
+  container.appendChild(divBtns);
+}

tecnicas/static/js/panel-codes.js

@@ -9,10 +9,20 @@ let sortData;
 initIU();
 
 function submitData(e) {
+  const submitData = [];
+
+  sortData.forEach((order) => {
+    const simplePosition = {};
+    order.forEach((dataPosition) => {
+      simplePosition[dataPosition["code"]] = dataPosition["position"];
+    });
+    submitData.push(simplePosition);
+  });
+  
   const codesInput = document.createElement("input");
   codesInput.type = "hidden";
   codesInput.name = "sort_codes";
-  codesInput.value = JSON.stringify(sortData);
+  codesInput.value = JSON.stringify(submitData);
   this.appendChild(codesInput);
 }
 
@@ -110,6 +120,9 @@ function shuffle(arr) {
   return arrSuffle;
 }
 
+/**
+ * Render the UI with permutations
+ */
 function addIUPermutations() {
   const container = document.getElementsByClassName("ct-orden-list")[0];
   const itemsChild = [];

tecnicas/static/js/panel-words.js

@@ -1,68 +1,272 @@
-const selectWordsContainer = document.querySelector(".ct-words-select");
-const tagsWords = document.querySelectorAll(".word");
-let numberWords = 3;
-const allWords = [];
-
-for (let i = 0; i < tagsWords.length; i++) {
-  let atributes = tagsWords.item(i).children;
-  allWords.push({
-    id: atributes[1].innerText,
-    name: atributes[0].innerText,
-    selected: false,
+// **************************************
+// Logic for get to words and render UI
+// **************************************
+const imgList = document.querySelector(".ct-img-list");
+
+const listWordsSelect = [];
+const wordsSelectContainer = document.querySelector(".ct-palabras-usadas");
+
+const errorp = document.getElementsByClassName("ct-error-words")[0];
+const foundWordsContainer = document.getElementsByClassName(
+  "ct-palabras-encontradas"
+)[0];
+
+const formSearch = document.getElementsByClassName("ct-serach-words")[0];
+formSearch.addEventListener("submit", getWordsByName);
+
+checInitWords();
+
+async function getWordsByName(e) {
+  e.preventDefault();
+  errorp.classList.add("hidden");
+  foundWordsContainer.innerHTML = "";
+
+  let words = [];
+
+  const dataForm = new FormData(this);
+  const params = new URLSearchParams({
+    palabra: dataForm.get("search").trim(),
   });
-}
 
-for (let i = 1; i <= numberWords; i++) {
-  const select = creadSelect(i);
-  selectWordsContainer.appendChild(select);
+  const url = `api/palabras?${params}`;
+
+  try {
+    const respone = await fetch(url, {
+      method: "GET",
+      headers: {
+        "X-CSRFToken": dataForm.get("csrfmiddlewaretoken"),
+      },
+    });
+
+    const jsonResponse = await respone.json();
+
+    if (jsonResponse.error) {
+      errorp.textContent = `Error: ${jsonResponse.error}`;
+      errorp.classList.remove("hidden");
+      return;
+    }
+
+    words = jsonResponse["data"];
+  } catch (error) {
+    console.log("Error:", error);
+  }
+
+  showWordsFound(words);
 }
 
-function creadSelect(index) {
-  const label = document.createElement("label");
-  label.attributes["form"] = `palabra-${index}`;
-  label.classList.add(
-    "font-medium",
-    "py-2",
-    "px-3",
-    "bg-gray-200",
-    "capitalize",
+function createWordElement({ word, add = true, callback = null }) {
+  const li = document.createElement("li");
+  li.classList.add(
+    add ? "bg-gray-600" : "bg-gray-400",
+    add ? "text-white" : "text-black",
     "rounded",
-    "text-center"
+    "font-bold",
+    "text-lg",
+    "px-4",
+    "py-3",
+    "flex",
+    "flex-wrap",
+    "flex-row",
+    "flex-1",
+    "min-w-fit",
+    "justify-center",
+    "items-center",
+    "gap-3"
   );
 
-  const p = document.createElement("p");
-  p.innerText = `Palabra ${index}`;
+  const pName = document.createElement("p");
+  pName.textContent = word.nombre_palabra;
+  pName.id = word.id;
 
-  const select = document.createElement("select");
-  select.attributes["id"] = `palabra-${index}`;
-  select.name = `palabra-${index}`;
-  select.required = true;
-  select.classList.add(
-    "ct-select-op",
-    "p-1",
-    "rounded",
-    "bg-gray-500",
-    "[*]:capitalize",
-    "[*]:text-white"
+  let callButton;
+
+  if (callback) {
+    callButton = () => callback(word);
+  }
+
+  li.appendChild(pName);
+  li.appendChild(createButton(add, callButton));
+
+  return li;
+}
+
+function createButton(add = true, callback = null) {
+  const button = document.createElement("button");
+  button.textContent = add ? "➕" : "➖";
+  button.classList.add(
+    "px-4",
+    "border-b-2",
+    "active:border-b-0",
+    "active:border-t-2",
+    "transition-all",
+    "rounded-xl",
+    "font-black",
+    "w-fit",
+    "capitalize"
+  );
+
+  button.classList.add(
+    add ? "active:border-green-500" : "active:border-red-500",
+    add ? "border-green-800" : "border-red-800",
+    add ? "bg-green-500" : "bg-red-500"
   );
 
-  const emtpyOption = document.createElement("option");
-  emtpyOption.value = "";
-  emtpyOption.innerText = "Seleccione palabra";
-  emtpyOption.attributes["selected"] = true;
-  emtpyOption.attributes["disabled"] = true;
+  if (callback) {
+    button.addEventListener("click", callback);
+  }
+
+  return button;
+}
 
-  select.appendChild(emtpyOption);
+function swtichGridSearch(change = true) {
+  change
+    ? foundWordsContainer.classList.add("grid")
+    : foundWordsContainer.classList.remove("grid");
+}
 
-  allWords.forEach((dataWord, i) => {
-    const option = document.createElement("option");
-    option.value = dataWord.id;
-    option.innerText = dataWord.name;
-    select.appendChild(option);
+function showWordsFound(words) {
+  foundWordsContainer.innerHTML = "";
+  swtichGridSearch();
+
+  words.forEach((word) => {
+    const elemtnLi = createWordElement({ word: word, callback: addWordToUse });
+    foundWordsContainer.appendChild(elemtnLi);
   });
+}
+
+function addWordToUse(word) {
+  if (listWordsSelect.find((w) => w.id === word.id)) {
+    spanNotificationRed(
+      `La palabra "${word.nombre_palabra}" ya fue seleccionada`
+    );
+
+    return;
+  }
+
+  listWordsSelect.push(word);
+  updatelistWordsSelect();
+}
+
+function spanNotificationRed(errorMessage) {
+  const noti = document.querySelector(".ct-notification-red");
+  noti.textContent = errorMessage;
+  noti.classList.remove("hidden");
+
+  setTimeout(() => {
+    noti.classList.add("hidden");
+  }, 2500);
+}
+
+function spanNotificationGreen(message) {
+  const noti = document.querySelector(".ct-notification-green");
+  noti.textContent = message;
+  noti.classList.remove("hidden");
+
+  setTimeout(() => {
+    noti.classList.add("hidden");
+  }, 3000);
+}
+
+function removeWordToUse(word) {
+  const index = listWordsSelect.findIndex((w) => w.id === word.id);
+  if (index > -1) {
+    listWordsSelect.splice(index, 1);
+    updatelistWordsSelect();
+  }
+}
+
+function updatelistWordsSelect() {
+  wordsSelectContainer.innerHTML = "";
+
+  listWordsSelect.forEach((word) => {
+    const elemtnLi = createWordElement({
+      word: word,
+      add: false,
+      callback: removeWordToUse,
+    });
+    wordsSelectContainer.appendChild(elemtnLi);
+  });
+
+  if (listWordsSelect.length === 0) {
+    wordsSelectContainer.appendChild(imgList);
+  }
+}
+
+// **************************************
+// Logic for post new Word
+// **************************************
+const formNewWord = document.querySelector(".ct-form-new-word");
+formNewWord.addEventListener("submit", postNewWord);
+
+async function postNewWord(e) {
+  e.preventDefault();
+
+  const dataForm = new FormData(this);
+  const url = "api/palabras";
+
+  dataForm.set(
+    "nombre_palabra",
+    dataForm.get("nombre_palabra").trim().toLowerCase()
+  );
+
+  try {
+    const respone = await fetch(url, {
+      method: "POST",
+      headers: {
+        "X-CSRFToken": dataForm.get("csrfmiddlewaretoken"),
+      },
+      body: dataForm,
+    });
+
+    const jsonResponse = await respone.json();
+
+    if (jsonResponse.error) {
+      spanNotificationRed(`Error: ${jsonResponse.error}`);
+      return;
+    }
+
+    const word = jsonResponse["data"];
+    addWordToUse(word);
+    spanNotificationGreen(jsonResponse["message"]);
+
+    formNewWord.reset();
+  } catch (error) {
+    spanNotificationRed(`Error: ${error}`);
+  }
+}
+
+// **************************************
+// Create Session
+// **************************************
+const formCreateSession = document.querySelector(".ct-creat-session");
+formCreateSession.addEventListener("submit", submitSelectWords);
+
+async function submitSelectWords(e) {
+  e.preventDefault();
+
+  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);
+  this.appendChild(wordsInput);
+
+  this.submit();
+}
+
+function checInitWords() {
+  const wordsSends = document.getElementsByClassName("ct-word-received");
 
-  label.appendChild(p);
-  label.appendChild(select);
+  for (let i = 0; i < wordsSends.length; i++) {
+    const id = parseInt(wordsSends.item(i).id);
+    const name = wordsSends.item(i).textContent;
+    const newWord = { id: id, nombre_palabra: name };
+    listWordsSelect.push(newWord);
+  }
 
-  return label;
+  updatelistWordsSelect();
 }

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-codes.html

@@ -17,7 +17,7 @@
                 <p class="text-center font-bold tracking-wide text-xl bg-gray-500 text-white px-3 py-3 pb-4 rounded">
                     Puede dejar los campos como están para usar los códigos predefinidos.
                 </p>
-                {% for field in form_worlds %}
+                {% for field in form_codes %}
                 <label for="{{ field.id_for_label }}"
                     class="text-lg flex flex-col items-center px-2 font-medium tracking-wide">
                     <p class="tracking-normal capitalize text-base font-bold">{{ field.label }}</p>

tecnicas/templates/tecnicas/create_sesion/configuracion-panel-words.html

@@ -7,14 +7,6 @@
 <article class="w-full flex flex-col justify-center items-center bg-gray-600 my-10">
     <section class="w-fit h-fit relative">
         <article class="flex flex-col gap-4 bg-gray-400 md:p-10 p-5 rounded-2xl lg:w-4xl w-full">
-            <ul class="all-words hidden">
-                {% for word in words %}
-                <li class="word">
-                    <p>{{ word.nombre_palabra }}</p>
-                    <p>{{ word.id }}</p>
-                </li>
-                {% endfor %}
-            </ul>
             <h1 class="text-center font-bold text-4xl">Panel de configuración</h1>
             <hr>
             {% if error %}
@@ -23,35 +15,94 @@
             </p>
             {% endif %}
 
-            <article class="flex flex-col md:flex-row gap-5 justify-between items-center">
-                <section class="flex-1/3 bg-gray-600 text-white p-4 rounded-lg text-center">
-                    <p>Soy una palabra</p>
-                </section>
-                <section class="flex-2/3 w-full">
-                    <form action="" method="get" class="h-full w-full">
+            <article class="flex flex-col md:flex-row gap-5 justify-between">
+                <section class="flex-3/5 flex flex-col gap-4">
+                    <form action="" method="get" class="ct-serach-words">
                         {% csrf_token %}
-                        <label for="search">
-                            <input type="text" name="search" id="search" placeholder="Buscar palabra"
-                                class="p-2 px-4 bg-gray-200 rounded-lg w-full text-lg">
-                        </label>
+                        <p class="text-lg font-bold text-center mb-2 bg-gray-600 p-2 rounded text-white">
+                            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-gray-200 rounded-lg w-full text-lg font-medium">
+                            </label>
+                            <button type="submit"
+                                class="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 capitalize">
+                                Buscar
+                            </button>
+                        </section>
                     </form>
+                    <p
+                        class="ct-error-words hidden capitalize text-white bg-red-600 text-center text-2xl p-1.5 rounded">
+                        error</p>
+                    <ul class="ct-palabras-encontradas gap-2 grid-cols-2 max-h-96 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-gray-600 text-white p-4 rounded-lg text-center min-h-96">
+                    <p class="text-xl font-bold pb-3">Lista de palabras</p>
+                    <hr class="mb-3 text-white">
+                    <ul class="ct-palabras-usadas flex flex-col gap-3">
+                        {% 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>
 
+            <article class="ct-new-tags bg-gray-600 p-5 flex justify-center items-center rounded-2xl">
+                <form method="post" action="" class="ct-form-new-word p-3">
+                    {% csrf_token %}
+                    <p class="mb-4 text-2xl min-md:text-xl font-bold text-center text-white">
+                        ¿No encuentras una palabra?
+                    </p>
+                    <label for="{{ form_word.nombre_palabra.id_for_label }}"
+                        class="font-medium text-xl text-white flex flex-wrap justify-center items-center gap-3 mb-4">
+                        <p class="px-4">Nueva palabra:</p>
+                        {{ form_word.nombre_palabra }}
+                    </label>
+                    <p
+                        class="ct-error-word mb-4 font-bold bg-red-500 text-white text-md capitalize text-center rounded hidden">
+                        error
+                    </p>
+                    <hr class="text-white">
+                    <article class="flex justify-center gap-8 mt-4 text-white font-medium tracking-wide">
+                        <button
+                            class="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-600 text-white w-fit"
+                            type="submit">
+                            Crear y agregar a la lista
+                        </button>
+                    </article>
+                </form>
+            </article>
 
-            <form action="" method="post" class="flex flex-col gap-5">
-                {% csrf_token %}
-                <article class="p-4 flex flex-col items-center gap-2 rounded">
-                    <h2 class="text-2xl mb-2 text-center font-bold">Estilo Atributos<br>Seleccion de palabras</h2>
-                    <div class="ct-words-select flex flex-row flex-wrap justify-center items-center gap-5 text-lg">
-                    </div>
-                    <hr>
-                    <button type="button"
-                        class="ct-gen-or 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 capitalize">
-                        Agregar otra palabra
+            <article>
+                <form action="" method="post" class="ct-creat-session flex justify-center mt-4">
+                    {% csrf_token %}
+                    <button type="submit" name="start"
+                        class="text-lg tracking-wider font-medium p-2 px-4 border-b-2 active:border-b-0 active:border-t-2 active:border-yellow-500 border-yellow-800  transition-all rounded-xl bg-yellow-500 text-white w-fit capitalize">
+                        Crear sesión
                     </button>
-                </article>
-            </form>
+                </form>
+            </article>
+
+            <article
+                class="ct-notification-red absolute max-md:fixed bottom-0 mb-4 left-1/2 -translate-x-1/2 bg-red-600 text-white p-2 px-4 rounded-lg text-center font-medium hidden uppercase">
+            </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>
     </section>
 </article>

tecnicas/templates/tecnicas/create_sesion/creando_sesion.html

@@ -0,0 +1,31 @@
+{% extends 'tecnicas/layouts/base.html' %}
+{% load static %}
+
+{% block title %}Creando sesion{% endblock %}
+
+{% block content %}
+<article class="w-full flex flex-col justify-center items-center bg-gray-600 my-10">
+    <article class="flex flex-col gap-4 bg-gray-400 md:p-10 p-5 rounded-2xl lg:w-4xl w-full">
+        <h1 class="text-center font-bold text-4xl">Creando Sesion</h1>
+        <hr>
+        <section class="ct-load-create flex flex-col gap-4 bg-gray-600 p-6 rounded-xl">
+            <p class="text-lg text-white text-center font-bold">
+                Estamos creando la sesion, por favor espere...
+            </p>
+            <hr class="text-white">
+            <div class="w-full h-4 bg-green-500 rounded-full overflow-hidden">
+                <div class="h-full bg-red-400 animate-pulse" style="width: 100%"></div>
+            </div>
+        </section>
+        <section class="ct-message-create flex flex-col gap-4 bg-gray-600 p-6 rounded-xl hidden"></section>
+        <form action="" method="post" class="hidden ct-cretae-session-form">
+            {% csrf_token %}
+            <input type="hidden" name="action" value="create_session">
+        </form>
+    </article>
+</article>
+{% endblock %}
+
+{% block extra_js %}
+<script src="{% static 'js/create-session.js' %}"></script>
+{% endblock %}

tecnicas/test/test_controller_words.py

@@ -0,0 +1,27 @@
+from django.test import TestCase
+from django.urls import reverse
+from ..controllers import PalabrasController
+from ..models import Palabra
+
+
+class TestsApiWords(TestCase):
+    ids: list[int]
+    words_saved: list[Palabra]
+
+    def setUp(self):
+        self.named_words = ["rasposo", "afilado", "poroso"]
+        words_to_save = [Palabra(nombre_palabra=name)
+                         for name in self.named_words]
+        self.words_saved = Palabra.objects.bulk_create(words_to_save)
+        self.ids = [word.id for word in self.words_saved]
+
+    def test_get_words_by_list_ids(self):
+        instance = PalabrasController(ids=self.ids)
+        new_words = Palabra.objects.filter(id__in=self.ids)
+        names = [word.nombre_palabra for word in new_words]
+        self.assertEqual(set(self.named_words), set(names))
+
+    def test_get_words_by_list_ids_fail(self):
+        instance = PalabrasController(ids=[23, 12, 76])
+        response = instance.setWords()
+        self.assertIn("error", response)

tecnicas/test/test_words.py

@@ -7,9 +7,9 @@ class TestsApiWords(TestCase):
     def setUp(self):
         Palabra.objects.create(nombre_palabra="salado")
 
-    def test_get_word_fail(self):
+    def test_get_words_fail(self):
         word_name = "dulce"
-        expected_error = "palabra no encontrada"
+        expected_error = "no existen palabras"
 
         response = self.client.get(
             reverse("cata_system:api_palabras")+f"?palabra={word_name}"
@@ -21,7 +21,7 @@ class TestsApiWords(TestCase):
         self.assertIn("error", res_json)
         self.assertEqual(res_json["error"], expected_error)
 
-    def test_get_word_no_parameter(self):
+    def test_get_words_no_parameter(self):
         expected_error = "parametros no encontrados"
 
         response = self.client.get(reverse("cata_system:api_palabras"))
@@ -32,11 +32,12 @@ class TestsApiWords(TestCase):
         self.assertIn("error", res_json)
         self.assertEqual(res_json["error"], expected_error)
 
-    def test_get_word_success(self):
-        word_name = "salado"
-        expected_message = "dato localizado"
+    def test_get_words_success(self):
+        word_name = "sal"
+        expected_message = "datos localizados"
 
-        expected_data = Palabra.objects.get(nombre_palabra=word_name).to_dict()
+        expected_data = Palabra.objects.filter(
+            nombre_palabra__contains=word_name)
 
         response = self.client.get(
             reverse("cata_system:api_palabras")+f"?palabra={word_name}"
@@ -50,19 +51,17 @@ class TestsApiWords(TestCase):
         self.assertEqual(res_json["message"], expected_message)
 
         data = res_json["data"]
-        self.assertEqual(data["id"], expected_data["id"])
-        self.assertEqual(data["name"], expected_data["nombre_palabra"])
+        self.assertEqual(len(data), len(expected_data))
 
     def test_post_word_success(self):
         word_name = "dulce"
         expected_message = "palabra creada"
 
-        response = self.client.post(
-            reverse("cata_system:api_palabras"),
-            data={"nombre_palabra": word_name}
-        )
+        data = {
+            "nombre_palabra": word_name
+        }
 
-        self.assertEqual(response.status_code, 200)
+        response = self.client.post(reverse("cata_system:api_palabras"), data)
 
         res_json = response.json()
 
@@ -74,27 +73,60 @@ class TestsApiWords(TestCase):
         self.assertIn("nombre_palabra", data)
         self.assertEqual(data["nombre_palabra"], word_name)
 
+    def test_post_word_lowercase(self):
+        word_name = "AMargo"
+        expected_message = "palabra creada"
+
+        data = {
+            "nombre_palabra": word_name
+        }
+
+        response = self.client.post(reverse("cata_system:api_palabras"), data)
+
+        res_json = response.json()
+
+        self.assertIn("message", res_json)
+        self.assertEqual(res_json["message"], expected_message)
+
+        data = res_json["data"]
+        self.assertIn("id", data)
+        self.assertIn("nombre_palabra", data)
+        self.assertEqual(data["nombre_palabra"], word_name.lower())
+
     def test_post_word_fail(self):
         word_name = "salado"
         expected_error = "palabra repetida"
 
+        data = {"nombre_palabra": word_name}
+
         response = self.client.post(
             reverse("cata_system:api_palabras"),
-            data={"nombre_palabra": word_name}
+            data
         )
 
-        self.assertEqual(response.status_code, 200)
-
         res_json = response.json()
         self.assertIn("error", res_json)
         self.assertEqual(res_json["error"], expected_error)
-    
+
     def test_post_word_no_parameter(self):
-        expected_error = "parametros no encontrados"
+        expected_error = "parametros requeridos"
 
         response = self.client.post(reverse("cata_system:api_palabras"))
 
-        self.assertEqual(response.status_code, 200)
+        res_json = response.json()
+        self.assertIn("error", res_json)
+        self.assertEqual(res_json["error"], expected_error)
+
+    def test_post_word_too_short(self):
+        word_name = "ab"
+        expected_error = "la palabra es muy corta"
+
+        data = {"nombre_palabra": word_name}
+
+        response = self.client.post(
+            reverse("cata_system:api_palabras"),
+            data
+        )
 
         res_json = response.json()
         self.assertIn("error", res_json)

tecnicas/urls.py

@@ -15,6 +15,7 @@ urlpatterns = [
     path("panel-configuracion-tags", views.configurationPanelTags, name="panel_configuracion_tags"),
     path("panel-configuracion-codes", views.configurationPanelCodes, name="panel_configuracion_codes"),
     path("panel-configuracion-words", views.configurationPanelWords, name="panel_configuracion_words"),
+    path("creando-sesion", views.createSession, name="creando_sesion"),
     path("nueva-etiqueta", views.newTag, name="nueva_etiqueta"),
     path("crear-catador", views.testerCreate, name="crear_catador"),
     path("buscar-catador", views.testerSearch, name="buscar_catador"),

tecnicas/utils/__init__.py

@@ -1,3 +1,3 @@
 from .code_generate import generarCodigo
 from .code_generate import generarCodigos
-from .general_error import general_error
+from .personal_errors import general_error, controller_error

tecnicas/utils/{general_error.py → personal_errors.py}

@@ -1,5 +1,11 @@
 from django.http import JsonResponse
 
+
 def general_error(message="informacion incorrecta"):
-    respuesta = { "error" : message }
-    return JsonResponse(respuesta)
+    result = {"error": message}
+    return JsonResponse(result)
+
+
+def controller_error(message="ha ocurrido un error inesperado"):
+    result = {"error": message}
+    return result

tecnicas/views/__init__.py

@@ -11,4 +11,5 @@ from .configuration_panel_words import configurationPanelWords
 from .api_tag import newTag
 from .tester_create import testerCreate
 from .tester_search import testerSearch
-from .api_words import words
+from .api_words import words
+from .create_session import createSession

tecnicas/views/api_words.py

@@ -2,39 +2,49 @@ from django.http import HttpRequest, JsonResponse
 from django.db import IntegrityError
 from ..models import Palabra
 from ..utils import general_error
+from ..forms.word_form import WordForm
 
 
 def words(req: HttpRequest):
     if req.method == "GET":
         try:
             word_name = req.GET["palabra"]
-            fund_word = Palabra.objects.get(nombre_palabra=word_name)
+
+            if word_name == "":
+                fund_words = Palabra.objects.all()[:10]
+            else:
+                fund_words = Palabra.objects.filter(
+                    nombre_palabra__startswith=word_name)
         except KeyError:
             return general_error("parametros no encontrados")
-        except Palabra.DoesNotExist:
-            return general_error("palabra no encontrada")
 
-        response = {
-            "message": "dato localizado",
-            "data": {
-                "id": fund_word.id,
-                "name": fund_word.nombre_palabra,
-            }
-        }
+        if not fund_words:
+            return general_error("no existen palabras")
 
-        return JsonResponse(response)
-    elif req.method == "POST":
-        try:
-            word_name = req.POST["nombre_palabra"]
-            new_word = Palabra.objects.create(nombre_palabra=word_name)
-        except KeyError:
-            return general_error("parametros no encontrados")
-        except IntegrityError:
-            return general_error("palabra repetida")
+        response_words = [word.to_dict() for word in fund_words]
 
         response = {
-            "message": "palabra creada",
-            "data": new_word.to_dict()
+            "message": "datos localizados",
+            "data": response_words
         }
 
         return JsonResponse(response)
+    elif req.method == "POST":
+        form = WordForm(req.POST)
+
+        if form.is_valid():
+            form.cleaned_data["nombre_palabra"] = form.cleaned_data["nombre_palabra"].lower(
+            )
+            new_word = form.save()
+            send_word = {
+                "nombre_palabra": new_word.nombre_palabra,
+                "id": new_word.id
+            }
+            response = {
+                "message": "palabra creada",
+                "data": send_word
+            }
+            return JsonResponse(response)
+        else:
+            errors = form.errors.get("nombre_palabra")
+            return general_error(errors[0])

tecnicas/views/configuration_panel_basic.py

@@ -4,7 +4,19 @@ from django.urls import reverse
 from ..forms import SesionBasicForm
 from ..models import TipoTecnica
 
+
 def configurationPanelBasic(req: HttpRequest):
+    keys_forms = [
+        "form_basic",
+        "form_tags",
+        "form_codes",
+        "form_words"
+    ]
+
+    for key in keys_forms:
+        if key in req.session:
+            del req.session[key]
+
     if req.method == "POST":
         try:
             form = SesionBasicForm(req.POST)
@@ -23,7 +35,7 @@ def configurationPanelBasic(req: HttpRequest):
         except KeyError:
             return redirect(reverse("cata_system:seleccion_tecnica") + "?error=error en datos de configuracion")
 
-        return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", { "form_sesion": form, "error": "Ha ocurrido un error al continuar al siguiente paso." })
+        return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form, "error": "Ha ocurrido un error al continuar al siguiente paso."})
     elif req.method == "GET":
         try:
             id_tecnica = req.GET["id_tecnica"]
@@ -35,6 +47,6 @@ def configurationPanelBasic(req: HttpRequest):
 
         if tecnica:
             form_sesion = SesionBasicForm(id_tecnica_new=id_tecnica)
-            return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", { "form_sesion": form_sesion })
+            return render(req, "tecnicas/create_sesion/configuracion-panel-basic.html", {"form_sesion": form_sesion})
         else:
-            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=la_tecnica_no_existe")
+            return redirect(reverse("cata_system:seleccion_tecnica") + "?error=la_tecnica_no_existe")

tecnicas/views/configuration_panel_codes.py

@@ -7,12 +7,12 @@ import json
 
 
 def configurationPanelCodes(req: HttpRequest):
-    data_basic = req.session["form_basic"]
-    data_tags = req.session["form_tags"]
+    if not req.session.get("form_basic") or not req.session.get("form_tags"):
+        req.session.flush()
+        return redirect(reverse("cata_system:seleccion_tecnica") +
+                        "?error=datos del formulario requerido no encontrados")
 
-    if not data_basic or not data_tags:
-        redirect(reverse("cata_system:seleccion_tecnica") +
-                 "?error=datos del formulario requerido no encontrados")
+    data_basic = req.session["form_basic"]
 
     num_products = data_basic["numero_productos"]
     num_tester = data_basic["numero_catadores"]
@@ -20,40 +20,40 @@ def configurationPanelCodes(req: HttpRequest):
     if req.method == "GET":
         codes_products = generarCodigos(num_products)
 
-        form_worlds = CodesForm(codes=codes_products)
+        form_codes = CodesForm(codes=codes_products)
 
-        context_worlds_form = {
-            "form_worlds": form_worlds,
+        context_codes_form = {
+            "form_codes": form_codes,
             "num_tester": num_tester
         }
 
-        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_worlds_form)
+        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)
     elif req.method == "POST":
         sorts_code = json.loads(req.POST.get("sort_codes"))
         codes = []
-        context_worlds_form = {}
+        context_codes_form = {}
 
         for name, value in req.POST.items():
             if name.__contains__("producto_"):
                 codes.append(value)
 
-        form_worlds = CodesForm(req.POST, codes=codes)
+        form_codes = CodesForm(req.POST, codes=codes)
 
-        context_worlds_form = {
-            "form_worlds": form_worlds,
+        context_codes_form = {
+            "form_codes": form_codes,
             "num_tester": num_tester,
         }
 
-        if form_worlds.is_valid():
+        if form_codes.is_valid():
             codes_sort = {"product_codes": []}
 
-            for name, value in form_worlds.cleaned_data.items():
+            for name, value in form_codes.cleaned_data.items():
                 codes_sort["product_codes"].append({name: value})
 
             codes_sort["sort_codes"] = sorts_code
             req.session["form_codes"] = codes_sort
             return redirect(reverse("cata_system:panel_configuracion_words"))
         else:
-            context_worlds_form["error"] = "error en los datos recibidos"
+            context_codes_form["error"] = "error en los datos recibidos"
 
-        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_worlds_form)
+        return render(req, "tecnicas/create_sesion/configuracion-panel-codes.html", context_codes_form)

tecnicas/views/configuration_panel_tags.py

@@ -4,31 +4,34 @@ from django.urls import reverse
 from ..forms import SesionTagsForm, EtiquetaForm
 from ..models import TipoEscala
 
+
 def configurationPanelTags(req: HttpRequest):
     basic_data = req.session.get("form_basic", {})
 
     if not basic_data:
         return redirect(reverse('cata_system:panel_configuracion_basic'))
-    
+
     type_scale = TipoEscala.objects.get(pk=basic_data["tipo_escala"])
     tamano_escala = basic_data["tamano_escala"]
     form_new_etiqueta = EtiquetaForm()
 
     if req.method == "GET":
-        form_etiqutas = SesionTagsForm(longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
+        form_etiqutas = SesionTagsForm(
+            longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
 
         context_tags = {
-            "form_tags":form_etiqutas,
+            "form_tags": form_etiqutas,
             "form_new_tag": form_new_etiqueta
         }
 
         return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
     elif req.method == "POST":
         values = {}
-        form = SesionTagsForm(req.POST, longitud=tamano_escala, tipo_escala=type_scale.nombre_escala)
+        form = SesionTagsForm(req.POST, longitud=tamano_escala,
+                              tipo_escala=type_scale.nombre_escala)
 
         context_tags = {
-            "form_tags":form,
+            "form_tags": form,
             "form_new_tag": form_new_etiqueta
         }
 
@@ -40,4 +43,4 @@ def configurationPanelTags(req: HttpRequest):
             return redirect(reverse("cata_system:panel_configuracion_codes"))
         else:
             context_tags["error"] = "ha ocurrido un error"
-            return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)
+            return render(req, "tecnicas/create_sesion/configuracion-panel-tags.html", context_tags)

tecnicas/views/configuration_panel_words.py

@@ -1,11 +1,44 @@
 from django.http import HttpRequest
-from django.shortcuts import render
+from django.shortcuts import render, redirect
+from django.urls import reverse
 from ..models.palabra import Palabra
+from ..forms import WordForm
+
+import json
+
 
 def configurationPanelWords(req: HttpRequest):
+    if not req.session.get("form_basic") or not req.session.get("form_tags") or not req.session.get("form_codes"):
+        req.session.flush()
+        return redirect(reverse("cata_system:seleccion_tecnica") +
+                        "?error=datos del formulario requerido no encontrados")
+
+    form = WordForm()
+    context = {
+        "form_word": form
+    }
+
     if req.method == "GET":
-        allWords =  Palabra.objects.all()
-        context = {
-            "words": allWords
-        }
-        return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+        return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+    elif req.method == "POST":
+        if not req.POST.get("words"):
+            return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+        words = json.loads(req.POST.get("words"))
+        context["words"] = words
+
+        ids_words = [word["id"] for word in words]
+
+        if len(ids_words) != len(set(ids_words)):
+            context["error"] = "existen palabras duplicadas"
+            return render(req, "tecnicas/create_sesion/configuracion-panel-words.html", 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(req, "tecnicas/create_sesion/configuracion-panel-words.html", context)
+
+        req.session["form_words"] = ids_words
+        return redirect(reverse("cata_system:creando_sesion"))

tecnicas/views/create_session.py

@@ -0,0 +1,163 @@
+from django.http import HttpRequest, JsonResponse
+from django.shortcuts import render, redirect
+from django.urls import reverse
+from ..utils import general_error
+from ..controllers import TecnicaController, EscalaController, ProductosController, OrdenesController, EstiloPalabrasController, PalabrasController, SesionController
+from ..models import Presentador
+
+
+def createSession(req: HttpRequest):
+    if req.method == "GET":
+        return render(req, 'tecnicas/create_sesion/creando_sesion.html')
+    if req.method == "POST":
+        if req.POST.get('action') == 'create_session':
+            if not req.session.get("form_basic") or not req.session.get("form_tags") or not req.session.get("form_codes") or not req.session.get("form_words"):
+                req.session.flush()
+                return general_error("no se ha especificado informacion necesaria para la creacion de la sesion")
+
+            # ////////////////////////////////////////////////////// #
+            #
+            # First step: Create technique and scale with their tags #
+            #
+            # ////////////////////////////////////////////////////// #
+            data_basic = req.session["form_basic"]
+            controllerTechnique = TecnicaController()
+            controllerTechnique.setTechniqueFromBasicData(basic=data_basic)
+
+            technique = controllerTechnique.saveTechnique()
+            if not technique:
+                return general_error("error al guardar la tecnica")
+
+            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):
+                controllerTechnique.deleteTechnique()
+                return general_error(scale["error"])
+
+            dict_tags = req.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 = req.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):
+                controllerTechnique.deleteTechnique()
+                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):
+                controllerTechnique.deleteTechnique()
+                return general_error(saved_orders["error"])
+
+            seded_positions = controllerOrdes.setPositions()
+            if isinstance(seded_positions, dict):
+                controllerTechnique.deleteTechnique()
+                return general_error(seded_positions["error"])
+
+            saved_postions = controllerOrdes.savePositions()
+            if isinstance(saved_postions, dict):
+                controllerTechnique.deleteTechnique()
+                return general_error(saved_prodcuts["error"])
+
+            # /////////////////////////////////////////////////////// #
+            #
+            # Third step: Create relations technique with Words Style #
+            #
+            # /////////////////////////////////////////////////////// #
+            ids_words = req.session["form_words"]
+            words_controller = PalabrasController(ids=ids_words)
+
+            words_to_use = words_controller.setWords()
+            if isinstance(words_to_use, dict):
+                controllerTechnique.deleteTechnique()
+                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):
+                controllerTechnique.deleteTechnique()
+                return general_error(instace_style["error"])
+
+            words_using = style_controller.relatedWords()
+            if isinstance(words_using, dict):
+                controllerTechnique.deleteTechnique()
+                return general_error("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=Presentador.objects.get(nombre_usuario="aguBido")
+            )
+
+            setting_session = session_controller.setSession()
+            if isinstance(setting_session, dict):
+                controllerTechnique.deleteTechnique()
+                return general_error(setting_session["error"])
+
+            saved_session = session_controller.saveSession()
+            if isinstance(saved_session, dict):
+                return general_error(saved_session["error"])
+
+            context = {
+                "message": "sesion creada",
+                "data": {
+                    "codigo_sesion": saved_session.codigo_sesion,
+                    "nombre_sesion": saved_session.nombre_sesion
+                }
+            }
+
+            keys_forms = [
+                "form_basic",
+                "form_tags",
+                "form_codes",
+                "form_words"
+            ]
+
+            for key in keys_forms:
+                if key in req.session:
+                    del req.session[key]
+                    
+            return JsonResponse(context)
+        return general_error("ha orcurrido un error inesperado")