Update routes/dashboard_home.py

routes/dashboard_home.py

@@ -3,10 +3,14 @@ import stripe
 import requests
 import logging
 import pytz
-from fastapi import APIRouter, HTTPException, Header, Query
+import asyncio
+import aiohttp
+from fastapi import APIRouter, HTTPException, Header, Query, Depends
 from datetime import datetime, timedelta
 from dateutil.relativedelta import relativedelta
-from typing import Dict, Any
+from typing import Dict, Any, Optional, List, Tuple
+from functools import lru_cache
+from concurrent.futures import ThreadPoolExecutor
 
 router = APIRouter()
 
@@ -29,41 +33,55 @@ SUPABASE_HEADERS = {
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-def verify_admin_token(user_token: str) -> str:
-    """Verifica se o token pertence a um administrador"""
+# Pool de threads para chamadas paralelas
+thread_pool = ThreadPoolExecutor(max_workers=10)
+
+# 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)
+
+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"
     }
     
-    # Primeiro, verifica se o token é válido
-    response = requests.get(f"{SUPABASE_URL}/auth/v1/user", headers=headers)
-    if response.status_code != 200:
-        raise HTTPException(status_code=401, detail="Token inválido ou expirado")
-    
-    user_data = 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")
-    
-    # Verifica se o usuário é um administrador
-    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():
-        raise HTTPException(status_code=404, detail="Usuário não encontrado")
+    async with aiohttp.ClientSession() as session:
+        # Verificar se o token é válido
+        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")
     
-    user_info = response.json()[0]
-    is_admin = user_info.get("is_admin", False)
+    # Usar cache para verificar se é admin
+    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
 
-def get_total_platform_revenue(start_timestamp: int = None, end_timestamp: int = None) -> Dict[str, Any]:
-    """Obtém o faturamento total da plataforma no Stripe"""
+async def fetch_stripe_data(fetch_func, **params):
+    """Executa chamadas ao Stripe em thread separada para não bloquear"""
+    return await asyncio.to_thread(fetch_func, **params)
+
+async def get_total_platform_revenue(start_timestamp: Optional[int] = None, end_timestamp: Optional[int] = None) -> Dict[str, Any]:
+    """Obtém o faturamento total da plataforma no Stripe de forma otimizada"""
     try:
         query_params = {"limit": 100}
         
