Creación (CRUD) — Desarrollo con el framework Django

• ¿Qué pasa cuando envías el formulario?
• ¿Qué hace Django detrás de escena?
• ¿Cómo creamos una nueva entidad?
  • 1. El Formulario
• La ruta (URL)
• El Handler (vista)
• La plantilla HTML
• ¿Cómo se muestran los errores?

Cuando quieres crear algo nuevo en una aplicación (como un artículo, un usuario o un producto), necesitas dos rutas:

• Una ruta para mostrar el formulario vacío donde vas a escribir los datos.
• Otra ruta que reciba esos datos cuando envíes el formulario.

También es clave entender cómo trabajan juntas estas rutas y cómo manejar los errores cuando las cosas no salen perfectas. Vamos paso a paso. Cuando hablamos de crear algo, normalmente pasamos por tres momentos:

• Mostrar el formulario vacío para llenar los datos.

• Mostrar el mismo formulario pero resaltando los errores, si el usuario se equivoca al llenarlo.

• Redirigir al usuario a otra página si todo salió bien (por ejemplo, a la lista de artículos o a la página de edición).

¿Qué pasa cuando envías el formulario?

Aquí es donde se pone interesante: cuando el usuario da clic en Enviar, los datos del formulario llegan a un "receptor" —el handler, que en Django normalmente es una vista (View).

Ese handler:

• Valida la información (por ejemplo, revisa que no hayas dejado campos vacíos).
• Si todo está bien, guarda los datos y lleva al usuario a otra página.
• Si hay errores, le muestra otra vez el formulario, pero ahora señalando qué debe corregir.

Desde el punto de vista del usuario, simplemente ve la misma página con los datos que había escrito y unos mensajes de error encima.

El usuario puede corregir los errores y enviar de nuevo el formulario. ¡Y puede repetir esto las veces que necesite hasta que todo quede perfecto!

¿Qué hace Django detrás de escena?

Si el usuario cometió un error, Django no lo saca del formulario: simplemente recarga la página con los datos anteriores y los errores.

Para esto, Django guarda temporalmente la información en una sesión (algo así como una memoria interna del navegador).

También usa un sistema llamado ModelForm para llenar automáticamente los campos de nuevo.

¿Cómo creamos una nueva entidad?

Necesitamos cuatro piezas:

• Una forma (formulario).
• Una ruta (URL).
• Un handler (vista).
• Una plantilla (HTML).

Vamos a ver cada parte con ejemplos:

1. El Formulario

Primero, creamos el formulario que se basa en un modelo existente (por ejemplo, un modelo llamado Article).

# forms.py
from django.forms import ModelForm
from .models import Article  # Asegúrate de importar el modelo

class ArticleForm(ModelForm):
    class Meta:
        model = Article
        fields = ['name', 'body']  # Campos que queremos mostrar en el formulario

🎯 Así no tenemos que crear cada campo manualmente: Django los genera a partir de nuestro modelo.

La ruta (URL)

Ahora tenemos que decirle a Django qué ruta debe usar para acceder a la página de creación.

# urls.py
from django.urls import path
from codica_django_blog.article.views import IndexView, ArticleFormCreateView

urlpatterns = [
    # otras rutas
    path("create/", ArticleFormCreateView.as_view(), name="articles_create"),
]

Esta ruta va a responder al URL /create/ y usará la vista ArticleFormCreateView.

El Handler (vista)

Vamos a crear la clase que se encargará de mostrar el formulario cuando el usuario entra a la página y también de procesar los datos cuando el usuario lo envía.

from django.views import View
from django.shortcuts import render, redirect
from .forms import ArticleForm

class ArticleFormCreateView(View):
    def get(self, request, *args, **kwargs):
        form = ArticleForm()
        return render(request, "articles/create.html", {"form": form})

    def post(self, request, *args, **kwargs):
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('articles')  # Redirige a la lista de artículos
        return render(request, 'articles/create.html', {'form': form})

Explicación:

• Si el usuario simplemente entra a la página (GET), le mostramos un formulario vacío.
• Si el usuario manda datos (POST), validamos y guardamos, o devolvemos los errores.

La plantilla HTML

Esta será la página que verá el usuario en el navegador. Aquí mostramos el formulario y también los mensajes de error si los hay.

<form action="{% url 'articles_create' %}" method="post">
    {% csrf_token %}
    <table border="1">
        {{ form }}
    </table>
    <input type="submit" value="Crear">
</form>

¿Cómo se muestran los errores?

Cuando se presiona el botón "Crear artículo":

1. Django recibe los datos vía POST
2. Se crea un objeto del formulario con esos datos: form = ArticleForm(request.POST)
3. Se valida con form.is_valid()

✅ Si todo está bien, se guarda el nuevo artículo: form.save()

❌ Si hay errores, se vuelve a mostrar la misma página con los mismos datos y los errores explicados

{% if form.errors %}
<div>
    <ul>
    {% for error in form.errors %}
        <li><strong>{{ error|escape }}</strong></li>
    {% endfor %}
    </ul>
</div>
{% endif %}

Así, si alguien deja un campo vacío, verá un mensaje claro como: "Este campo es obligatorio"

Trabajo independiente

Materiales adicionales

1. Validador
2. Mensajes flash