Configurando e Gerenciando Aplicações Django com ORM e Admin

Configuração Inicial do Projeto Django

Para iniciar um projeto Django, é fundamental configurar a conexão com o banco de dados e garantir que as dependências necessárias estejam instaladas.

1.1. Configuração do Banco de Dados MySQL

Primeiro, crie um banco de dados no seu servidor MySQL. Por exemplo:

CREATE DATABASE IF NOT EXISTS gerenciamento_academico DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

Em seguida, configure o acesso ao banco de dados no arquivo settings.py do seu projeto Django:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'gerenciamento_academico',
        'USER': 'root',
        'PASSWORD': 'sua_senha_secreta', # Substitua pela sua senha
        'HOST': '127.0.0.1', # Ou o IP do seu servidor MySQL
        'PORT': '3306',
    }
}

Para usar MySQL com Django, o driver mysqlclient (que requer pymysql para compatibilidade Python 3) é recomendado. Adicione a seguinte linha no arquivo __init__.py da raiz do seu projeto para garantir que pymysql seja usado como o driver MySQL padrão:

import pymysql
pymysql.install_as_MySQLdb()

Para verificar a conectividade básica e aplicar as configurações iniciais do Django, execute o comando de migração, que também criará tabelas internas do Django:

python manage.py migrate

Criação e Ativação de uma Aplicação Django

Um projeto Django é composto por uma ou mais "apps". Crie uma nova aplicação para organizar seu código:

python manage.py startapp meu_app

Após criar a aplicação, adicione-a à lista INSTALLED_APPS no arquivo settings.py para que o Django a reconheça:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'meu_app', # Sua nova aplicação
]

2.1. Definição de Modelos (ORM)

Os modelos definem a estrutura das tabelas do banco de dados e são a interface do Django ORM. No arquivo meu_app/models.py, defina os modelos para turmas e estudantes:

from django.db import models

class Turma(models.Model):
    nome_turma = models.CharField(max_length=50, verbose_name="Nome da Turma")
    data_inicio = models.DateField(verbose_name="Data de Início")
    num_alunas = models.IntegerField(default=0, verbose_name="Número de Alunas")
    num_alunos = models.IntegerField(default=0, verbose_name="Número de Alunos")
    excluida = models.BooleanField(default=False, verbose_name="Turma Excluída")

    def __str__(self):
        return f"{self.nome_turma} ({self.num_alunas} Alunas, {self.num_alunos} Alunos)"

    class Meta:
        db_table = "turmas" # Nome da tabela no banco de dados
        verbose_name = "Turma"
        verbose_name_plural = "Turmas"
        ordering = ['nome_turma'] # Ordenação padrão

class Estudante(models.Model):
    nome_completo = models.CharField(max_length=100, verbose_name="Nome Completo")
    genero_masculino = models.BooleanField(default=True, verbose_name="É Masculino?")
    idade = models.IntegerField(verbose_name="Idade")
    observacoes = models.TextField(blank=True, null=True, verbose_name="Observações")
    excluido = models.BooleanField(default=False, verbose_name="Estudante Excluído")
    data_cadastro = models.DateTimeField(auto_now_add=True, verbose_name="Data de Cadastro")
    data_atualizacao = models.DateTimeField(auto_now=True, verbose_name="Última Atualização")
    turma = models.ForeignKey(Turma, on_delete=models.CASCADE, related_name="estudantes", verbose_name="Turma")

    def __str__(self):
        return self.nome_completo

    class Meta:
        db_table = "estudantes" # Nome da tabela no banco de dados
        verbose_name = "Estudante"
        verbose_name_plural = "Estudantes"
        ordering = ['nome_completo'] # Ordenação padrão

2.2. Geração e Aplicação de Migrações

Após definir os modelos, o Django precisa criar as tabelas correspondentes no banco de dados. Isso é feito em duas etapas:

Crie os arquivos de migração:

python manage.py makemigrations meu_app

Aplique as migrações ao banco de dados:

python manage.py migrate

Inteargindo com o Banco de Dados via Shell do Django

O shell do Django é uma ferramenta poderosa para interagir com seus modelos e dados. Para acessá-lo:

python manage.py shell

Dentro do shell, importe seus modelos e comece a manipular os dados:

>>> from meu_app.models import Turma, Estudante
>>> from datetime import date