@@ -79,12 +97,13 @@ def get_total_platform_revenue(start_timestamp: int = None, end_timestamp: int =
         has_more = True
         last_id = None
         
-        # Paginar resultados para obter todos os pagamentos
+        # Usar batch para reduzir chamadas
         while has_more:
             if last_id:
                 query_params["starting_after"] = last_id
-                
-            payment_list = stripe.Charge.list(**query_params)
+            
+            # Usar thread para não bloquear o evento loop
+            payment_list = await fetch_stripe_data(stripe.Charge.list, **query_params)
             payments.extend(payment_list.data)
             
             has_more = payment_list.has_more
@@ -93,24 +112,22 @@ def get_total_platform_revenue(start_timestamp: int = None, end_timestamp: int =
             else:
                 has_more = False
         
-        # Calcular totais
-        total_revenue = 0
-        successful_revenue = 0
-        failed_revenue = 0
+        # Calcular totais em uma única passagem
+        totals = {"total": 0, "succeeded": 0, "failed": 0}
         
         for payment in payments:
             amount = payment.amount
-            total_revenue += amount
+            totals["total"] += amount
             
             if payment.status == 'succeeded':
-                successful_revenue += amount
+                totals["succeeded"] += amount
             elif payment.status == 'failed':
-                failed_revenue += amount
+                totals["failed"] += amount
         
         return {
-            "total_revenue": total_revenue,
-            "successful_revenue": successful_revenue,
-            "failed_revenue": failed_revenue,
+            "total_revenue": totals["total"],
+            "successful_revenue": totals["succeeded"],
+            "failed_revenue": totals["failed"],
             "currency": "BRL",
             "payment_count": len(payments)
         }
@@ -126,8 +143,8 @@ def get_total_platform_revenue(start_timestamp: int = None, end_timestamp: int =
             "error": str(e)
         }
 
-def get_platform_transfers(start_timestamp: int = None, end_timestamp: int = None) -> Dict[str, Any]:
-    """Obtém o total transferido para estilistas"""
+async def get_platform_transfers(start_timestamp: Optional[int] = None, end_timestamp: Optional[int] = None) -> Dict[str, Any]:
+    """Obtém o total transferido para estilistas de forma otimizada"""
     try:
         query_params = {"limit": 100}
         
@@ -143,12 +160,13 @@ def get_platform_transfers(start_timestamp: int = None, end_timestamp: int = Non
         has_more = True
         last_id = None
         
-        # Paginar resultados para obter todas as transferências
+        # Usar batch para reduzir chamadas
         while has_more:
             if last_id:
                 query_params["starting_after"] = last_id
-                
-            transfer_list = stripe.Transfer.list(**query_params)
+            
+            # Usar thread para não bloquear o evento loop
+            transfer_list = await fetch_stripe_data(stripe.Transfer.list, **query_params)
             transfers.extend(transfer_list.data)
             
             has_more = transfer_list.has_more
@@ -157,7 +175,7 @@ def get_platform_transfers(start_timestamp: int = None, end_timestamp: int = Non
             else:
                 has_more = False
         
-        # Calcular total transferido para estilistas
+        # Cálculo otimizado
         total_transferred = sum(transfer.amount for transfer in transfers)
         
         return {
@@ -194,8 +212,46 @@ def get_app_revenue_share(total_revenue: int, total_transferred: int) -> Dict[st
         "currency": "BRL"
     }
 
-def get_monthly_revenue(target_date) -> Dict[str, Any]:
-    """Obtém o faturamento de um mês específico"""
+async def get_platform_users() -> Dict[str, Any]:
+    """Obtém informações sobre usuários e estilistas da plataforma de forma assíncrona"""
+    try:
+        async with aiohttp.ClientSession() as session:
+            # Executar ambas as chamadas em paralelo
+            tasks = [
+                session.get(f"{SUPABASE_URL}/rest/v1/User?select=id", headers=SUPABASE_HEADERS),
+                session.get(f"{SUPABASE_URL}/rest/v1/User?role=eq.stylist&select=id", headers=SUPABASE_HEADERS)
+            ]
+            
+            responses = await asyncio.gather(*tasks)
+            users_response, stylists_response = responses
+            
+            total_users = 0
+            if users_response.status == 200:
+                users_data = await users_response.json()
+                total_users = len(users_data)
+            
+            total_stylists = 0
+            if stylists_response.status == 200:
+                stylists_data = await stylists_response.json()
+                total_stylists = len(stylists_data)
+        
+        logger.info(f"Total de usuários: {total_users}, Total de estilistas: {total_stylists}")
+        
+        return {
+            "total_users": total_users,
+            "total_stylists": total_stylists
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao obter informações de usuários: {str(e)}")
+        return {
+            "total_users": 0,
+            "total_stylists": 0,
+            "error": str(e)
+        }
+
+async def get_monthly_revenue_data(target_date) -> Dict[str, Any]:
+    """Obtém o faturamento de um mês específico de forma otimizada"""
     ny_timezone = pytz.timezone('America/New_York')
     if not isinstance(target_date, datetime):
         target_date = datetime.now(ny_timezone)
@@ -211,9 +267,11 @@ def get_monthly_revenue(target_date) -> Dict[str, Any]:
     start_timestamp = int(month_start.timestamp())
     end_timestamp = int(month_end.timestamp())
     
-    # Obter dados do mês
-    revenue_data = get_total_platform_revenue(start_timestamp, end_timestamp)
-    transfer_data = get_platform_transfers(start_timestamp, end_timestamp)
+    # Obter dados do mês em paralelo
+    revenue_data, transfer_data = await asyncio.gather(
+        get_total_platform_revenue(start_timestamp, end_timestamp),
+        get_platform_transfers(start_timestamp, end_timestamp)
+    )
     
     # Calcular divisão app/estilistas
     total_revenue = revenue_data["successful_revenue"]
@@ -231,52 +289,18 @@ def get_monthly_revenue(target_date) -> Dict[str, Any]:
         "transfer_count": transfer_data["transfer_count"]
     }
 
-def get_platform_users() -> Dict[str, Any]:
-    """Obtém informações sobre usuários e estilistas da plataforma"""
-    try:
-        # Obter número total de usuários
-        users_url = f"{SUPABASE_URL}/rest/v1/User?select=id"
-        users_response = requests.get(users_url, headers=SUPABASE_HEADERS)
-        
-        total_users = 0
-        if users_response.status_code == 200:
-            total_users = len(users_response.json())
-        
-        # Obter número total de estilistas
-        stylists_url = f"{SUPABASE_URL}/rest/v1/User?role=eq.stylist&select=id"
-        stylists_response = requests.get(stylists_url, headers=SUPABASE_HEADERS)
-        
-        total_stylists = 0
-        if stylists_response.status_code == 200:
-            total_stylists = len(stylists_response.json())
-        
-        logger.info(f"Total de usuários: {total_users}, Total de estilistas: {total_stylists}")
-        
-        return {
-            "total_users": total_users,
-            "total_stylists": total_stylists
-        }
-        
-    except Exception as e:
-        logger.error(f"❌ Erro ao obter informações de usuários: {str(e)}")
-        return {
-            "total_users": 0,
-            "total_stylists": 0,
-            "error": str(e)
-        }
-        
 @router.get("/admin/dashboard")
-def get_admin_dashboard(
+async def get_admin_dashboard(
     user_token: str = Header(None, alias="User-key"),
     period: str = Query("all_time", description="Período: all_time, last_month, last_year")
 ):
     """
     Endpoint para dashboard administrativo com métricas de faturamento
-    e divisão entre app e estilistas
+    e divisão entre app e estilistas - versão otimizada
     """
     try:
         # Verificar se é um administrador
-        user_id = verify_admin_token(user_token)
+        user_id = await verify_admin_token(user_token)
         
         # Definir intervalo de datas baseado no período solicitado
         ny_timezone = pytz.timezone('America/New_York')
@@ -292,19 +316,36 @@ def get_admin_dashboard(
             start_date = now_ny - relativedelta(years=1)
             start_timestamp = int(start_date.timestamp())
         
-        # Obter dados gerais de faturamento
-        revenue_data = get_total_platform_revenue(start_timestamp, end_timestamp)
-        transfer_data = get_platform_transfers(start_timestamp, end_timestamp)
+        # Executar todas as chamadas em paralelo
+        tasks = [
+            get_total_platform_revenue(start_timestamp, end_timestamp),
+            get_platform_transfers(start_timestamp, end_timestamp),
+            get_platform_users()
+        ]
         
-        # Calcular divisão de receita entre app e estilistas
+        # Adicionar task para dados mensais se necessário
+        monthly_task = None
+        if period == "last_month":
+            target_date = now_ny - relativedelta(months=1)
+            monthly_task = get_monthly_revenue_data(target_date)
+            tasks.append(monthly_task)
+        
+        # Esperar por todas as chamadas completarem
+        results = await asyncio.gather(*tasks)
+        
+        # Extrair resultados
+        if period == "last_month":
+            revenue_data, transfer_data, user_data, monthly_data = results
+        else:
+            revenue_data, transfer_data, user_data = results
+            monthly_data = None
+        
+        # Calcular divisão de receita
         revenue_share = get_app_revenue_share(
             revenue_data["successful_revenue"],
             transfer_data["total_transferred_to_stylists"]
         )
         
-        # Obter dados de usuários
-        user_data = get_platform_users()
-        
         # Preparar resposta
         response = {
             "total_revenue": revenue_data["successful_revenue"],
@@ -321,9 +362,7 @@ def get_admin_dashboard(
         }
         
         # Adicionar dados específicos de mês apenas para período last_month
-        if period == "last_month":
-            target_date = now_ny - relativedelta(months=1)
-            monthly_data = get_monthly_revenue(target_date)
+        if period == "last_month" and monthly_data:
             response["monthly_data"] = monthly_data
         
         return response