Formulários no Django: Manipulação, Validação e Renderização

Formulários no Django são uma parte essencial de qualquer aplicação web que precise interagir com o usuário. No Django, o sistema de formulários é um dos recursos mais poderosos e flexíveis, facilitando o trabalho com dados de entrada, sua validação e posterior manipulação.

Se você já precisou lidar com formulários HTML manualmente, sabe o quão trabalhoso pode ser garantir que todos os dados sejam capturados e validados corretamente.

É aí que entra o Django, automatizando grande parte desse processo e permitindo que você foque no desenvolvimento da lógica da sua aplicação.

Esta postagem explora a manipulação de formulários no Django, incluindo a criação, validação e renderização, com exemplos práticos para ilustrar cada etapa.

Criando um Formulário no Django

Django fornece uma classe chamada forms.Form, que facilita a criação e manipulação de formulários. Além disso, o Django oferece o forms.ModelForm, que automaticamente gera um formulário baseado em um modelo (Model) definido no banco de dados. Comecemos pela criação de um formulário simples usando forms.Form.

Exemplo básico de criação de formulário

from django import forms

class ContatoForm(forms.Form):
    nome = forms.CharField(label='Nome', max_length=100)
    email = forms.EmailField(label='E-mail')
    mensagem = forms.CharField(widget=forms.Textarea, label='Mensagem')

No exemplo acima, definimos um formulário de contato com três campos:

• nome: Um campo de texto simples (usando CharField) com um limite de 100 caracteres.
• email: Um campo de e-mail que automaticamente valida se o dado inserido é um endereço de e-mail válido.
• mensagem: Um campo de texto maior, onde usamos forms.Textarea para renderizar um <textarea> HTML, adequado para entradas de várias linhas.

A criação de um formulário envolve basicamente definir as propriedades de cada campo e seus tipos de validação básica (como o tipo de dado que ele deve aceitar).

O que são Widgets?

Os widgets no Django controlam como os campos de formulário são renderizados no HTML. Cada tipo de campo tem um widget padrão associado, mas você pode personalizar isso facilmente. Por exemplo, podemos modificar o campo de mensagem para usar um widget de campo de texto menor, ou até adicionar classes CSS personalizadas para estilizar o formulário:

class ContatoForm(forms.Form):
    nome = forms.CharField(label='Nome', max_length=100, widget=forms.TextInput(attrs={'class': 'form-control'}))
    email = forms.EmailField(label='E-mail', widget=forms.EmailInput(attrs={'class': 'form-control'}))
    mensagem = forms.CharField(widget=forms.Textarea(attrs={'rows': 5, 'class': 'form-control'}), label='Mensagem')

Aqui usamos o argumento attrs para adicionar classes CSS personalizadas a cada campo, que seriam úteis ao integrar com frameworks como Bootstrap, por exemplo.

Em outras palavras, os widgets te da a oportunidade o que você poderá adicionar dentro dos inputs que serão renderizados no HTML.

Tipos de campos no Formulários no Django

Django oferece uma grande variedade de campos para formulários, cada um com uma função específica. Alguns dos mais usados incluem:

• CharField: Usado para entradas de texto simples.
• EmailField: Valida se o valor inserido é um e-mail válido.
• IntegerField: Valida se o valor inserido é um número inteiro.
• DateField: Para campos de data.
• BooleanField: Um checkbox booleano.

Exemplo de um formulário com diferentes tipos de campo:

class RegistroForm(forms.Form):
    nome = forms.CharField(label='Nome', max_length=100)
    idade = forms.IntegerField(label='Idade')
    data_nascimento = forms.DateField(label='Data de Nascimento')
    aceita_termos = forms.BooleanField(label='Aceito os termos e condições')

Caso você viu a ultima postagem que fiz sobre models você perceberá que os campos de formulários do Django são parecidos em termos de “tipagem”. Exatamente, como nem sempre usaremos formulários para fazer inserção de dados para o banco de dados e melhor ter forms e models separados, embora sejam parecidos. 😉

Validação de Formulários

Django oferece validação automática de dados para os tipos de campo. No entanto, existem cenários onde você precisará implementar validações personalizadas para os seus formulários. A validação ocorre em dois níveis:

1. Validação embutida: Django já inclui regras de validação padrão para muitos tipos de campos (por exemplo, EmailField verifica se o valor inserido é um e-mail válido).
2. Validação personalizada: Você pode criar suas próprias regras de validação para campos específicos.

Validação embutida nos formulários no Django

