Merge pull request #105 from fivelibx/develop

Develop

Author: lucaspaiva-lp

README.md

@@ -1,4 +1,4 @@
-<img alt="FiveLib Banner" src="https://github.com/devacademicx/fivelib/blob/main/docs/assets/banner.png"/>
+<img alt="FiveLib Banner" src="https://fivelib.vercel.app"/>
 
 <div align="center">
 <br/>

backend/api/auth.py

@@ -1,3 +1,249 @@
+import random
+from datetime import datetime, timedelta, timezone
+from fastapi import APIRouter, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
+from schemas.auth import LoginRequest, LoginResponse, RegisterRequest, VerifyCodeRequest, ForgotPasswordRequest, ResetPasswordRequest
+from services.email_service import enviar_email_verificacao
+from database.config import supabase
+from api.security import obter_hash_senha, verificar_senha, criar_token_acesso
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/login")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/v1/auth/login")
+
+router = APIRouter(tags=["auth"])
+
+@router.post("/login", response_model=LoginResponse)
+async def login(data: LoginRequest):
+    response = supabase.table("user").select("*").eq("email", data.email).execute()
+    
+    user_data = response.data
+    
+    if not user_data:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="E-mail ou senha incorretos"
+        )
+    
+    user = user_data[0]
+    
+    if not verificar_senha(data.password, user["senha"]):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="E-mail ou senha incorretos"
+        )
+    
+    if not user.get("is_active", False):
+        novo_codigo = f"{random.randint(100000, 999999)}"
+        novo_tempo_expiracao = (datetime.now(timezone.utc) + timedelta(minutes=15)).isoformat()
+        
+        print("\n" + "="*50)
+        print(f"🔑 [LOGIN - CONTA INATIVA] NOVO CÓDIGO GERADO PARA {data.email}: {novo_codigo}")
+        print("="*50 + "\n")
+        
+        
+        supabase.table("user").update({
+            "verification_code": novo_codigo,
+            "verification_expires_at": novo_tempo_expiracao
+        }).eq("id", user["id"]).execute()
+        
+        await enviar_email_verificacao(email=user["email"], codigo=novo_codigo)
+        
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail={
+                "error": "requires_verification",
+                "email": user["email"],
+                "message": "Esta conta ainda não foi ativada. Um novo código foi gerado."
+            }
+        )
+    
+    payload_usuario = {
+        "sub": str(user["id"]),
+        "email": user["email"],
+        "role": user["perfil"]
+    }
+    
+    token_real = criar_token_acesso(data=payload_usuario)
+    
+    return {
+        "access_token": token_real,
+        "token_type": "bearer",
+        "role": user["perfil"],  
+        "name": user["nome"]
+    }
+
+@router.post("/register", status_code=status.HTTP_201_CREATED)
+async def register(data: RegisterRequest):
+    if not getattr(data, "accepted_terms", False):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Você precisa aceitar os Termos de Uso e a Política de Privacidade para se cadastrar."
+        )
+
+    user_exists = supabase.table("user").select("id, is_active").eq("email", data.email).execute()
+    
+    codigo_verificacao = f"{random.randint(100000, 999999)}"
+    tempo_expiracao = (datetime.now(timezone.utc) + timedelta(minutes=15)).isoformat()
+    senha_criptografada = obter_hash_senha(data.senha)
+    timestamp_aceite = datetime.now(timezone.utc).isoformat()
+
+    if user_exists.data:
+        usuario_atual = user_exists.data[0]
+        
+        if usuario_atual.get("is_active") == True:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Este e-mail já está cadastrado."
+            )
+        
+        print("\n" + "="*50)
+        print(f"🔄 [REENVIO/ATUALIZAÇÃO] NOVO CÓDIGO PARA {data.email}: {codigo_verificacao}")
+        print("="*50 + "\n")
+        
+        update_response = supabase.table("user").update({
+            "nome": data.nome,
+            "senha": senha_criptografada,
+            "data_nascimento": data.data_nascimento.isoformat(),
+            "verification_code": codigo_verificacao,
+            "verification_expires_at": tempo_expiracao,
+            "accepted_terms": True,
+            "accepted_terms_at": timestamp_aceite
+        }).eq("id", usuario_atual["id"]).execute()
+        
+        if not update_response.data:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Erro ao atualizar código de verificação. Tente novamente."
+            )
+        
+        await enviar_email_verificacao(email=data.email, codigo=codigo_verificacao)
+            
+        return {"message": "Um novo código de verificação foi gerado."}
+
+    print("\n" + "="*50)
+    print(f"📧 [NOVO CADASTRO] CÓDIGO PARA {data.email}: {codigo_verificacao}")
+    print("="*50 + "\n")
+    
+    novo_usuario = {
+        "nome": data.nome,
+        "email": data.email,
+        "senha": senha_criptografada,
+        "data_nascimento": data.data_nascimento.isoformat(),
+        "perfil": "user",
+        "is_active": False, 
+        "verification_code": codigo_verificacao,
+        "verification_expires_at": tempo_expiracao,
+        "accepted_terms": True,
+        "accepted_terms_at": timestamp_aceite
+    }
+    
+    insert_response = supabase.table("user").insert(novo_usuario).execute()
+    
+    if not insert_response.data:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erro ao criar conta. Tente novamente mais tarde."
+        )
+    
+    await enviar_email_verificacao(email=data.email, codigo=codigo_verificacao)
+    
+    return {"message": "Cadastro realizado com sucesso! Verifique seu e-mail para ativar a conta."}
+
+@router.post("/verify-code", status_code=status.HTTP_200_OK)
+async def verify_code(data: VerifyCodeRequest):
+    response = supabase.table("user").select("*").eq("email", data.email).execute()
+    
+    if not response.data:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Usuário não encontrado."
+        )
+        
+    user = response.data[0]
+    
+    if user.get("is_active", False):
+        return {"message": "Esta conta já está ativa."}
+        
+    if user.get("verification_code") != data.code:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Código de verificação incorreto."
+        )
+        
+    expires_at_str = user.get("verification_expires_at")
+    if expires_at_str:
+        expires_at = datetime.fromisoformat(expires_at_str.replace("Z", "+00:00"))
+        
+        if datetime.now(timezone.utc) > expires_at:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="O código de verificação expirou. Solicite um novo código."
+            )
+            
+    update_response = supabase.table("user").update({
+        "is_active": True,
+        "verification_code": None,
+        "verification_expires_at": None
+    }).eq("id", user["id"]).execute()
+    
+    if not update_response.data:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erro ao ativar a conta. Tente novamente."
+        )
+        
+    return {"message": "Conta ativada com sucesso! Você já pode fazer login."}
+
+@router.post("/forgot-password", status_code=status.HTTP_200_OK)
+async def forgot_password(data: ForgotPasswordRequest):
+    response = supabase.table("user").select("id, is_active").eq("email", data.email).execute()
+    
+    if not response.data:
+        return {"message": "Se o e-mail estiver cadastrado, um código de recuperação será enviado."}
+        
+    user = response.data[0]
+    
+    codigo_recuperacao = f"{random.randint(100000, 999999)}"
+    tempo_expiracao = (datetime.now(timezone.utc) + timedelta(minutes=15)).isoformat()
+    
+    print("\n" + "="*50)
+    print(f"🔒 [RECUPERAÇÃO DE SENHA] CÓDIGO GERADO PARA {data.email}: {codigo_recuperacao}")
+    print("="*50 + "\n")
+    
+    supabase.table("user").update({
+        "reset_password_code": codigo_recuperacao,
+        "reset_password_expires_at": tempo_expiracao
+    }).eq("id", user["id"]).execute()
+    
+    await enviar_email_verificacao(email=data.email, codigo=codigo_recuperacao)
+    
+    return {"message": "Código de recuperação gerado com sucesso. Verifique seu e-mail."}
+
+
+@router.post("/reset-password", status_code=status.HTTP_200_OK)
+async def reset_password(data: ResetPasswordRequest):
+    response = supabase.table("user").select("*").eq("email", data.email).execute()
+    
+    if not response.data:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Usuário não encontrado.")
+        
+    user = response.data[0]
+    
+    if not user.get("reset_password_code") or user.get("reset_password_code") != data.code:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Código de recuperação inválido.")
+        
+    expires_at_str = user.get("reset_password_expires_at")
+    if expires_at_str:
+        expires_at = datetime.fromisoformat(expires_at_str.replace("Z", "+00:00"))
+        if datetime.now(timezone.utc) > expires_at:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="O código de recuperação expirou.")
+            
+    nova_senha_criptografada = obter_hash_senha(data.nova_senha)
+    
+    supabase.table("user").update({
+        "senha": nova_senha_criptografada,
+        "reset_password_code": None,
+        "reset_password_expires_at": None,
+        "is_active": True 
+    }).eq("id", user["id"]).execute()
+    
+    return {"message": "Senha redefinida com sucesso! Você já pode fazer login."}

