Resumo : neste tutorial, você aprenderá como criar um formulário Django para criar, atualizar e excluir modelos Post da aplicação de blog.
Este tutorial começa onde a criação do tutorial da página de administração do Django parou.
O administrador do Django é bom o suficiente para o administrador gerenciar o conteúdo com base nos modelos. No entanto, quando você deseja que os usuários do site gerenciem seu conteúdo, é necessário criar formulários separados para eles.
Introdução ao formulário Django
O tratamento de formulários envolve uma lógica muito complexa:
- Prepare um formulário HTML.
- Valide campos no navegador usando JavaScript ou validação HTML5 integrada.
- Receba os valores no servidor.
- Valide os campos no servidor.
- Processar valores de formulário, como salvá-los no banco de dados se o formulário for válido
- Renderize novamente o formulário com valores antigos e uma mensagem de erro se o formulário for inválido.
Os formulários Django simplificam e automatizam quase todas as etapas acima.
Observe que você pode escrever código para executar todas as etapas acima manualmente se desejar mais personalização dos formulários.
Todos os formulários no Django herdam da django.forms.Form
classe. A ModelForm
classe permite criar um formulário associado a um modelo .
Definindo um formulário
Primeiro, crie um novo arquivo forms.py
no blog
diretório da aplicação.
Segundo, defina um novo formulário chamado PostForm
que herda da ModelForm
classe:
from django.forms import ModelForm
from .models import Post
class PostForm(ModelForm):
class Meta:
model = Post
fields = ['title','content', 'author', 'author']
Linguagem de código: Python ( python )
Como funciona.
- Importar
ModelForm
dodjango.forms
. - Importe
Post
domodels.py
módulo. - Defina
PostForm
a classe que herda daModelForm
classe. NaPostForm
classe, defina aMeta
classe e especifique os atributosmodel
efields
.
Terceiro, defina uma rota que exiba PostForm
:
from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='posts'),
path('post/create', views.create_post, name='post-create'),
path('about/', views.about, name='about'),
]
Linguagem de código: Python ( python )
Quarto, defina create_post()
a função que exibe o formulário:
from django.shortcuts import render
from .models import Post
from .forms import PostForm
def create_post(request):
if request.method == 'GET':
context = {'form': PostForm()}
return render(request, 'blog/post_form.html', context)
def home(request):
posts = Post.objects.all()
context = {'posts': posts}
return render(request, 'blog/home.html', context)
def about(request):
return render(request, 'blog/about.html')
Linguagem de código: Python ( python )
No create_post()
, se a HTTP
solicitação for GET
, crie uma nova instância da PostForm
classe e passe-a para a render()
função.
Quinto, crie o post_form.html
modelo:
{% extends 'base.html' %}
{% block content %}
<h2>New Post</h2>
<form method="post" novalidate>
{% csrf_token %}
{{ form.as_p }}
<input type="submit" value="Save" />
</form>
{% endblock content %}
Linguagem de código: HTML, XML ( xml )
No post_form.html
, adicione a csrf_token
tag e renderize o formulário usando a form.as_p
propriedade. Ele produzirá o seguinte:
<p>
<label for="id_title">Title:</label>
<input type="text" name="title" maxlength="120" required id="id_title">
</p>
<p>
<label for="id_content">Content:</label>
<textarea name="content" cols="40" rows="10" required id="id_content"></textarea>
</p>
Linguagem de código: HTML, XML ( xml )
Se você abrir o URL http://127.0.0.1:8000/post/create
, verá o seguinte formato:
Se você clicar no botão Salvar, verá a mensagem de erro:
Como os campos de título, conteúdo e autor do modelo Post são campos obrigatórios por padrão, o PostForm
que usa o Post
modelo também renderiza um formulário HTML que requer esses campos.
Para testar a validação do servidor, você pode desabilitar a validação do cliente adicionando a novalidate
propriedade ao formulário como este:
{% extends 'base.html' %}
{% block content %}
<h2>New Post</h2>
<form method="post" novalidate>
{% csrf_token %}
{{ form.as_p }}
<input type="submit" value="Save" />
</form>
{% endblock content %}
Linguagem de código: HTML, XML ( xml )
Para lidar com o método HTTP POST, você precisa modificar a create_post
função no views.py
aplicativo blog
:
from django.shortcuts import render, redirect
from .models import Post
from .forms import PostForm
def create_post(request):
if request.method == 'GET':
context = {'form': PostForm()}
return render(request, 'blog/post_form.html', context)
elif request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect('posts')
else:
return render(request, 'blog/post_form.html', {'form': form})
# ...
Linguagem de código: Python ( python )
Se a solicitação HTTP for POST ( request.method=='POST'
):
- Crie uma nova instância da
PostForm
classe com os dados do POST. - Verifique se o formulário é válido.
- Se o formulário for válido, salve os valores do formulário no banco de dados e redirecione o navegador da web para o
'posts'
caminho. - Caso contrário, renderize novamente o formulário com valores e erros antigos.
Se você enviar o formulário sem inserir nenhum valor, receberá as seguintes mensagens de erro:
Entretanto, quando você fornece valores para alguns campos obrigatórios, o Django renderiza o formulário com valores antigos e exibe mensagens de erro apenas para campos inválidos.
Por exemplo, o formulário a seguir exibe a mensagem de erro para o title
campo, mantendo os valores antigos dos campos content
e :author
Se você inserir valores válidos para todos os campos, o Django salva os valores no banco de dados
…e redirecione para a lista de postagens:
Baixe o código fonte do Projeto Django
Resumo
- Crie um formulário de modelo subclassificando o arquivo
ModelForm
. - Adicione a
novalidate
propriedade ao formulário para desabilitar temporariamente a validação HTML5 para testar a validação do servidor. - Use
form.is_valid()
para verificar se o formulário é válido. - Use
form.save()
para salvar valores de formulário no banco de dados. - Use
redirect()
para redirecionar para um caminho.