Implementa projeto

Author: RicardoMourao-py

.gitignore

@@ -0,0 +1,6 @@
+# arquivos a serem ignorados
+.DS_Store
+*.pyc
+__pycache__/
+venv/
+*.env

README.md

@@ -1 +1,87 @@
-"# FastAPI_Filmes" 
+# API Gerenciadora de Filmes e suas respectivas Avaliações
+
+Este é um projeto foi criado para que o usuário use uma api que possa fazer o cadastramento de filmes e o cadastramento de avaliações desses filmes. Além disso, foi utilizado todos os requisitos para o CRUD e o API RESTful. Veja abaixo o modelo de entidade-relacionamento desse gerenciamento:
+
+<img src="img/ER_projeto.png">
+
+Observe pelo modelo de entidade-relacionamento, que avaliações possui um forte dependência, pois sempre estará linkada a um filme. Entretanto, um filme pode estar linkado a várias avaliações.
+
+Ademais, o projeto consiste em duas etapas, a primeira consolida suas informações em arquivos .txt sem a utilização de banco de dados. Veja abaixo:
+
+### **Link para vídeo da primeira parte implementada:**
+Nesse vídeo é possível encontrar requisitos adequados de práticas iniciais do uso da API e como utilizá-la no mundo real, como por exemplo, conexão com o front-end. <br>
+https://www.youtube.com/watch?v=pYtyoPe8YtU
+
+Nesse contexto, o projeto busca a melhores práticas do mercado, portanto, é importante a utilização de banco de dados. Logo, na segunda parte do projeto é utilizado `MySQL`, entretanto, qualquer outro database pode ser implementado. Visualize abaixo a segunda parte implementada e explicada:
+
+### **Link para vídeo da segunda parte implementada:**
+Nesse vídeo é possível encontrar requisitos adequados de práticas do uso da API conectadas a um banco de dados. <br>
+https://youtu.be/c97G6mM7Quk
+
+---
+## Utilização do Projeto
+Com isso, para rodar o projeto em sua máquina local siga as etapas abaixo:
+
+1. Uitlize o prompt de comando para Clonar o repositório em um diretório da sua preferência:
+```
+git clone https://github.com/insper-classroom/23-1-projeto-sql-insper-inside-team.git
+```
+2. Crie seu ambiente virtual no prompt
+```
+python -m venv name_env
+```
+3. Ative o seu ambiente virtual
+```
+name_env\Scripts\activate.bat
+```
+4. Instale todas suas dependências
+```
+pip install -r requirements.txt
+``` 
+5. Crie seu database com suas tabelas no seu DBMS(Database Management System) com a query abaixo:
+```sql
+CREATE DATABASE IF NOT EXISTS filmes;
+
+USE filmes;
+
+CREATE TABLE IF NOT EXISTS filmes (
+    id_filme INTEGER PRIMARY KEY NOT NULL auto_increment,
+    nome VARCHAR(255) UNIQUE NOT NULL,
+    ano INTEGER NOT NULL,
+    duracao FLOAT NOT NULL,
+    descricao TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS avaliacoes (
+    id_avaliacao INTEGER PRIMARY KEY NOT NULL auto_increment,
+    comentario TEXT NOT NULL,
+    nota FLOAT NOT NULL CHECK (nota >= 0 AND nota <= 10),
+    id_filme INTEGER,
+    FOREIGN KEY (id_filme) REFERENCES filmes(id_filme) ON DELETE CASCADE
+);
+```
+6. Crie um arquivo `.env` no seu diretório com suas credenciais. Observe que o banco de dados utilizado é o `MySQL`, caso esteja utilizando outro, pesquise quais características seu arquivo `.env` deve ter e modifique o arquivo [database.py](sql_app/database.py) de acordo com as especificações. Caso esteja utilizando o mesmo, basta criá-lo com o seguinte conteúdo (lembre-se de adicionar o que está em branco):
+```
+DB_PROVIDER=mysql
+DB_DRIVER=mysqlconnector
+DB_DATABASE_NAME=filmes
+DB_USER=
+DB_PASSWORD=
+DB_HOST=localhost
+DB_PORT=3306
+DB_CONNECTION_STRING=${DB_PROVIDER}+${DB_DRIVER}://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE_NAME}
+```
+6. Execute o projeto
+```
+uvicorn main:app --reload
+```
+7. Abra o seu browser em: <br>
+http://127.0.0.1:8000/docs <br>
+
+Deve aparecer a seguinte tela:
+
+<img src="img/interface.png">
+
+<BR>
+
+## <center>  SE DIVIRTA !!! </center>