backend/api/routes/users.py

@@ -1,8 +1,36 @@
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, status
 from api.auth import oauth2_scheme
+from api.security import decodificar_token_acesso
+from database.config import supabase
 
 router = APIRouter()
 
+async def obter_usuario_atual(token: str = Depends(oauth2_scheme)):
+    payload = decodificar_token_acesso(token)
+    
+    user_id = payload.get("sub")
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token inválido: ID de usuário ausente no payload."
+        )
+        
+    response = supabase.table("user").select("id", "nome", "email", "perfil").eq("id", user_id).execute()
+    
+    if not response.data:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Usuário dono deste token não foi encontrado."
+        )
+        
+    return response.data[0]
+
+
 @router.get("/me")
-async def read_users_me(token: str = Depends(oauth2_scheme)):
-    return {"user": "Lucas", "token_received": token}
+async def read_users_me(current_user: dict = Depends(obter_usuario_atual)):
+    return {
+        "id": current_user["id"],
+        "name": current_user["nome"],
+        "email": current_user["email"],
+        "role": current_user["perfil"]
+    }

backend/api/security.py

@@ -0,0 +1,50 @@
+import os
+import bcrypt
+import jwt
+from datetime import datetime, timedelta, timezone
+from fastapi import HTTPException, status
+
+SECRET_KEY = os.getenv("JWT_SECRET_KEY", "chave_padrao_desenvolvimento_local_123456")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24
+
+def obter_hash_senha(senha: str) -> str:
+    senha_bytes = senha.encode('utf-8')
+    salt = bcrypt.gensalt()
+    hash_bytes = bcrypt.hashpw(senha_bytes, salt)
+    return hash_bytes.decode('utf-8')
+
+def verificar_senha(senha_plana: str, senha_hash: str) -> bool:
+    try:
+        senha_bytes = senha_plana.encode('utf-8')
+        hash_bytes = senha_hash.encode('utf-8')
+        return bcrypt.checkpw(senha_bytes, hash_bytes)
+    except Exception:
+        return False
+
+
+def criar_token_acesso(data: dict) -> str:
+    dados_para_criptografar = data.copy()
+
+    expiracao = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    dados_para_criptografar.update({"exp": expiracao})
+    
+    token_jwt = jwt.encode(dados_para_criptografar, SECRET_KEY, algorithm=ALGORITHM)
+    return token_jwt
+
+def decodificar_token_acesso(token: str) -> dict:
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        return payload
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="O token de acesso expirou. Faça login novamente.",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    except jwt.InvalidTokenError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token de acesso inválido.",
+            headers={"WWW-Authenticate": "Bearer"},
+        )

backend/main.py

@@ -4,6 +4,7 @@
 
 # Rotas da API
 from api.routes.health import router as health_router
+from api.auth import router as auth_router
 from api.routes.users import router as users_router
 from api.routes.tools import router as tools_router
 
@@ -31,7 +32,8 @@
 async def root():
     return {"message": "FiveLib API is running"}
 
-# NOTE: Registro dos roteadores.
-app.include_router(health_router, prefix="/health")
-app.include_router(users_router, prefix="/users")
-app.include_router(tools_router, prefix="/resources", tags=["Tools"])
+# NOTE: Registro dos roteadores com o prefixo da versão.
+app.include_router(health_router, prefix="/api/v1/health")
+app.include_router(auth_router, prefix="/api/v1/auth")
+app.include_router(users_router, prefix="/api/v1/users")
+app.include_router(tools_router, prefix="/api/v1/resources", tags=["Tools"])