# 1. Criar objetos (registros)
>>> turma1 = Turma.objects.create(nome_turma="Python Avançado", data_inicio=date(2023, 1, 15), num_alunas=5, num_alunos=15)
>>> turma2 = Turma.objects.create(nome_turma="Desenvolvimento Web", data_inicio=date(2023, 3, 1), num_alunas=8, num_alunos=12)

# 2. Recuperar objetos
>>> todas_turmas = Turma.objects.all()
>>> print(todas_turmas)
# <queryset alunas="" alunos="" avan="" python="">, <turma: alunas="" alunos="" desenvolvimento="" web="">]>

>>> turma_por_id = Turma.objects.get(pk=1) # Recupera a turma com ID 1
>>> print(turma_por_id)
# <turma: alunas="" alunos="" avan="" python="">

# 3. Atualizar objetos
>>> turma_por_id.num_alunos = 18
>>> turma_por_id.save() # Salva as alterações no banco de dados

# 4. Criar Estudantes e associá-los a uma Turma
>>> estudante1 = Estudante.objects.create(nome_completo="Ana Silva", genero_masculino=False, idade=22, turma=turma1)
>>> estudante2 = Estudante.objects.create(nome_completo="Carlos Mendes", genero_masculino=True, idade=25, turma=turma1, observacoes="Excelente aluno")
>>> estudante3 = Estudante.objects.create(nome_completo="Beatriz Costa", genero_masculino=False, idade=20, turma=turma2)

# 5. Recuperar estudantes de uma turma
>>> estudantes_da_turma1 = turma1.estudantes.all()
>>> print(estudantes_da_turma1)
# <queryset ana="" silva="">, <estudante: carlos="" mendes="">]>

# 6. Excluir objetos
>>> turma_a_excluir = Turma.objects.get(pk=2)
>>> turma_a_excluir.delete()
# (2, {'meu_app.Estudante': 1, 'meu_app.Turma': 1}) - Note que estudantes associados também são excluídos devido a CASCADE.

# Para sair do shell
>>> quit()
</estudante:></queryset></turma:></turma:></queryset>

Gerenciamento de Servidor

Para iniciar o servidor de desenvolvimento do Django, execute:

python manage.py runserver

Por padrão, o srevidor rodará em http://127.0.0.1:8000/. Você pode especificar um endereço e porta:

python manage.py runserver 0.0.0.0:8000

Painel de Administração do Django

O painel de administração do Django oferece uma interface pronta para gerenciar seus dados.

5.1. Criação de Superusuário

Crie um superusuário para acessar o painel de administração:

python manage.py createsuperuser

Siga as instruções para definir nome de usuário, e-mail e senha.

5.2. Localização e Fuso Horário

No settings.py, configure a localização e o fuso horário para Português (Brasil) e o fuso horário de São Paulo:

LANGUAGE_CODE = 'pt-br'
TIME_ZONE = 'America/Sao_Paulo'
USE_TZ = True # Habilita o suporte a fuso horário

5.3. Registro de Modelos no Admin

Para que seus modelos apareçam no painel de administração, registre-os no arquivo meu_app/admin.py:

from django.contrib import admin
from .models import Turma, Estudante

# Opção 1: Registro simples
# admin.site.register(Turma)
# admin.site.register(Estudante)

# Opção 2: Registro com personalização (usando decorador)
@admin.register(Turma)
class AdminTurma(admin.ModelAdmin):
    list_display = ['nome_turma', 'data_inicio', 'num_alunas', 'num_alunos', 'excluida']
    list_filter = ['data_inicio', 'excluida']
    search_fields = ['nome_turma']
    list_per_page = 10 # Itens por página

    # Permite adicionar estudantes diretamente na página de edição da turma
    class EstudanteInline(admin.TabularInline):
        model = Estudante
        extra = 2 # Quantos campos vazios para novos estudantes serão mostrados

    inlines = [EstudanteInline]

