O Django é um dos frameworks mais populares e completos para desenvolvimento web em Python. Criado para facilitar a construção de aplicações web complexas com menos código e maior eficiência, ele segue o padrão “Model-View-Template” (MVT), o que facilita a separação lógica entre os dados, a interface de usuário e o processamento de regras de negócio.
Uma das funcionalidades mais marcantes do Django é sua interface de administração que ja vem por padrão, conhecida como Django Admin.
Desde a criação de um novo projeto, o Django fornece uma interface de administração completamente funcional e altamente personalizável. O que permite gerenciar com facilidade o conteúdo da aplicação sem precisar desenvolver um painel de controle do zero.
O Django Admin tem sido um dos recursos favoritos de desenvolvedores e equipes de conteúdo, pois oferece uma maneira rápida de gerenciar modelos, usuários e permissões.
Ele é projetado para ser usado tanto por desenvolvedores quanto por administradores de conteúdo, eliminando a necessidade de interfaces administrativas complexas ou construídas do zero.
Neste post, você irá entender como configurar e usar o Django Admin para gerenciar o conteúdo da sua aplicação de maneira eficiente e profissional.
Configuração Inicial do Projeto
Antes de começar a utilizar o Django Admin, é necessário realizar algumas configurações básicas. Como a instalação do projeto e o app, para em seguida iniciarmos os proximos passos.
Criando Um Ambiente Virtual
Antes de tudo vamos iniciar a criação de um projeto django, é necessario a criação de um ambiente virtual python para isolarmos nossa aplicação.
python3 -m venv venvCriação De Um Projeto Django
Adicione os comandos a seguir em sequência:
# 1. cria o projeto
django-admin startproject meu_projeto .
# 2. cria o app
django-admin startapp postagens Conexão Do App De Postagens Com o Projeto
Agora que o projeto e o aplicativo de postagens foram criados, podemos fazer a conexão do aplicativo no projeto:
Em settings.py adicone o nome do aplicativo no seguinte lugar:
INSTALLED_APPS = [
# Outros aplicativos
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'postagens', # <---------------------- Aqui
]Criando Um Super Usuario
Depois de conectar o aplicationvo no projeto, usando o settings.py, é hora de acessar a interface de administração, criando um super-usuário. No qual é um usuário com permissões completas sobre o sistema:
python manage.py createsuperuserSiga as instruções fornecidas no terminal para definir o nome de usuário, e-mail e senha. Uma vez concluído, o seu superusuário estará criado e pronto para acessar o site de administrador do django.
Acessando a Interface De Administração (django admin)
Após isso, já podemos iniciar o servidor de desenvolvimento para garantir que tudo está funcionando corretamente:
python manage.py runserverCom o servidor rodando, acesse a interface de administração navegando até a URL padrão:
http://127.0.0.1:8000/admin/Você verá uma tela de login, onde poderá inserir as credenciais do superusuário que acabou de criar.
Ao entrar, você será levado à página inicial da interface administrativa do Django, onde você poderá visualizar modelos registrados, gerênciar usuários e realizar outras tarefas administrativas.
Registrando Modelos No Django Admin
Porém como visto na imagem acima, podemos perceber que temos apenas os modelos padrões do proprio Django.
Com isso, Agora que você já tem a interface do Django Admin funcionando, é hora de adicionar seus modelos para que eles possam ser gerenciados através dessa interface.
O Que São Modelos No Django?
No Django, os modelos representam as tabelas do banco de dados. Cada classe de modelo que você define em seu código Python é mapeada para uma tabela no banco de dados. Esses modelos contêm campos que representam colunas na tabela, como nome, e-mail, data de criação, entre outros.
Registrando Modelos No Django Admin
Por padrão, o Django Admin não exibe todos os modelos automaticamente. Você precisa registrar os modelos que deseja gerenciar na interface administrativa. Para isso, vá até o arquivo admin.py no seu aplicativo (caso não exista, crie o arquivo). Suponha que você tenha um modelo de Post de blog, como este:
# postagens/models.py
from django.db import models
class Post(models.Model):
titulo = models.CharField(max_length=200)
conteudo = models.TextField()
publicado_em = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.tituloPara registrar este modelo no Django Admin, edite o arquivo admin.py e adicione o seguinte código:
# postagens/admin.py
from django.contrib import admin
from .models import Post # <--------- Não se esqueça do import
admin.site.register(Post) # <----- Registro do model no site adminApós isso, ao voltar à interface administrativa e atualizar a página, você verá o modelo Post disponível para gerenciamento.
Customização Básica Do Django Admin
É possível personalizar como os dados aparecem na interface administrativa. No Django Admin, você pode modificar como os campos do modelo são exibidos na lista de objetos ou no formulário de edição.
Adicionando alguns dados (Posts) vamos dar uma olhada de como as postagens aparecem por padrão:
1 – Criação de postagem
2 – Depois da criação das postagens, desta form que ficará a listagem dos mesmos (padrão):
Lembrando que os dados estão listados assim por causa do metodo __str__ que adicionamos la no model 😉
Agora vamos adicionar uma nova classe chamada PostAdmin para modificar a maneira que listamos as postagens no site admin do django:
# postagens/admin.py
from django.contrib import admin
from .model import Post
class PostAdmin(admin.ModelAdmin):
list_display = ('titulo', 'publicado_em')
search_fields = ('titulo',)
admin.site.register(Post, PostAdmin)Aqui, list_display define os campos que serão exibidos na lista de itens, e search_fields permite a criação de uma barra de pesquisa para filtrar os resultados pelo campo título.
Assim que você adicionar e salvar essas mudanças, recarregue a pagina para ver as mudanças no admin site:
Customizando a Interface De Edição De Postagens no Django Admin
A verdadeira força do Django Admin está na sua extensibilidade. Com a classe ModelAdmin, você pode customizar praticamente tudo na interface administrativa para se adequar às suas necessidades.
Organizando Campos No Formulário
A interface de edição padrão do Django Admin exibe todos os campos de um modelo em um layout vertical simples. No entanto, você pode organizá-los de maneira mais estruturada. Usando o atributo fieldsets, é possível agrupar campos e adicionar títulos:
# postagens/admin.py
from django.contrib import admin
from .models import Post
# Register your models here.
class PostAdmin(admin.ModelAdmin):
fieldsets = ( # <------------------- Novo campo
('Informações Básicas', {
'fields': ('titulo',)
}),
('Conteúdo', {
'fields': ('conteudo',)
}),
)
list_display = ('titulo', 'publicado_em')
search_fields = ('titulo',)
admin.site.register(Post, PostAdmin)Antes de adicionar esses valores no seu codigo, entre nos detalhes de uma postagem e veja como os campos estao por padrão:
Agora, adcione o codigo acima com o novo campo e observe as mudanças:
Como voce pode ver, cada campo teve a adição de um cabeçalho explicando seu proposito.
Criando Ações Customizadas
Além de gerenciar os dados exibidos, você também pode definir ações customizadas que podem ser aplicadas em lote. Por exemplo, para criar uma ação que marca vários posts como despublicados:
Adicionando Um Novo Campo No Model Post
Nesse caso, na model de postagens eu irei adicionar um novo campo chamado publicado que pode ser verdadeiro ou falso (BoooleanField(default=True)):
# postagens/models.py
from django.db import models
class Post(models.Model):
titulo = models.CharField(max_length=200)
conteudo = models.TextField()
publicado_em = models.DateTimeField(auto_now_add=True)
publicado = models.BooleanField(default=True) # <-------- Noco campo
def __str__(self):
return self.tituloCriando As Migrations e Refletindo No Banco De Dados
Assim que este codigo for adicionado, será necessario fazer os comandos para criar um novo arquivo de migration dentro da aplicação e outro comando para refletir este novo arquivo no banco de dados:
# Comando para criar arquivo de migrations
python manage.py makemigrations
# Comando para refletir a migration no banco de dados.
python manage.py migrateAssim que esses comandos forem efetuados, voce estara pronto/apto para efetuar tambem as mudanças no site admin (no mesmo arquivo e a mesma classe que estavamos trabalhando antes).
Adicionando Um Novo Campo e Criando Nova Ação Customizada
# postagens/admin.py
from django.contrib import admin
from .models import Post
def despublicar_post(modeladmin, request, queryset): <--- Nova função
"""
Muda o status de uma
postagem para despublicado.
"""
queryset.update(publicado=False)
# Register your models here.
class PostAdmin(admin.ModelAdmin):
actions = [despublicar_post] <--- Ação adicionada com o nome da função criada acima.
fieldsets = (
('Informações Básicas', {
'fields': ('titulo',)
}),
('Conteúdo', {
'fields': ('conteudo',)
}),
('Estatus', { <--- Novo campo adicionado para listagem
'fields': ('publicado',)
}),
)
list_display = ('titulo', 'publicado_em', 'publicado')
search_fields = ('titulo',)
despublicar_post.short_description = 'Marcar posts como despublicados'
admin.site.register(Post, PostAdmin)Desta forma na listagem de postagens sera mostrado um novo campo detalhando se a postagem esta publicada ou não, e tambem o poder de despublicar varias postagens de uma vez.
Checando as mudanças
Neste caso eu irei apenas despublicar a primeira postagem para deixar o resultado como exemplo abaixo:
Como pode ver, a postagem foi despublicada. Neste caso, ao clicar no “dropdown” e escolhido a ação de desplublicar, a função despublicar_post() foi acionada mudando o estatus desta postagem. Porem, caso necessite efetuar a mundaçã de estatus (deixar o mesmo como publicado).
Simplesmente, clique na postagem no qual efetuamos o estatus de publicado anteriormente e clique para que o mesmo fique com o estatus de publicado novamente.
Aproveite o código desta aplicação e continue com este projeto
Conclusão
O Django Admin é uma das funcionalidades mais convenientes e poderosas para quem desenvolve aplicações com o Django.
Lembrando que essas mudanças no site admin são apenas algumas que e possivel efetuar. Existe uma gama enorme de possibilidades que podemos aplicar alem dessas.
Sendo assim, ao entender como configurar e customizar a interface de administração, é possível gerenciar o conteúdo de maneira eficiente e segura.
Se usado corretamente, ele elimina a necessidade de construir um painel administrativo do zero, poupando tempo e recursos.