img/ER_projeto.png

@@ -0,0 +1,12 @@
+from fastapi import FastAPI
+from sql_app.routes import routeAvaliacao, routeFilme
+
+app = FastAPI(
+    title="Cadastre Filmes e os Avalie !!!",
+    description="API para gerenciar filmes e avaliações",
+    version="1.0.0",
+)
+
+# Adiciona as rotas para as classes Movie e Rating
+app.include_router(routeFilme.router, tags=["Filmes"])
+app.include_router(routeAvaliacao.router, tags=["Avaliações"])

img/interface.png

@@ -0,0 +1,5 @@
+python-dotenv==1.0.0
+SQLAlchemy==1.4.32
+fastapi==0.95.0
+pydantic==1.10.6
+typing-extensions==4.5.0

main.py

@@ -0,0 +1,59 @@
+from sqlalchemy.orm import Session
+
+from . import models, schemas
+
+############################### CRUD Filmes ################################################
+def read_filme(db: Session, filme_id: int):
+    return db.query(models.Filme).filter(models.Filme.id_filme == filme_id).first()
+  
+def read_filmes(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Filme).offset(skip).limit(limit).all()
+
+def create_filme(db: Session, filme: schemas.FilmeCreate):
+    db_filme = models.Filme(**filme.dict())
+    db.add(db_filme)
+    db.commit()
+    db.refresh(db_filme)
+    return db_filme
+
+def update_filme(db: Session, filme_id: int, filme: schemas.FilmeUpdate):
+    db_filme = db.query(models.Filme).filter(models.Filme.id_filme == filme_id).first()
+    for key, value in filme.dict().items():
+        setattr(db_filme, key, value)
+    db.commit()
+    db.refresh(db_filme)
+    return db_filme
+
+def delete_filme(db: Session, filme_id: int):
+    db_filme = db.query(models.Filme).filter(models.Filme.id_filme == filme_id).first()
+    db.delete(db_filme)
+    db.commit()
+    return {"Filme deletado": db_filme}
+
+############################### CRUD Avaliacoes ###########################################
+def read_avaliacoes(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Avaliacao).offset(skip).limit(limit).all()
+
+def read_avaliacao(db: Session, filme_id: int):
+    return db.query(models.Avaliacao).filter(models.Avaliacao.id_filme == filme_id).all()
+
+def create_avaliacao(db: Session, avaliacao: schemas.AvaliacaoCreate):
+    db_avaliacao = models.Avaliacao(**avaliacao.dict())
+    db.add(db_avaliacao)
+    db.commit()
+    db.refresh(db_avaliacao)
+    return db_avaliacao
+
+def update_avaliacao(db: Session, avaliacao_id: int, avaliacao: schemas.AvaliacaoUpdate):
+    db_avaliacao = db.query(models.Avaliacao).filter(models.Avaliacao.id_avaliacao == avaliacao_id).first()
+    for key, value in avaliacao.dict().items():
+        setattr(db_avaliacao, key, value)
+    db.commit()
+    db.refresh(db_avaliacao)
+    return db_avaliacao
+
+def delete_avaliacao(db: Session, avaliacao_id: int):
+    db_avaliacao = db.query(models.Avaliacao).filter(models.Avaliacao.id_avaliacao == avaliacao_id).first()
+    db.delete(db_avaliacao)
+    db.commit()
+    return {"Avaliação deletada": db_avaliacao}