Sempre que você utiliza um tipo de campo como EmailField, IntegerField, etc., o Django automaticamente aplica validações apropriadas ao valor recebido.

Por exemplo, se tentarmos enviar um valor inválido para o campo de e-mail no formulário de contato que criamos acima, Django nos retornará um erro de validação:

form = ContatoForm({'nome': 'João', 'email': 'emailinvalido', 'mensagem': 'Olá!'})
if form.is_valid():
    # Este bloco não será executado
    print("Formulário válido")
else:
    print(form.errors)

Aqui, como o e-mail é inválido, o Django vai gerar um erro como parte do dicionário form.errors que poderá ser exibido no template.

Validação personalizada nos formulários no Django

Além da validação embutida, você pode definir suas próprias regras de validação para campos individuais. Isso é feito através do método clean_<nome do campo>(), onde você pode especificar a lógica de validação adicional para um determinado campo.

Vamos criar um exemplo onde validamos o nome de usuário para garantir que ele tenha pelo menos 5 caracteres:

class RegistroForm(forms.Form):
    nome = forms.CharField(label='Nome', max_length=100)
    email = forms.EmailField(label='E-mail')

    def clean_nome(self): # <-- Aqui você esta adicionando validação ao campo "nome" 😉 
        nome = self.cleaned_data.get('nome')
        if len(nome) < 5:
            raise forms.ValidationError("O nome deve ter pelo menos 5 caracteres.")
        return nome

Aqui, o método clean_nome será executado automaticamente durante o processo de validação do formulário. Se o nome for menor que 5 caracteres, Django gerará um erro de validação.

Validação geral de formulário

Além da validação de campos individuais, você também pode realizar validações no nível do formulário. Isso é feito sobrescrevendo o método clean() da classe do formulário “Form”. Isso é útil quando você precisa validar dois ou mais campos em conjunto.

Exemplo de validação no nível do formulário:

class RegistroForm(forms.Form):
    senha = forms.CharField(widget=forms.PasswordInput)
    confirma_senha = forms.CharField(widget=forms.PasswordInput)

    def clean(self):
        cleaned_data = super().clean()
        senha = cleaned_data.get("senha")
        confirma_senha = cleaned_data.get("confirma_senha")

        if senha and confirma_senha and senha != confirma_senha:
            raise forms.ValidationError("As senhas não coincidem.")

Neste exemplo, garantimos que os campos senha e confirma_senha correspondam. Se não forem iguais, um erro de validação será gerado.

Renderizando Formulários no Django

Uma vez que criamos e validamos um formulário, o próximo passo é renderizá-lo em um template HTML. No Django, isso pode ser feito de forma bastante simples usando o objeto form que é passado para o template a partir da view.

Exemplo básico de renderização de formulário

No arquivo views.py, passamos uma instância do formulário para o contexto:

from django.shortcuts import render
from .forms import ContatoForm

def contato_view(request):
    form = ContatoForm()
    return render(request, 'contato.html', {'form': form})

No template contato.html, podemos renderizar o formulário de diferentes maneiras. A forma mais simples é usando {{ form.as_p }}, que renderiza cada campo como um parágrafo (<p>):

<form method="post">
    {% csrf_token %}
    {{ form.as_p }} <-- Aqui todas os campos serão adicionados. 
    <button type="submit">Enviar</button>
</form>

Você também pode renderizar manualmente cada campo do formulário, o que oferece mais controle sobre o HTML gerado:

<form method="post">
    {% csrf_token %}
    <div>
        {{ form.nome.label_tag }}
        {{ form.nome }}
        {{ form.nome.errors }}
    </div>
    <div>
        {{ form.email.label_tag }}
        {{ form.email }}
        {{ form.email.errors }}
    </div>
    <div>
        {{ form.mensagem.label_tag }}
        {{ form.mensagem }}
        {{ form.mensagem.errors }}
    </div>
    <button type="submit">Enviar</button>
</form>

Ao renderizar cada campo manualmente, você também pode exibir os erros de validação associados diretamente ao lado de cada campo, como mostrado acima com {{ form.campo.errors }}.

Fluxograma Explicando Os Passos Do Formulário No Django

Conclusão

Formulários no Django são uma ferramenta poderosa para lidar com dados de entrada de usuários, validação e renderização em HTML.

Neste post, você aprendeu como criar formulários, validar dados tanto de forma embutida quanto personalizada, e finalmente renderizar o formulário no template HTML. Dominar esse recurso do Django simplifica a coleta de dados em sua aplicação, além de garantir que os dados sejam válidos e seguros.