Desafio da Aula
Agora o foco será modelar dados relacionados com SQLModel e expor essas informações por meio de uma API.
Você irá criar um sistema simples de alunos e tarefas, com relacionamento entre as tabelas.
Tarefa:
Seu objetivo será implementar o modelo SQL, e a API para gerenciar alunos e suas tarefas.
Para te ajudar neste processo, ao final do enunciado, você encontrará um template para o seu arquivo de modelos SQLModel,
e um outro template para sua API.
Para executar os testes, você poderá utilizar o docs oferecido pelo próprio FastAPI
1. Modelagem com SQLModel
Estruture os modelos e o relacionamento no banco de dados
Você deverá modelar apenas 1 tabela, com os seguintes parâmetros:
- Tabela de alunos:
- nome
- idade
- Acesso direto as tarefas - Veja as Dicas para descobrir como fazer isso
Para facilitar, a propriedade do ID já foi implementada em uma tabela, e na outra, a tarefa já está totalmente implementada, segue um template do código que você deverá completar:
from typing import List
# Este import será importante em algum lugar...
# Dica: Olhe as outras dicas : D
from sqlmodel import Field, Relationship, SQLModel
class Aluno(SQLModel, table=True):
nusp: int | None = Field(default=None, primary_key=True)
# Implemente aqui os registros para o nome e idade do aluno.
#Atente-se a como a tarefa referência os alunos.
#
# É só uma tarefa, ou são várias tarefas?
# Pelo modelo de Tarefa, devemos preparar algo a mais
# para que possamos pegar o aluno pela tarefa?
# A dica está nos imports.
class Tarefa(SQLModel, table=True):
id: int | None = Field(default=None, primary_key=True)
nome: str
duracao: int
aluno_nusp: int = Field(foreign_key="aluno.nusp")
aluno: Aluno = Relationship(back_populates="tarefas")
# Dica numero 2:
# "tarefas" deve ser o nome do atributo
# que representa a relação no modelo Aluno
2. Implementação da API
Implemente as rotas necessárias para cadastrar e consultar os dados:
- POST:
- GET:
- Listar TODOS os alunos
- Listar TODAS as tarefas de um aluno em específico
Para adiantar a configuração básica, use o template abaixo com a estrutura básica já feita, e algumas outras funções que poderão ser usadas como referência:
from fastapi import FastAPI
from sqlmodel import Session, select, SQLModel, create_engine
from models import Aluno, Tarefa
arquivo_sqlite = "exercicio_7.db"
url_sqlite = f"sqlite:///{arquivo_sqlite}"
engine = create_engine(url_sqlite)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
app = FastAPI()
@app.on_event("startup")
def on_startup() -> None:
create_db_and_tables()
@app.post("/alunos")
def criar_aluno(aluno: Aluno):
with Session(engine) as session:
# Implemente aqui os comandos para adicionar, salvar e depois
# como resposta da API:
# retorne o objeto aluno da forma em que ele foi salvo no banco de dados.
@app.post("/tarefas")
def criar_tarefa(tarefa: Tarefa):
with Session(engine) as session:
session.add(tarefa)
session.commit()
session.refresh(tarefa)
return tarefa
@app.get("/alunos")
def listar_alunos():
with Session(engine) as session:
# Implemente aqui o comando para retornar:
# A lista de TODOS os alunos
# cadastrados no banco de dados.
@app.get("/tarefas")
def listar_tarefas():
with Session(engine) as session:
return session.exec(select(Tarefa)).all()
@app.get("/alunos/{aluno_nusp}/tarefas")
def listar_tarefas_do_aluno(aluno_nusp: int):
with Session(engine) as session:
# Implemente aqui os comandos para retornar:
# A lista de tarefas associadas a um aluno.
# você pode fazer esta consulta tanto
# através da estruturação de uma consulta normal SQL,
# quanto simplesmente pegando o Aluno
# e retornando a propriedade implementada anteriormente.
Entregue um arquivo para os modelos e o arquivo da API utilizando destes modelos.