@admin.register(Estudante)
class AdminEstudante(admin.ModelAdmin):
    # Método customizado para exibir o gênero de forma amigável
    def exibir_genero(self, obj):
        return "Masculino" if obj.genero_masculino else "Feminino"
    exibir_genero.short_description = "Gênero" # Nome da coluna no admin

    list_display = ['nome_completo', 'exibir_genero', 'idade', 'turma', 'excluida', 'data_cadastro']
    list_filter = ['genero_masculino', 'turma', 'excluida']
    search_fields = ['nome_completo', 'observacoes']
    list_per_page = 20 # Itens por página

    # Controla a posição das ações de massa (dropdown)
    actions_on_top = False
    actions_on_bottom = True

    # Campos que aparecem na tela de edição/criação
    fieldsets = (
        ("Informações Pessoais", {
            "fields": ('nome_completo', 'genero_masculino', 'idade')
        }),
        ("Detalhes da Turma", {
            "fields": ('turma', 'observacoes')
        }),
        ("Status", {
            "fields": ('excluida',)
        })
    )

Acesse http://127.0.0.1:8000/admin/ no seu navegador e faça login com as credenciais do superusuário para ver a interface de administração.

Implementando Vistas (Views) e URLs

As views processam requisições HTTP e retornam respostas. As URLs mapeiam caminhos da web para suas views.

6.1. Definição de Views

No arquivo meu_app/views.py, crie suas funções de view:

from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse
from .models import Turma, Estudante

def pagina_inicial(request):
    """View para a página inicial."""
    return HttpResponse("<h1>Bem-vindo à Gestão Acadêmica!</h1>")

def listar_turmas(request):
    """View para listar todas as turmas."""
    todas_turmas = Turma.objects.filter(excluida=False).order_by('nome_turma')
    contexto = {'turmas': todas_turmas}
    return render(request, 'meu_app/lista_turmas.html', contexto)

def detalhes_turma(request, turma_id):
    """View para exibir os detalhes de uma turma específica e seus estudantes."""
    turma_selecionada = get_object_or_404(Turma, pk=turma_id, excluida=False)
    estudantes_da_turma = turma_selecionada.estudantes.filter(excluida=False).order_by('nome_completo')
    contexto = {
        'turma': turma_selecionada,
        'estudantes': estudantes_da_turma
    }
    return render(request, 'meu_app/detalhes_turma.html', contexto)

def listar_todos_estudantes(request):
    """View para listar todos os estudantes."""
    todos_estudantes = Estudante.objects.filter(excluida=False).order_by('nome_completo')
    contexto = {'estudantes': todos_estudantes}
    return render(request, 'meu_app/lista_estudantes.html', contexto)

6.2. Configuração de URLs

Primeiro, inclua as URLs da sua aplicação no arquivo urls.py do seu projeto principal:

# Seu_Projeto/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('meu_app.urls')), # Inclui as URLs da sua aplicação
]

Em seguida, crie um arquivo urls.py dentro do diretório meu_app e defina os padrões de URL específicos da sua aplicação:

# meu_app/urls.py
from django.urls import path
from . import views

app_name = 'meu_app' # Namespace para suas URLs

urlpatterns = [
    path('', views.pagina_inicial, name='inicio'),
    path('turmas/', views.listar_turmas, name='listar_turmas'),
    path('turmas/<turma_id>/', views.detalhes_turma, name='detalhes_turma'),
    path('estudantes/', views.listar_todos_estudantes, name='listar_estudantes'),
]
</turma_id>

Criação de Templates (Modelos HTML)

Os templates são arquivos HTML que exibem os dados gerados pelas views. Crie uma pasta templates na raiz do seu projeto e, dentro dela, uma subpasta com o nome da sua aplicação (meu_app):

Seu_Projeto/
├── manage.py
├── Seu_Projeto/
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── meu_app/
│   ├── models.py
│   ├── views.py
│   ├── urls.py
│   └── ...
└── templates/
    └── meu_app/
        ├── lista_turmas.html
        ├── detalhes_turma.html
        └── lista_estudantes.html

7.1. Configuração do Caminho dos Templates

No settings.py, assegure que o Django saiba onde procurar pelos templates:

import os

# BASE_DIR já deve estar definido na raiz do seu settings.py
# BASE_DIR = Path(__file__).resolve().parent.parent

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')], # Adicione esta linha
        'APP_DIRS': True, # Permite que Django procure templates em subpastas 'templates' dentro de cada app
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

7.2. Exemplos de Templates

lista_turmas.html:


<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <title>Lista de Turmas</title>
</head>
<body>
    <h1>Turmas Disponíveis</h1>
    <ul>
        {% for turma in turmas %}
            <li>
                <a href="{% url 'meu_app:detalhes_turma' turma.id %}">
                    {{ turma.nome_turma }} ({{ turma.num_alunas }} Alunas, {{ turma.num_alunos }} Alunos)
                </a>
            </li>
        {% empty %}
            <li>Nenhuma turma encontrada.</li>
        {% endfor %}
    </ul>
    <p><a href="{% url 'meu_app:listar_estudantes' %}">Ver todos os Estudantes</a></p>
</body>
</html>

detalhes_turma.html:


<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <title>Detalhes da Turma - {{ turma.nome_turma }}</title>
</head>
<body>
    <h1>Detalhes da Turma: {{ turma.nome_turma }}</h1>
    <p><strong>Data de Início:</strong> {{ turma.data_inicio|date:"d/m/Y" }}</p>
    <p><strong>Número de Alunas:</strong> {{ turma.num_alunas }}</p>
    <p><strong>Número de Alunos:</strong> {{ turma.num_alunos }}</p>

    <h2>Estudantes da Turma:</h2>
    <ul>
        {% for estudante in estudantes %}
            <li>{{ estudante.nome_completo }} ({{ estudante.idade }} anos) - {{ estudante.get_genero_masculino_display }}</li>
        {% empty %}
            <li>Nenhum estudante nesta turma.</li>
        {% endfor %}
    </ul>
    <p><a href="{% url 'meu_app:listar_turmas' %}">Voltar para a lista de Turmas</a></p>
</body>
</html>

lista_estudantes.html:


<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <title>Lista de Estudantes</title>
</head>
<body>
    <h1>Todos os Estudantes</h1>
    <ul>
        {% for estudante in estudantes %}
            <li>
                {{ estudante.nome_completo }} (Idade: {{ estudante.idade }}, Turma: {{ estudante.turma.nome_turma }})
                {% if estudante.observacoes %}<br><small>Observações: {{ estudante.observacoes }}</small>{% endif %}
            </li>
        {% empty %}
            <li>Nenhum estudante encontrado.</li>
        {% endfor %}
    </ul>
    <p><a href="{% url 'meu_app:listar_turmas' %}">Voltar para a lista de Turmas</a></p>
</body>
</html>

Reconstrução de Migrações

Se você fizer alterações significativas nos modelos ou precisar resetar o esquema do banco de dados (ex: mudar de banco de dados, ou após um desastre), pode ser necessário recriar as migrações:

Apague os arquivos de migração existentes (exceto __init__.py) dentro de meu_app/migrations/.
Execute python manage.py makemigrations meu_app.
Execute python manage.py migrate.
ORM: Mapeamento Objeto-Relacional

O Django ORM (Object-Relational Mapper) é a ponte entre seus modelos Python e as tabelas do banco de dados. Cada classe de modelo corresponde a uma tabela, e cada atributo de modelo corresponde a uma coluna na tabela. Ele permite interagir com o banco de dados usando objetos Python, eliminando a necessidade de escrever SQL puro na maioria dos casos.

Preenchimento de Dados Iniciais (Exemplo SQL)

Para testes, você pode preencher o banco de dados diretamente com SQL após as migrações. Este é um exemplo para o modelo Turma e Estudante:

-- Inserir dados em 'turmas'
INSERT INTO turmas (nome_turma, data_inicio, num_alunas, num_alunos, excluida) VALUES
('Algoritmos I', '2023-08-01', 10, 15, 0),
('Estruturas de Dados', '2023-08-01', 8, 12, 0),
('Programação Web com Django', '2023-09-10', 12, 18, 0);

-- Inserir dados em 'estudantes' (substitua turma_id pelos IDs reais das turmas criadas)
INSERT INTO estudantes (nome_completo, genero_masculino, idade, observacoes, excluida, turma_id, data_cadastro, data_atualizacao) VALUES
('João Pereira', 1, 20, 'Ativo', 0, 1, NOW(), NOW()),
('Maria Souza', 0, 21, 'Bolsista', 0, 1, NOW(), NOW()),
('Pedro Lima', 1, 22, NULL, 0, 2, NOW(), NOW()),
('Julia Santos', 0, 19, 'Monitora', 0, 3, NOW(), NOW()),
('Rafael Alves', 1, 20, NULL, 0, 3, NOW(), NOW());

Tags: Django ORM Python MySQL Web Development

Publicado em 7-20 03:36

Doido Dev