Como criar um aplicativo CRUD com exibições baseadas em classes do Django

Um dos principais recursos do Django é seu suporte embutido para a criação de projetos sobre as operações CRUD (Create, Read, Update, Delete). Embora as visualizações baseadas em classes do Django forneçam uma maneira rápida, fácil e flexível de criar aplicativos da Web, muitos desenvolvedores ainda usam visualizações baseadas em funções.

As exibições baseadas em classe oferecem vários benefícios em relação às exibições baseadas em função, incluindo herança, estruturação de código, reutilização de código e muito mais. Embora a implementação de exibições baseadas em classe possa parecer um pouco complexa, este guia ajudará você a compreender o conceito criando um aplicativo gerenciador de tarefas e fornecendo instruções passo a passo.

O que são visualizações baseadas em classes no Django?

No Django, as visualizações são funções Python que recebem uma solicitação da web e retornam uma resposta da web. Visualizações baseadas em classes (CBVs) são uma maneira alternativa de definir visualizações no Django usando classes Python em vez de funções.

Os CBVs têm várias vantagens, como melhor organização de código, reutilização mais fácil de código e capacidade de usar herança para criar variações de visualizações existentes. Os CBVs também fornecem métodos integrados, como o pegar() e publicar() métodos que você pode substituir para comportamentos personalizados.

O código usado neste artigo está disponível neste Repositório GitHub.

Visualizações baseadas em classes disponíveis no Django

O Django fornece alguns CBVs integrados para casos de uso populares, como exibir listas de objetos ou criar novos. Alguns desses CBVs integrados são:

1. Exibição de lista: esta visualização renderiza uma lista de objetos recuperados de um modelo. Por exemplo, uma página que lista todas as postagens disponíveis em um blog usará um Exibição de lista.
2. DetailView: esta visualização renderiza uma visualização detalhada de um único objeto recuperado de um modelo. Você pode usar um DetailView para exibir os detalhes de postagens específicas em um aplicativo de blog.
3. CreateView: esta visualização renderiza um formulário para criar um novo objeto e manipula o envio do formulário. Por exemplo, em um aplicativo gerenciador de tarefas, você usará essa visualização para criar novas tarefas.
4. DeleteView: esta exibição renderiza uma página de confirmação para excluir um objeto e trata da exclusão da página.
5. UpdateView: esta visualização renderiza um formulário para atualizar um objeto existente e manipula o envio do formulário.

O Django também oferece outras visualizações, incluindo TemplateView, RedirectView, e FormView. você pode se referir a Documentação do Django para obter informações detalhadas sobre exibições baseadas em classe.

Crie um aplicativo gerenciador de tarefas com exibições baseadas em classes do Django

Construir um aplicativo como um aplicativo gerenciador de tarefas permitirá que você entenda como implementar operações CRUD com CBVs. Um gerenciador de tarefas possui recursos que permitem aos usuários criar, atualizar, excluir e ler tarefas. Esses recursos estão alinhados com as operações CRUD. As etapas a seguir ajudarão você a criar um aplicativo gerenciador de tarefas com Django CBVs.

Configurar um projeto Django

Para criar um aplicativo gerenciador de tarefas com Django, você deve começar seguindo estas etapas:

1. Instale o Django em seu ambiente virtual Python com este comando:

   pip instalar django

2. Crie um projeto Django. O comando a seguir criará um projeto chamado project_core.

   django-admin startproject project_core .

3. Crie um aplicativo chamado gerenciador de tarefas.

   python manage.py startapp task_manager

4. Na tua settings.py adicione o nome do seu aplicativo ao INSTALLED_APPS lista.

   INSTALADO_APPS = [
   'gerenciador de tarefas',
   ]

5. Abra o urls.py arquivo no diretório do seu projeto e configure as URLs para o seu gerenciador de tarefas aplicativo:

   de django.urls importar caminho, incluir
   urlpadrões = [
    caminho('', incluir('task_manager.urls')),
   ]

Crie um modelo para seu aplicativo Gerenciador de Tarefas

No diretório do seu aplicativo (ou gerenciador de tarefas pasta), abra o seu modelos.py arquivo e crie um modelo para seu aplicativo gerenciador de tarefas. Aqui está um exemplo de modelo que você pode usar:

de django.db importar modelos
aulaTarefa(modelos. Modelo):
 título = modelos. CharField (max_length=200)
 descrição = modelos. Campo de texto()
 concluído = modelos. BooleanField (padrão =Falso)
 created_at = modelos. DateTimeField (auto_now_add=Verdadeiro)