requirements.txt

@@ -0,0 +1,15 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from dotenv import dotenv_values
+
+env = dict(dotenv_values(".env"))
+
+SQLALCHEMY_DATABASE_URL = env.get("DB_CONNECTION_STRING")
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

sql_app/__init__.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Float, Column, ForeignKey, Integer, String, CheckConstraint
+from sqlalchemy.orm import relationship
+
+from .database import Base
+
+################################## Filme ############################################
+class Filme(Base):
+    __tablename__ = "filmes"
+
+    id_filme = Column(Integer, primary_key=True, nullable=True, unique=True, autoincrement=True)
+    nome = Column(String, nullable=True, unique=True)
+    ano = Column(Integer, nullable=True)
+    duracao = Column(Float, nullable=True)
+    descricao = Column(String, nullable=True)
+
+    avaliacoes = relationship("Avaliacao", backref='parent', passive_deletes=True)
+
+################################## Avaliacao ########################################
+class Avaliacao(Base):
+    __tablename__ = "avaliacoes"
+
+    id_avaliacao = Column(Integer, primary_key=True, nullable=True, unique=True, autoincrement=True)
+    comentario = Column(String, nullable=True)
+    nota = Column(Float, nullable=True)
+    id_filme = Column(Integer, ForeignKey("filmes.id_filme", ondelete='CASCADE'))
+
+    filme = relationship("Filme", back_populates="avaliacoes")
+
+    __table_args__ = (
+        CheckConstraint('nota >= 0 AND nota <= 10', name='check_nota'),
+    )

sql_app/crud.py

