# Formulários do Django
Por último, queremos uma forma legal de adicionar e editar as postagens do nosso blog. A `ferramenta de administração` do Django é legal, mas é um pouco difícil de personalizar e de deixar mais bonita. Com `formulários`, temos poder absoluto sobre nossa interface - podemos fazer quase tudo que pudermos imaginar!
Uma coisa legal do Django é que podemos tanto criar um formulário do zero, como criar um `ModelForm` que salva o resultado do formulário em um determinado modelo.
É exatamente isso que queremos fazer: criar um formulário para o nosso modelo `Post`.
Assim como todas as partes importantes do Django, forms têm seu próprio arquivo: `forms.py`.
Precisamos criar um arquivo com este nome dentro da pasta `blog`.
```
blog
└── forms.py
```
Agora vamos abri-lo no editor de código e digitar o seguinte:
```python
from django import forms
from .models import Post
class PostForm(forms.ModelForm):
class Meta:
model = Post
fields = ('title', 'text',)
```
Primeiro, precisamos importar o módulo de formulários do Django (*from django import forms*) e, obviamente, o nosso modelo *Post* (*from .models import Post*).
`PostForm`, como você já deve suspeitar, é o nome do nosso formulário. Precisamos dizer ao Django que esse form é um `ModelForm` (pro Django fazer algumas mágicas para nós) – `forms.ModelForm` é o responsável por essa parte.
Em seguida, temos a `class Meta` em que dizemos ao Django qual modelo deverá ser usado para criar este formulário (`model = Post`).
Por fim, podemos dizer quais campos devem entrar no nosso formulário. Neste cenário, queremos que apenas o `title` e o `text` sejam expostos -- `author` deve ser a pessoa que está logada no sistema (nesse caso, você!) e `created_date` deve ser configurado automaticamente quando criamos um post (no código), correto?
E é isso! Tudo o que precisamos fazer agora é usar o formulário em uma *view* e mostrá-lo em um template.
Novamente, criaremos um link para a página, uma URL, uma view e um template.
## Link para a página com o formulário
É hora de abrir *blog/templates/blog/base.html*. Nós iremos adicionar um link em *div* nomeado *page-header*:
```html
" class="top-menu">
```
Note que queremos chamar nossa nova view de `post_new`. A classe `"glyphicon glyphicon-plus"` é fornecida pelo tema (bootstrap) que estamos usando, e nos mostrará um sinal de mais.
Depois de adicionar essa linha, o seu HTML vai ficar assim:
```html
Django Girls blog
">
```
Depois de salvar e recarregar a página ** você verá um erro familiar `NoReverseMatch` certo? É isso!
## URL
Vamos abrir o arquivo *blog/urls.py* e escrever:
```python
path('post/new/', views.post_new, name='post_new'),
```
O código final deve se parecer com isso:
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.post_list, name='post_list'),
path('post//', views.post_detail, name='post_detail'),
path('post/new/', views.post_new, name='post_new'),
]
```
Após recarregar a página, veremos um `AttributeError` por que não temos a view `post_new` implementada. Vamos adicioná-la agora.
## View post\_new
Hora de abrir o arquivo *blog/views.py* e adicionar o seguinte às linhas *from*:
```python
from .forms import PostForm
```
E então a nossa *view*:
```python
def post_new(request):
form = PostForm()
return render(request, 'blog/post_edit.html', {'form': form})
```
Para criar um novo formulario `Post`, devemos chamar `PostForm()` e passá-lo para o template. Voltaremos a esta *view* depois, mas por enquanto, vamos criar um template para o formulário.
## Template
Precisamos criar um arquivo *post\_edit.html* na pasta *blog/templates/blog*. Para fazer o formulário funcionar, precisamos de várias coisas:
* Temos que exibir o formulário. Podemos fazer isso com (por exemplo) `{{ form.as_p }}`.
* A linha acima precisa estar dentro de uma tag HTML form: ``.
* Precisamos de um botão `Salvar`. Fazemos isso com um botão HTML: ``.
* E finalmente, depois de abrir a tag `