Migre seu modelo com este comando:

python manage.py makemigrations && python manage.py migrar

Crie um formulário Django para seu aplicativo

Você deve ter um formulário para lidar Criar e Atualizar operações. No diretório do seu aplicativo, crie um arquivo chamado form.py. Aqui está um exemplo:

de django importar formulários
de .modelos importar Tarefa
aulaFormulário de Tarefa(formas. ModeloForm):
aulameta:
 modelo = Tarefa
 campos = ['título', 'descrição', 'concluído']
 widgets = {
'título': formas. TextInput (attrs={'aula': 'form-control',}),
'descrição': formas. Textarea (attrs={'aula': 'form-control',}),
'concluído': formas. CheckboxInput (attrs={'aula': 'form-check-input'}),
 }

O código acima tem uma classe chamada Formulário de Tarefa que define os campos e widgets do formulário. Ele também especifica o modelo a ser usado.

Crie visualizações do Django para cada operação CRUD

Um aplicativo CRUD básico com CBVs requer pelo menos quatro exibições para lidar com todas as operações com eficiência. As próximas etapas mostrarão como criá-los.

Importe os Módulos e Pacotes Necessários

Abre o teu views.py arquivo e faça as seguintes importações:

de django.views.generic importar ListView, DetailView, CreateView, UpdateView, DeleteView
de django.urls importar reverse_lazy
de .modelos importar Tarefa
de .formulários importar Formulário de Tarefa

O código acima importa cinco CBVs. Também importa reverse_lazy para redirecionar o usuário para um URL especificado após o envio de um formulário. Finalmente, importa o Tarefa modelo, e o Formulário de Tarefa criado anteriormente.

Criar uma exibição para listar objetos de modelo

Um aplicativo gerenciador de tarefas deve ter uma página listando todas as tarefas criadas pelo usuário. Para criar uma visão para isso, você deve usar o Exibição de lista. Aqui está um exemplo:

aulaTaskListView(Exibição de lista):
 modelo = Tarefa
 template_name = 'task_manager/task_list.html'
 context_object_name = 'tarefas'

A visão acima define três atributos que são:

1. modelo: esse atributo define qual modelo usar para essa exibição específica.
2. template_name: Este atributo diz ao Django qual modelo renderizar no navegador.
3. context_object_name: Este atributo define o nome que permite ao template acessar a lista de objetos do modelo.

A maioria dos CBVs conterá esses três atributos.

Criar uma exibição para lidar com detalhes da tarefa

Cada tarefa que um usuário cria deve ter uma página mostrando seus detalhes. O CBV ideal para lidar com isso é DetailVew. Aqui está um exemplo simples:

aulaTaskDetailView(DetailView):
 modelo = Tarefa
 template_name = 'task_manager/task_detail.html'

Criar uma visualização para criação de tarefas

Crie uma exibição para lidar com a criação ou adição de novas tarefas. Isto é o Criar parte das operações CRUD, e a visão correta para isso é a CreateView. Veja como usá-lo:

aulaTaskCreateView(CreateView):
 modelo = Tarefa
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('lista de tarefas')

O código acima apresenta dois novos atributos: form_class e url_sucesso.

O form_class O atributo informa à visualização qual classe de formulário renderizar e usar para suas operações.

O url_sucesso especifica como redirecionar o usuário após enviar o formulário. Ele usa o reverse_lazy função que leva o nome de um caminho de URL.

Criar uma exibição para tarefas de edição

Para permitir que seus usuários editem ou atualizem suas tarefas, você deve criar uma exibição semelhante a esta:

aulaTaskUpdateView(AtualizarVisualização):
 modelo = Tarefa
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('lista de tarefas')

A visão acima é semelhante à TaskCreateView criado anteriormente. A única diferença é a utilização do UpdateView.

Criar uma exibição para lidar com operações de exclusão

Para permitir que seus usuários excluam tarefas sempre que quiserem, você deve usar o DeleteView CBV. Aqui está um exemplo:

aulaTaskDeleteView(DeleteView):
 modelo = Tarefa
 template_name = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('lista de tarefas')

Configure as URLs do seu aplicativo

No diretório do seu aplicativo, crie um urls.py arquivo e configure seus padrões de URL como este:

de django.urls importar caminho
de .Visualizações importar TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpadrões = 
 caminho('', TaskListView.as_view(), nome='lista de tarefas'),
 caminho('criar/', TaskCreateView.as_view(), nome='tarefa_criar'),
 caminho('tarefas//', TaskDetailView.as_view(), nome='tarefa_detalhe'),
 caminho('tarefas//update/', TaskUpdateView.as_view(), nome='task_update'),
 caminho('tarefas//delete/', TaskDeleteView.as_view(), nome='task_delete'),
]

Os padrões de URL acima são semelhantes aos URLs criados com exibições baseadas em funções. A diferença é o as_view() função anexada ao final de cada nome de visualização.

Você pode use slugs do Django para criar URLs em vez da chave primária usada acima.

Crie modelos para suas exibições

Permitir que seus usuários executem as ações definidas nas exibições acima sugere que você forneça uma interface com a qual eles possam interagir. Nas exibições criadas anteriormente, o aplicativo gerenciador de tarefas deve ter quatro interfaces de usuário.

No diretório do aplicativo, crie quatro modelos HTML. Você também deve criar base.html arquivo. Você pode estilize seus modelos Django com Bootstrap para economizar tempo.

Modelo de Lista de Tarefas

Este modelo deve incluir o código que lista todas as tarefas no modelo. Um exemplo do esqueleto do código é este:

{% estende 'base.html' %}
{% bloquear conteúdo %}
<Centro>
<h1>Suas tarefash1>
<ahref="{% url 'task_create' %}">Adicionar tarefaa>
 {% para tarefa em tarefas %}
<div>
<div>
<h5>{{ tarefa.título }}h5>
<p>{{ task.description|truncatechars: 50 }}p>
<p>
<forte>Concluído:forte>
 {% if task.completed %}Sim{% else %}Não{% endif %}
p>
<ahref="{% url 'task_detail' task.pk %}">
 Consulte Mais informação
a>
<ahref="{% url 'task_delete' task.pk %}">
 Excluir tarefa
a>
div>
div>
 {% vazio %}
<h3>Ainda não há tarefas.h3>
<ahref="{% url 'task_create' %}">Adicionar tarefaa>
 {% endfor %}
Centro>
{% bloco final %}

Com algumas classes Bootstrap, você pode deixar sua página assim:

Modelo de detalhes da tarefa

Esta página deve mostrar os detalhes completos de cada tarefa criada. Aqui está um modelo de exemplo que você pode usar:

{% estende 'base.html' %}
{% bloquear conteúdo %}
<h1>{{ tarefa.título }}h1>
<p>{{ descrição da tarefa }}p>
<p>Concluído: {% if task.completed %}Sim{% else %}Não{% endif %}p>
<ahref="{% url 'task_update' task.pk %}">Editar tarefaa>
<ahref="{% url 'task_delete' task.pk %}">Excluir tarefaa>
{% bloco final %}

Dependendo da sua abordagem de estilo, sua página deve ficar assim:

Modelo de formulário de tarefa

Este modelo deve conter um formulário que permita ao usuário criar ou atualizar uma tarefa.

{% estende 'base.html' %}
{% bloquear conteúdo %}
<h1>Criar tarefah1>
<formamétodo="publicar">
 {% csrf_token %}
 {{ form.as_p }}
<botãotipo="enviar">Salvarbotão>
forma>
{% bloco final %}

O modelo ficará assim:

Excluir modelo de tarefa

Este modelo deve ser uma página de confirmação para evitar a exclusão acidental de tarefas.

{% estende 'base.html' %}
{% bloquear conteúdo %}
<h1>Confirmar exclusãoh1>
<p>Tem certeza de que deseja excluir "{{ object.title }}"?p>
<formamétodo="publicar">
 {% csrf_token %}
<botãotipo="enviar">Excluirbotão>
<ahref="{% url 'task_list' %}">Cancelara>
forma>
{% bloco final %}

Com algum Bootstrap, sua página deve ficar assim:

Use exibições baseadas em classes para aumentar sua produtividade

Visualizações baseadas em classe são uma ótima maneira de escrever código limpo e organizado em um curto espaço de tempo, aumentando assim sua produtividade. Você deve usá-los em seus projetos tanto quanto possível. Além disso, você pode integrar ainda mais recursos como funcionalidade de pesquisa, notificações e assim por diante para tornar seu aplicativo gerenciador de tarefas um aplicativo funcional completo.