Create logs.py

routes/logs.py

@@ -1,67 +1,94 @@
-import os
 import logging
 import aiohttp
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Query, Header
 from typing import List, Dict, Any
 
+from . import SUPABASE_URL, SUPABASE_HEADERS, verify_token_with_permissions
+
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
-# Supabase configs
-SUPABASE_URL = "https://ussxqnifefkgkaumjann.supabase.co"
-SUPABASE_KEY = os.getenv("SUPA_KEY")
-SUPABASE_ROLE_KEY = os.getenv("SUPA_SERVICE_KEY")  # <- necessária para acessar logs
+@router.get("/logs")
+async def get_logs(
+    page: int = Query(0, ge=0),
+    user_token: str = Header(..., alias="User-key")
+):
+    """
+    Retorna uma lista paginada de logs com informações do usuário.
+    Requer permissão de admin.
+    Cada página contém no máximo 50 logs.
+    """
+    try:
+        # Verifica permissão de administrador
+        await verify_token_with_permissions(user_token)
 
-if not SUPABASE_KEY or not SUPABASE_ROLE_KEY:
-    raise ValueError("❌ SUPA_KEY ou SUPA_SERVICE_KEY não foram definidos no ambiente!")
+        limit = 50
+        offset = page * limit
 
-# Headers corretos para API de LOGS (precisa da role key!)
-SUPABASE_ROLE_HEADERS = {
-    "apikey": SUPABASE_ROLE_KEY,
-    "Authorization": f"Bearer {SUPABASE_ROLE_KEY}",
-    "Content-Type": "application/json"
-}
+        query_url = f"{SUPABASE_URL}/rest/v1/Logs?order=created_at.desc&limit={limit}&offset={offset}&select=id,user,action,reference,old_data,new_data,created_at"
 
-# Logging interno
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+        async with aiohttp.ClientSession() as session:
+            async with session.get(query_url, headers=SUPABASE_HEADERS) as response:
+                if response.status != 200:
+                    detail = await response.text()
+                    logger.error(f"❌ Erro ao buscar logs: {detail}")
+                    raise HTTPException(status_code=response.status, detail="Erro ao buscar logs")
 
+                logs = await response.json()
 
-@router.get("/logs", response_model=List[Dict[str, Any]])
-async def get_onboarding_logs():
-    """
-    Retorna os últimos 10 logs de modificação na tabela Onboarding.
-    """
-    project_ref = SUPABASE_URL.split("//")[1].split(".")[0]
-    log_api_url = f"https://api.supabase.com/v1/projects/{project_ref}/logs"
+        # Se não houver registros, retorna lista vazia
+        if not logs:
+            return {
+                "logs": [],
+                "page": page,
+                "has_next": False
+            }
 
-    params = {
-        "sql": """
-        select
-          cast(timestamp as text) as timestamp,
-          m.method,
-          m.status_code,
-          r.url
-        from edge_logs
-          cross join unnest(metadata) as m
-          cross join unnest(m.request) as r
-        where
-          path like '%rest/v1/Onboarding%'
-          and m.method in ('POST', 'PATCH', 'PUT', 'DELETE')
-        order by timestamp desc
-        limit 10
-        """
-    }
+        # Coletar todos os user_ids distintos
+        user_ids = list({log["user"] for log in logs if log.get("user")})
+        if not user_ids:
+            user_info_map = {}
+        else:
+            user_ids_query = ",".join(f'"{uid}"' for uid in user_ids)
+            users_url = f"{SUPABASE_URL}/rest/v1/User?id=in.({user_ids_query})&select=id,name,avatar"
 
-    async with aiohttp.ClientSession() as session:
-        try:
-            async with session.get(log_api_url, headers=SUPABASE_ROLE_HEADERS, params=params) as response:
-                if response.status != 200:
-                    error_body = await response.text()
-                    logger.error(f"Erro ao consultar logs: {error_body}")
-                    raise HTTPException(status_code=response.status, detail=error_body)
+            async with aiohttp.ClientSession() as session:
+                async with session.get(users_url, headers=SUPABASE_HEADERS) as response:
+                    if response.status != 200:
+                        logger.warning("⚠️ Erro ao buscar dados dos usuários")
+                        user_info_map = {}
+                    else:
+                        users_data = await response.json()
+                        user_info_map = {user["id"]: {"name": user["name"], "avatar": user["avatar"]} for user in users_data}
+
+        # Montar resposta com user_info
+        enriched_logs = []
+        for log in logs:
+            user_data = user_info_map.get(log["user"], {"name": None, "avatar": None})
+            enriched_logs.append({
+                "id": log["id"],
+                "user": {
+                    "id": log["user"],
+                    "name": user_data["name"],
+                    "avatar": user_data["avatar"]
+                },
+                "action": log["action"],
+                "reference": log["reference"],
+                "old_data": log["old_data"],
+                "new_data": log["new_data"],
+                "created_at": log["created_at"]
+            })
+
+        has_next = len(logs) == limit
 
-                return await response.json()
+        return {
+            "logs": enriched_logs,
+            "page": page,
+            "has_next": has_next
+        }
 
-        except Exception as e:
-            logger.exception("Erro inesperado ao consultar logs")
-            raise HTTPException(status_code=500, detail=str(e))
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"❌ Erro interno ao buscar logs: {str(e)}")
+        raise HTTPException(status_code=500, detail="Erro interno do servidor")