Update routes/onboarding.py

routes/onboarding.py

@@ -1,9 +1,12 @@
 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()
 
@@ -45,66 +48,101 @@ SUPABASE_ROLE_HEADERS = {
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-async def verify_token_with_permissions(user_token: str, required_permission: Optional[str] = None) -> Dict[str, Any]:
-    """Verifica o token e retorna ID do usuário e suas permissões"""
-    headers = {
-        "Authorization": f"Bearer {user_token}",
-        "apikey": SUPABASE_KEY,
-        "Content-Type": "application/json"
-    }
+# 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)
     
-    # Log para depuração
-    logger.info("Iniciando verificação de token")
+    if response.status_code != 200 or not response.json():
+        return False
     
-    try:
-        async with aiohttp.ClientSession() as session:
-            auth_url = f"{SUPABASE_URL}/auth/v1/user"
-            logger.info(f"Enviando requisição para {auth_url}")
-            
-            async with session.get(auth_url, headers=headers) as response:
-                status = response.status
-                logger.info(f"Resposta da verificação do token: {status}")
-                
-                if status != 200:
-                    response_text = await response.text()
-                    logger.error(f"Erro na autenticação: {status} - {response_text}")
-                    raise HTTPException(status_code=401, detail=f"Token inválido ou expirado: {response_text}")
-                
-                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 na resposta")
-        
-        # Log para depuração        
-        logger.info(f"Token válido para usuário {user_id}, verificando permissões")
-    
-    # Obter permissões do usuário
+    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():
-                raise HTTPException(status_code=403, detail="Acesso negado: não foi possível verificar permissões")
+                return {"is_admin": False, "edit_onboarding": False}
             
             user_info = (await response.json())[0]
-            is_admin = user_info.get("is_admin", False)
+            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")
             
-            if not is_admin:
-                raise HTTPException(status_code=403, detail="Acesso negado: privilégios de administrador necessários")
+            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
+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"""
+    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")
             
-            # 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"
-                    )
+            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")
+    
+    # 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")
+    
+    # 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"
+            )
     
     return {
         "user_id": user_id,
         "is_admin": is_admin,
-        "permissions": user_info
+        "permissions": permissions
     }
 
 @router.patch("/onboarding/update-question")
@@ -115,12 +153,11 @@ 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:
@@ -163,12 +200,11 @@ 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
 
@@ -213,12 +249,11 @@ 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"
@@ -243,24 +278,19 @@ 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 token foi fornecido
-        if not user_token:
-            raise HTTPException(status_code=401, detail="Token de autenticação não fornecido")
-        
-        # Adicionar log para depuração
-        logger.info(f"Verificando token para acesso ao endpoint /onboarding/questions")
-        
         # Verificar se o usuário é admin e tem permissão para editar onboarding
-        await verify_token_with_permissions(user_token, "edit_onboarding")
+        # Adicionamos um log para verificar o que está acontecendo
+        logger.info(f"Recebido token: {user_token[:10]}... para acesso às perguntas de onboarding")
         
-        # Se chegou aqui, o token é válido e o usuário tem permissões
-        logger.info("Token validado com sucesso, buscando 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()
@@ -300,6 +330,7 @@ async def get_onboarding_questions(user_token: str = Header(None, alias="User-ke
         }
 
     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)}")