Update routes/onboarding.py

routes/onboarding.py

@@ -1,12 +1,9 @@
 import os
 import logging
 import aiohttp
-import asyncio
 from pydantic import BaseModel
 from fastapi import APIRouter, HTTPException, Body, Query, Header
 from typing import List, Dict, Any, Optional, Union
-from functools import lru_cache
-import requests
 
 router = APIRouter()
 
@@ -48,64 +45,9 @@ SUPABASE_ROLE_HEADERS = {
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Cache para reduzir chamadas repetidas
-@lru_cache(maxsize=128)
-def get_cached_admin_status(user_id: str) -> bool:
-    """Obtém e armazena em cache se um usuário é admin"""
-    user_data_url = f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}"
-    response = requests.get(user_data_url, headers=SUPABASE_HEADERS)
-    
-    if response.status_code != 200 or not response.json():
-        return False
-    
-    user_info = response.json()[0]
-    return user_info.get("is_admin", False)
-
-# Função para obter permissões do usuário
-async def get_user_permissions(user_id: str) -> Dict[str, bool]:
-    """Obtém as permissões de um usuário"""
-    user_data_url = f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}&select=is_admin,edit_onboarding"
-    
-    async with aiohttp.ClientSession() as session:
-        async with session.get(user_data_url, headers=SUPABASE_HEADERS) as response:
-            if response.status != 200 or not await response.json():
-                return {"is_admin": False, "edit_onboarding": False}
-            
-            user_info = (await response.json())[0]
-            return {
-                "is_admin": user_info.get("is_admin", False),
-                "edit_onboarding": user_info.get("edit_onboarding", False)
-            }
-
-# Verificação de token admin (mantida para compatibilidade)
-async def verify_admin_token(user_token: str) -> str:
-    """Verifica se o token pertence a um administrador de forma assíncrona"""
-    headers = {
-        "Authorization": f"Bearer {user_token}",
-        "apikey": SUPABASE_KEY,
-        "Content-Type": "application/json"
-    }
-    
-    async with aiohttp.ClientSession() as session:
-        async with session.get(f"{SUPABASE_URL}/auth/v1/user", headers=headers) as response:
-            if response.status != 200:
-                raise HTTPException(status_code=401, detail="Token inválido ou expirado")
-            
-            user_data = await response.json()
-            user_id = user_data.get("id")
-            if not user_id:
-                raise HTTPException(status_code=400, detail="ID do usuário não encontrado")
-    
-    is_admin = await asyncio.to_thread(get_cached_admin_status, user_id)
-    
-    if not is_admin:
-        raise HTTPException(status_code=403, detail="Acesso negado: privilégios de administrador necessários")
-    
-    return user_id
-
-# Verificação de token com permissões específicas
+# Função para verificar token e permissões
 async def verify_token_with_permissions(user_token: str, required_permission: Optional[str] = None) -> Dict[str, Any]:
-    """Verifica o token e verifica se o usuário tem a permissão necessária"""
+    """Verifica o token e retorna ID do usuário e suas permissões"""
     headers = {
         "Authorization": f"Bearer {user_token}",
         "apikey": SUPABASE_KEY,
@@ -123,26 +65,32 @@ async def verify_token_with_permissions(user_token: str, required_permission: Op
                 raise HTTPException(status_code=400, detail="ID do usuário não encontrado")
     
     # Obter permissões do usuário
-    permissions = await get_user_permissions(user_id)
-    
-    # Verificar se é admin
-    is_admin = permissions.get("is_admin", False)
-    if not is_admin:
-        raise HTTPException(status_code=403, detail="Acesso negado: privilégios de administrador necessários")
+    user_data_url = f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}&select=is_admin,edit_onboarding"
     
-    # Verificar permissão específica, se requisitada
-    if required_permission:
-        has_permission = permissions.get(required_permission, False)
-        if not has_permission:
-            raise HTTPException(
-                status_code=403, 
-                detail=f"Acesso negado: permissão '{required_permission}' necessária"
-            )
+    async with aiohttp.ClientSession() as session:
+        async with session.get(user_data_url, headers=SUPABASE_HEADERS) as response:
+            if response.status != 200 or not await response.json():
+                raise HTTPException(status_code=403, detail="Acesso negado: não foi possível verificar permissões")
+            
+            user_info = (await response.json())[0]
+            is_admin = user_info.get("is_admin", False)
+            
+            if not is_admin:
+                raise HTTPException(status_code=403, detail="Acesso negado: privilégios de administrador necessários")
+            
+            # Verificar permissão específica, se requisitada
+            if required_permission:
+                has_permission = user_info.get(required_permission, False)
+                if not has_permission:
+                    raise HTTPException(
+                        status_code=403, 
+                        detail=f"Acesso negado: permissão '{required_permission}' necessária"
+                    )
     
     return {
         "user_id": user_id,
         "is_admin": is_admin,
-        "permissions": permissions
+        "permissions": user_info
     }
 
 @router.patch("/onboarding/update-question")
@@ -153,11 +101,12 @@ async def update_onboarding_question(
     """
     Atualiza uma pergunta de onboarding com base no ID.
     Apenas os campos enviados no payload serão atualizados.
+    Requer permissão de admin e edit_onboarding=true.
     """
     try:
         # Verificar se o usuário é admin e tem permissão para editar onboarding
         await verify_token_with_permissions(user_token, "edit_onboarding")
-        
+
         update_data = {}
 
         if payload.title is not None:
@@ -200,11 +149,12 @@ async def add_onboarding_question(
     """
     Adiciona uma nova pergunta de onboarding.
     Trata casos onde `options` vem como `{}` ou string.
+    Requer permissão de admin e edit_onboarding=true.
     """
     try:
         # Verificar se o usuário é admin e tem permissão para editar onboarding
         await verify_token_with_permissions(user_token, "edit_onboarding")
-        
+
         # Tratamento de `options`
         options = payload.options
 
@@ -249,11 +199,12 @@ async def delete_onboarding_question(
 ):
     """
     Deleta uma pergunta de onboarding com base no ID (passado via query parameter).
+    Requer permissão de admin e edit_onboarding=true.
     """
     try:
         # Verificar se o usuário é admin e tem permissão para editar onboarding
         await verify_token_with_permissions(user_token, "edit_onboarding")
-        
+
         query_url = f"{SUPABASE_URL}/rest/v1/Onboarding?id=eq.{id}"
         headers = SUPABASE_ROLE_HEADERS.copy()
         headers["Prefer"] = "return=representation"
@@ -278,20 +229,15 @@ async def delete_onboarding_question(
         raise HTTPException(status_code=500, detail="Erro interno do servidor")
 
 @router.get("/onboarding/questions")
-async def get_onboarding_questions(
-    user_token: str = Header(None, alias="User-key")
-) -> Dict[str, List[Dict[str, Any]]]:
+async def get_onboarding_questions(user_token: str = Header(None, alias="User-key")) -> Dict[str, List[Dict[str, Any]]]:
     """
     Retorna todas as perguntas de onboarding, separadas por target_type (client e stylist).
+    Requer permissão de admin e edit_onboarding=true.
     """
     try:
         # Verificar se o usuário é admin e tem permissão para editar onboarding
-        # Adicionamos um log para verificar o que está acontecendo
-        logger.info(f"Recebido token: {user_token[:10]}... para acesso às perguntas de onboarding")
-        
         await verify_token_with_permissions(user_token, "edit_onboarding")
-        logger.info("Token verificado com sucesso!")
-        
+
         query_url = f"{SUPABASE_URL}/rest/v1/Onboarding?select=id,title,description,question_type,options,target_type,optional,lock&order=created_at.asc"
         headers = SUPABASE_HEADERS.copy()
         headers["Accept"] = "application/json"
@@ -330,7 +276,6 @@ async def get_onboarding_questions(
         }
 
     except HTTPException as he:
-        logger.error(f"❌ HTTPException: {he.detail}")
         raise he
     except Exception as e:
         logger.error(f"❌ Erro ao obter perguntas de onboarding: {str(e)}")