@@ -0,0 +1,75 @@
+from fastapi import APIRouter,Depends, FastAPI, HTTPException
+from sqlalchemy.orm import Session
+from .. import crud, models, schemas
+from ..database import SessionLocal, engine
+
+models.Base.metadata.create_all(bind=engine)
+
+router = APIRouter()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+################################ AVALIACOES ##########################################################
+@router.get("/avaliacoes", summary="Liste todas as avaliações")
+async def listar_avaliacoes(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    """
+    Responsável por retornar todas as avaliacoes do nosso banco de dados
+    Não possui argumentos.
+    """
+    
+    avaliacoes = crud.read_avaliacoes(db, skip=skip, limit=limit)
+    return avaliacoes
+
+@router.get("/avaliacoes/{id_filme}", summary="Obtenha a avaliação do seu filme")
+async def obter_avaliacao(id_filme: int, db: Session = Depends(get_db)):
+    """
+    Obtenha uma avaliação específica de um filme com seu determinado id.
+    """
+
+    db_filme = crud.read_avaliacao(db=db, filme_id=id_filme)
+    if db_filme is None:
+        raise HTTPException(status_code=404, detail="Filme not found")
+    return {"Avaliações do Filme escolhido": db_filme}
+
+@router.post("/avaliacoes", summary="Adicione uma avaliação")
+async def adicionar_avaliacao(avaliacao: schemas.AvaliacaoCreate, db: Session = Depends(get_db)):
+    """
+    Adiciona avaliações com suas características.
+    - id_avaliacao => Apesar de não visível, está autoincrementado no database
+    - id_filme => Identificador do Filme 
+    - comentario => Deixe sua opinião sobre esse filme
+    - nota => Forneça uma nota de 0 a 10 para o seu filme
+    """
+    db_filme = crud.read_filme(db=db, filme_id=avaliacao.id_filme)
+    if db_filme is None:
+        raise HTTPException(status_code=404, detail="Filme not found")
+    return crud.create_avaliacao(db=db, avaliacao=avaliacao)
+    
+
+@router.put("/avaliacoes/{id_avaliacao}", summary="Atualize a sua avaliação do filme")
+async def atualizar_avaliacao(id_avaliacao: int, avaliacao: schemas.AvaliacaoUpdate, db: Session = Depends(get_db)):
+    """
+    Atualize uma determinada avaliação com todas as suas caracteríticas.
+    """
+
+    db_avaliacao = crud.update_avaliacao(db=db, avaliacao_id=id_avaliacao, avaliacao=avaliacao)
+    if db_avaliacao is None:
+        raise HTTPException(status_code=404, detail="Avaliacao not found")
+    return db_avaliacao
+    
+@router.delete("/avaliacoes/{id_avaliacao}", summary="Delete a sua avaliação do filme")
+async def remover_avaliacao(id_avaliacao: int, db: Session = Depends(get_db)):
+    """
+    Delete uma avaliação com o seu determinado Identificador.
+    """
+
+    db_avaliacao = crud.delete_avaliacao(db=db, avaliacao_id=id_avaliacao)
+    if db_avaliacao is None:
+        raise HTTPException(status_code=404, detail="Avaliacao not found")
+    return db_avaliacao

sql_app/database.py

@@ -0,0 +1,79 @@
+from fastapi import APIRouter,Depends, FastAPI, HTTPException
+from sqlalchemy.orm import Session
+from .. import crud, models, schemas
+from ..database import SessionLocal, engine
+models.Base.metadata.create_all(bind=engine)
+
+router = APIRouter()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+        
+################################ FILMES #############################################################
+@router.get("/filmes", summary="Liste todos os filmes")
+def listar_filmes(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    """
+    Responsável por retornar todas os filmes do nosso banco de dados
+
+    Não possui argumentos.
+    """
+
+    filmes = crud.read_filmes(db, skip=skip, limit=limit)
+    return filmes
+
+@router.get("/filmes/{id_filme}", summary="Obtenha o seu filme")
+def obter_filme(id_filme: int, db: Session = Depends(get_db)):
+    """
+    Obtenha um filme específico com seu determinado id.
+    """
+
+    db_filme = crud.read_filme(db=db, filme_id=id_filme)
+    if db_filme is None:
+        raise HTTPException(status_code=404, detail="Filme not found")
+    return db_filme
+
+@router.post("/filmes", summary="Adicione um filme")
+def adicionar_filme(filme: schemas.FilmeCreate, db: Session = Depends(get_db)):
+    """
+    Adiciona filmes com suas características.
+
+    - id_filme => Apesar de não estar visível, ele está autoincrementado no database.
+    - nome => Nome do filme 
+    - ano => Ano de lançamento do filme 
+    - duracao => Duração em horas do filme 
+    - descricao => Descrição da sinopse do filme 
+    """
+
+    # TODO: Não faz sentido verificar se o id nao existe entao 
+    #       poderia fazer verificação por nome
+
+    return crud.create_filme(db=db, filme=filme)
+        
+
+@router.put("/filmes/{id_filme}", summary="Atualize um filme")
+async def atualizar_filme(id_filme: int, filme: schemas.FilmeUpdate, db: Session = Depends(get_db)):
+    """
+    Atualize um determinado filme com todas as suas caracteríticas.
+    """
+
+    db_filme = crud.update_filme(db=db, filme_id=id_filme, filme=filme)
+    if db_filme is None:
+        raise HTTPException(status_code=404, detail="Filme not found")
+    return db_filme
+
+@router.delete("/filmes/{id_filme}", summary="Delete um filme")
+async def remover_filme(id_filme: int, db: Session = Depends(get_db)):
+    """
+    Delete um filme com o seu determinado Identificador. Lembre que caso remova um filme,
+    não haverá mais comentários relacionados a ele.
+    """
+
+    db_filme = crud.delete_filme(db=db, filme_id=id_filme)
+    if db_filme is None:
+        raise HTTPException(status_code=404, detail="Filme not found")
+    return db_filme