Formularios en Django

En Django, los formularios permiten recolectar y validar datos ingresados por el usuario en las páginas web. El proceso de crear un formulario comienza con la creación de una clase que hereda de django.forms.Form. En la clase, se deben definir los campos del formulario, cada uno representado por un objeto de campo de Django que define el tipo de campo y las características como los requerimientos de validación. Por ejemplo, si se quiere un campo de texto para el nombre del usuario, se puede definir así:

from django import forms

class UserForm(forms.Form):
    nombre = forms.CharField(max_length=50)

Los tipos de campo disponibles son CharField, IntegerField, FloatField, BooleanField, DateField, DateTimeField, EmailField, FileField, entre otros. Una vez que se ha definido la clase UserForm, se puede usar en una vista de Django para procesar los datos enviados por el usuario en un formulario HTML. Para mostrar el formulario, se puede utilizar:

def user_view(request):
    form = UserForm()
    return render(request, 'user.html', {'form': form})

En este ejemplo, se ha creado un objeto form de la clase UserForm y se ha pasado como contexto a la plantilla HTML user.html. Para procesar los datos del formulario enviado por el usuario, se debe comprobar si se ha enviado una solicitud POST:

def user_view(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            # Acciones a realizar con los datos ingresados en el formulario
            pass
    else:
        form = UserForm()
    return render(request, 'user.html', {'form': form})

En este ejemplo, se ha verificado si la solicitud es de tipo POST. Si es así, se ha creado un objeto form a partir de los datos recibidos en la solicitud. Si el formulario es válido, la acción correspondiente puede realizarse, por ejemplo, guardar los datos en la base de datos. Si el formulario es inválido, se puede informar al usuario y mostrar nuevamente el formulario para que intente corregir los errores de entrada. En resumen, Django utiliza formularios para recopilar y validar datos del usuario. Se deben definir clases que heredan de django.forms.Form. Los campos del formulario se definen como objetos de campo de Django, y se pueden validar los datos ingresados antes de procesarlos.

Un ejemplo práctico de uso de formularios en Django

Un ejemplo práctico de uso de formularios en Django sería el de un formulario de registro de usuarios en una aplicación web. Para ello, debemos crear un formulario en Django que permita a los usuarios ingresar su información, como su nombre de usuario, correo electrónico y contraseña. En el archivo forms.py crearemos el formulario:

from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User

class CreateUserForm(UserCreationForm):
    email = forms.EmailField()

    class Meta:
        model = User
        fields = ['username', 'email', 'password1', 'password2']

En este formulario estamos importando las librerías necesarias, y creando la clase "CreateUserForm". Al heredar de la clase "UserCreationForm", el formulario ya cuenta con campos por defecto, como "username" y "password". Adicionalmente, agregamos un campo para el correo electrónico. Ahora, debemos incluir el formulario en nuestra vista. Para ello, en el archivo views.py, creamos la función "register":

from django.shortcuts import render, redirect
from django.contrib import messages
from .forms import CreateUserForm

def register(request):
    if request.method == 'POST':
        form = CreateUserForm(request.POST)
        if form.is_valid():
            form.save()
            username = form.cleaned_data.get('username')
            messages.success(request, '¡Cuenta creada para ' + username + '!')
            return redirect('login')
    else:
        form = CreateUserForm()
    return render(request, 'register.html', {'form':form})

En esta función, verificamos si la petición es de tipo POST, lo que indica que se envió el formulario. Si el formulario es válido, se registrará al usuario y se redireccionará a la página de login. En caso contrario, se mostrará el formulario con los errores correspondientes. Por último, para mostrar el formulario, creamos una nueva página en template llamada "register.html". En ella incluimos el siguiente código:

{% extends 'base.html' %}
{% block content %}
    

{% endblock %}

En este código, estamos extendiendo el archivo base.html, y mostrando el formulario con el método POST. Usamos la variable "form" que definimos en la vista para mostrar los campos del formulario. También incluimos un botón para enviar el formulario. Con esto, hemos creado un formulario de registro de usuarios en Django.

Un ejemplo práctico de cómo usar formularios en Django

Un ejemplo práctico de cómo usar formularios en Django sería el de crear un formulario para que los usuarios puedan enviar sus comentarios sobre un producto en nuestra tienda en línea. Para ello, lo primero que hacemos es crear un modelo de Django que represente nuestro formulario:

from django.db import models

class Comentario(models.Model):
    nombre = models.CharField(max_length=50)
    correo_electronico = models.EmailField(max_length=100)
    comentario = models.TextField(max_length=1000)

Luego, creamos un formulario a partir de nuestro modelo con la clase ModelForm de Django:

from django import forms
from .models import Comentario

class ComentarioForm(forms.ModelForm):
    class Meta:
        model = Comentario
        fields = ['nombre', 'correo_electronico', 'comentario']
        widgets = {
            'nombre': forms.TextInput(attrs={'class': 'form-control'}),
            'correo_electronico': forms.EmailInput(attrs={'class': 'form-control'}),
            'comentario': forms.Textarea(attrs={'class': 'form-control'}),
        }

En el formulario, especificamos los campos que queremos mostrar (nombre, correo_electronico y comentario en este caso) y los widgets que queremos utilizar para cada uno de ellos (en este caso, un TextInput, un EmailInput y un Textarea respectivamente). Luego, en nuestro archivo de vistas (views.py), creamos una función que maneje el envío del formulario:

from django.shortcuts import render
from .forms import ComentarioForm

def comentario(request):
    if request.method == 'POST':
        form = ComentarioForm(request.POST)
        if form.is_valid():
            form.save()
            return render(request, 'gracias.html')
    else:
        form = ComentarioForm()
    return render(request, 'comentario.html', {'form': form})

En esta función, primero verificamos si el método de la solicitud es POST. Si es así, creamos una instancia del formulario con los datos enviados por el usuario (request.POST) y verificamos si el formulario es válido (is_valid()). Si el formulario es válido, lo guardamos en la base de datos (form.save()) y redirigimos al usuario a una página de agradecimiento (gracias.html). Si el método de la solicitud es GET, simplemente creamos una instancia del formulario vacío y la mostramos en una plantilla (comentario.html) junto con la página HTML. Por último, creamos nuestras plantillas HTML:

comentario.html:

gracias.html:

¡Gracias por tu comentario!

Con esto, hemos creado un formulario completo en Django con validación de entradas, protección contra ataques CSRF y almacenamiento automático en la base de datos.