Create dashboard_home.py

routes/dashboard_home.py

@@ -0,0 +1,573 @@
+import os
+import stripe
+import requests
+import logging
+import pytz
+from fastapi import APIRouter, HTTPException, Header, Query
+from datetime import datetime, timedelta
+from dateutil.relativedelta import relativedelta
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+router = APIRouter()
+
+# Configuração das chaves do Stripe e Supabase
+stripe.api_key = os.getenv("STRIPE_KEY")
+stripe.api_version = "2023-10-16"
+SUPABASE_URL = "https://ussxqnifefkgkaumjann.supabase.co"
+SUPABASE_KEY = os.getenv("SUPA_KEY")
+
+if not stripe.api_key or not SUPABASE_KEY:
+    raise ValueError("❌ STRIPE_KEY ou SUPA_KEY não foram definidos no ambiente!")
+
+SUPABASE_HEADERS = {
+    "apikey": SUPABASE_KEY,
+    "Authorization": f"Bearer {SUPABASE_KEY}",
+    "Content-Type": "application/json"
+}
+
+# Configuração do logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Modelo para requisições com período de tempo opcional
+class DateRangeRequest(BaseModel):
+    start_date: Optional[str] = None  # Formato: 'YYYY-MM-DD'
+    end_date: Optional[str] = None    # Formato: 'YYYY-MM-DD'
+
+def verify_admin_token(user_token: str) -> str:
+    """Verifica se o token pertence a um administrador"""
+    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")
+    
+    # Agora 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")
+    
+    user_info = 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")
+    
+    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"""
+    try:
+        query_params = {
+            "limit": 100
+        }
+        
+        # Adicionar filtros de data se fornecidos
+        if start_timestamp and end_timestamp:
+            query_params["created"] = {
+                "gte": start_timestamp,
+                "lte": end_timestamp
+            }
+        elif start_timestamp:
+            query_params["created"] = {"gte": start_timestamp}
+        elif end_timestamp:
+            query_params["created"] = {"lte": end_timestamp}
+        
+        payments = []
+        has_more = True
+        last_id = None
+        
+        # Paginar resultados para obter todos os pagamentos
+        while has_more:
+            if last_id:
+                query_params["starting_after"] = last_id
+                
+            # Obter pagamentos (charges)
+            payment_list = stripe.Charge.list(**query_params)
+            payments.extend(payment_list.data)
+            
+            has_more = payment_list.has_more
+            if payment_list.data:
+                last_id = payment_list.data[-1].id
+            else:
+                has_more = False
+        
+        # Calcular totais
+        total_revenue = 0
+        successful_revenue = 0
+        failed_revenue = 0
+        
+        for payment in payments:
+            amount = payment.amount
+            
+            # Contar todas as tentativas para o valor bruto
+            total_revenue += amount
+            
+            # Separar por status
+            if payment.status == 'succeeded':
+                successful_revenue += amount
+            elif payment.status == 'failed':
+                failed_revenue += amount
+        
+        return {
+            "total_revenue": total_revenue,
+            "successful_revenue": successful_revenue,
+            "failed_revenue": failed_revenue,
+            "currency": "BRL",
+            "payment_count": len(payments)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao obter faturamento total: {str(e)}")
+        return {
+            "total_revenue": 0,
+            "successful_revenue": 0,
+            "failed_revenue": 0,
+            "currency": "BRL",
+            "payment_count": 0,
+            "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"""
+    try:
+        query_params = {
+            "limit": 100
+        }
+        
+        # Adicionar filtros de data se fornecidos
+        if start_timestamp and end_timestamp:
+            query_params["created"] = {
+                "gte": start_timestamp,
+                "lte": end_timestamp
+            }
+        elif start_timestamp:
+            query_params["created"] = {"gte": start_timestamp}
+        elif end_timestamp:
+            query_params["created"] = {"lte": end_timestamp}
+        
+        transfers = []
+        has_more = True
+        last_id = None
+        
+        # Paginar resultados para obter todas as transferências
+        while has_more:
+            if last_id:
+                query_params["starting_after"] = last_id
+                
+            # Obter transferências
+            transfer_list = stripe.Transfer.list(**query_params)
+            transfers.extend(transfer_list.data)
+            
+            has_more = transfer_list.has_more
+            if transfer_list.data:
+                last_id = transfer_list.data[-1].id
+            else:
+                has_more = False
+        
+        # Calcular total transferido para estilistas
+        total_transferred = sum(transfer.amount for transfer in transfers)
+        
+        return {
+            "total_transferred_to_stylists": total_transferred,
+            "currency": "BRL",
+            "transfer_count": len(transfers)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao obter transferências: {str(e)}")
+        return {
+            "total_transferred_to_stylists": 0,
+            "currency": "BRL",
+            "transfer_count": 0,
+            "error": str(e)
+        }
+
+def get_app_revenue_share(total_revenue: int, total_transferred: int) -> Dict[str, Any]:
+    """Calcula a parte do faturamento que ficou com o aplicativo"""
+    app_revenue = total_revenue - total_transferred
+    
+    # Calcular percentuais
+    if total_revenue > 0:
+        app_percentage = (app_revenue / total_revenue) * 100
+        stylists_percentage = (total_transferred / total_revenue) * 100
+    else:
+        app_percentage = 0
+        stylists_percentage = 0
+    
+    return {
+        "app_revenue": app_revenue,
+        "app_percentage": round(app_percentage, 2),
+        "stylists_percentage": round(stylists_percentage, 2),
+        "currency": "BRL"
+    }
+
+def get_monthly_revenue_breakdown(months: int = 12) -> List[Dict[str, Any]]:
+    """Obtém o faturamento mensal nos últimos X meses"""
+    ny_timezone = pytz.timezone('America/New_York')
+    now_ny = datetime.now(ny_timezone)
+    monthly_data = []
+    
+    for i in range(months):
+        # Calcular início e fim do mês
+        target_date = now_ny - relativedelta(months=i)
+        month_start = datetime(target_date.year, target_date.month, 1, tzinfo=ny_timezone)
+        if target_date.month == 12:
+            month_end = datetime(target_date.year + 1, 1, 1, tzinfo=ny_timezone) - timedelta(seconds=1)
+        else:
+            month_end = datetime(target_date.year, target_date.month + 1, 1, tzinfo=ny_timezone) - timedelta(seconds=1)
+        
+        # Converter para timestamps
+        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)
+        
+        # Calcular divisão app/estilistas
+        total_revenue = revenue_data["successful_revenue"]
+        total_transferred = transfer_data["total_transferred_to_stylists"]
+        app_revenue = total_revenue - total_transferred
+        
+        # Calcular percentual de crescimento (comparado ao mês anterior)
+        growth_percentage = 0
+        growth_status = "neutral"
+        
+        if i < months - 1 and len(monthly_data) > 0:
+            prev_month = monthly_data[0]
+            prev_revenue = prev_month["total_revenue"]
+            
+            if prev_revenue > 0:
+                growth_percentage = ((total_revenue - prev_revenue) / prev_revenue) * 100
+                growth_status = "up" if growth_percentage > 0 else "down" if growth_percentage < 0 else "neutral"
+        
+        monthly_data.insert(0, {
+            "year": target_date.year,
+            "month": target_date.month,
+            "name": target_date.strftime("%b"),
+            "total_revenue": total_revenue,
+            "app_revenue": app_revenue,
+            "stylists_revenue": total_transferred,
+            "payment_count": revenue_data["payment_count"],
+            "transfer_count": transfer_data["transfer_count"],
+            "growth": {
+                "percentage": round(growth_percentage, 2),
+                "status": growth_status,
+                "formatted": f"{round(growth_percentage, 2)}%"
+            }
+        })
+    
+    return monthly_data
+
+def get_top_earning_stylists(limit: int = 10, start_timestamp: int = None, end_timestamp: int = None) -> List[Dict[str, Any]]:
+    """Obtém os estilistas com maior faturamento no período"""
+    try:
+        query_params = {
+            "limit": 100,
+            "expand": ["destination"]
+        }
+        
+        # Adicionar filtros de data se fornecidos
+        if start_timestamp and end_timestamp:
+            query_params["created"] = {
+                "gte": start_timestamp,
+                "lte": end_timestamp
+            }
+        elif start_timestamp:
+            query_params["created"] = {"gte": start_timestamp}
+        elif end_timestamp:
+            query_params["created"] = {"lte": end_timestamp}
+        
+        transfers = []
+        has_more = True
+        last_id = None
+        
+        # Paginar resultados para obter todas as transferências
+        while has_more:
+            if last_id:
+                query_params["starting_after"] = last_id
+                
+            # Obter transferências
+            transfer_list = stripe.Transfer.list(**query_params)
+            transfers.extend(transfer_list.data)
+            
+            has_more = transfer_list.has_more
+            if transfer_list.data:
+                last_id = transfer_list.data[-1].id
+            else:
+                has_more = False
+        
+        # Agrupar transferências por conta de destino (estilista)
+        stylist_earnings = {}
+        for transfer in transfers:
+            destination = transfer.destination
+            if destination not in stylist_earnings:
+                stylist_earnings[destination] = {
+                    "account_id": destination,
+                    "total_earnings": 0,
+                    "transfer_count": 0,
+                    "name": None
+                }
+            
+            stylist_earnings[destination]["total_earnings"] += transfer.amount
+            stylist_earnings[destination]["transfer_count"] += 1
+        
+        # Obter informações adicionais dos estilistas do Supabase
+        stylist_accounts = list(stylist_earnings.keys())
+        
+        # Consultar informações de usuário para cada estilista
+        for account_id in stylist_accounts:
+            try:
+                user_data_url = f"{SUPABASE_URL}/rest/v1/User?stripe_id=eq.{account_id}"
+                response = requests.get(user_data_url, headers=SUPABASE_HEADERS)
+                
+                if response.status_code == 200 and response.json():
+                    user_info = response.json()[0]
+                    stylist_earnings[account_id]["name"] = user_info.get("name", "Unknown")
+                    stylist_earnings[account_id]["id"] = user_info.get("id")
+                    stylist_earnings[account_id]["avatar"] = user_info.get("avatar")
+                else:
+                    # Tentar obter dados direto do Stripe como fallback
+                    account = stripe.Account.retrieve(account_id)
+                    stylist_earnings[account_id]["name"] = account.business_profile.name if hasattr(account, 'business_profile') else "Unknown"
+            except Exception as e:
+                logger.error(f"❌ Erro ao obter informações do estilista {account_id}: {str(e)}")
+        
+        # Ordenar por faturamento e limitar ao número solicitado
+        top_stylists = sorted(
+            stylist_earnings.values(), 
+            key=lambda x: x["total_earnings"], 
+            reverse=True
+        )[:limit]
+        
+        return top_stylists
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao obter top estilistas: {str(e)}")
+        return []
+
+def get_platform_metrics() -> Dict[str, Any]:
+    """Obtém métricas gerais da plataforma"""
+    try:
+        # Obter número total de usuários
+        users_url = f"{SUPABASE_URL}/rest/v1/User?select=count"
+        users_response = requests.get(
+            users_url, 
+            headers={**SUPABASE_HEADERS, "Prefer": "count=exact"}
+        )
+        
+        total_users = 0
+        if users_response.status_code == 200:
+            count_header = users_response.headers.get("Content-Range", "")
+            if count_header:
+                total_users = int(count_header.split("/")[1])
+        
+        # Obter número total de estilistas
+        stylists_url = f"{SUPABASE_URL}/rest/v1/User?is_stylist=eq.true&select=count"
+        stylists_response = requests.get(
+            stylists_url, 
+            headers={**SUPABASE_HEADERS, "Prefer": "count=exact"}
+        )
+        
+        total_stylists = 0
+        if stylists_response.status_code == 200:
+            count_header = stylists_response.headers.get("Content-Range", "")
+            if count_header:
+                total_stylists = int(count_header.split("/")[1])
+        
+        # Obter número total de assinaturas ativas
+        subscriptions_url = f"{SUPABASE_URL}/rest/v1/Subscriptions?active=eq.true&select=count"
+        subscriptions_response = requests.get(
+            subscriptions_url, 
+            headers={**SUPABASE_HEADERS, "Prefer": "count=exact"}
+        )
+        
+        total_active_subscriptions = 0
+        if subscriptions_response.status_code == 200:
+            count_header = subscriptions_response.headers.get("Content-Range", "")
+            if count_header:
+                total_active_subscriptions = int(count_header.split("/")[1])
+        
+        # Calcular taxa de conversão (assinaturas ativas / usuários totais)
+        conversion_rate = (total_active_subscriptions / total_users) * 100 if total_users > 0 else 0
+        
+        # Obter número total de consultas
+        schedules_url = f"{SUPABASE_URL}/rest/v1/schedules?select=count"
+        schedules_response = requests.get(
+            schedules_url, 
+            headers={**SUPABASE_HEADERS, "Prefer": "count=exact"}
+        )
+        
+        total_consultations = 0
+        if schedules_response.status_code == 200:
+            count_header = schedules_response.headers.get("Content-Range", "")
+            if count_header:
+                total_consultations = int(count_header.split("/")[1])
+        
+        return {
+            "total_users": total_users,
+            "total_stylists": total_stylists,
+            "total_active_subscriptions": total_active_subscriptions,
+            "conversion_rate": round(conversion_rate, 2),
+            "total_consultations": total_consultations
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao obter métricas da plataforma: {str(e)}")
+        return {
+            "total_users": 0,
+            "total_stylists": 0,
+            "total_active_subscriptions": 0,
+            "conversion_rate": 0,
+            "total_consultations": 0,
+            "error": str(e)
+        }
+
+@router.get("/admin/dashboard")
+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"),
+    top_stylists_limit: int = Query(10, ge=1, le=50)
+):
+    """
+    Endpoint para dashboard administrativo com métricas de faturamento
+    e divisão entre app e estilistas
+    """
+    try:
+        # Verificar se é um administrador
+        user_id = verify_admin_token(user_token)
+        
+        # Definir intervalo de datas baseado no período solicitado
+        ny_timezone = pytz.timezone('America/New_York')
+        now_ny = datetime.now(ny_timezone)
+        
+        start_timestamp = None
+        end_timestamp = int(now_ny.timestamp())
+        
+        if period == "last_month":
+            start_date = now_ny - relativedelta(months=1)
+            start_timestamp = int(start_date.timestamp())
+        elif period == "last_year":
+            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)
+        
+        # Calcular divisão de receita entre app e estilistas
+        revenue_share = get_app_revenue_share(
+            revenue_data["successful_revenue"],
+            transfer_data["total_transferred_to_stylists"]
+        )
+        
+        # Obter detalhamento mensal dos últimos 12 meses
+        monthly_revenue = get_monthly_revenue_breakdown(12)
+        
+        # Obter top estilistas por faturamento
+        top_stylists = get_top_earning_stylists(top_stylists_limit, start_timestamp, end_timestamp)
+        
+        # Obter métricas gerais da plataforma
+        platform_metrics = get_platform_metrics()
+        
+        return {
+            "total_revenue": revenue_data["successful_revenue"],
+            "failed_revenue": revenue_data["failed_revenue"],
+            "total_transferred_to_stylists": transfer_data["total_transferred_to_stylists"],
+            "app_revenue": revenue_share["app_revenue"],
+            "app_revenue_percentage": revenue_share["app_percentage"],
+            "stylists_revenue_percentage": revenue_share["stylists_percentage"],
+            "payment_count": revenue_data["payment_count"],
+            "transfer_count": transfer_data["transfer_count"],
+            "currency": "BRL",
+            "period": period,
+            "monthly_revenue": monthly_revenue,
+            "top_earning_stylists": top_stylists,
+            "platform_metrics": platform_metrics
+        }
+        
+    except HTTPException as he:
+        raise he
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao gerar dashboard administrativo: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/admin/dashboard/custom_period")
+def get_custom_period_dashboard(
+    date_range: DateRangeRequest,
+    user_token: str = Header(None, alias="User-key"),
+    top_stylists_limit: int = Query(10, ge=1, le=50)
+):
+    """
+    Endpoint para dashboard administrativo com métricas de faturamento
+    para um período personalizado
+    """
+    try:
+        # Verificar se é um administrador
+        user_id = verify_admin_token(user_token)
+        
+        # Converter datas para timestamps
+        start_timestamp = None
+        end_timestamp = None
+        
+        if date_range.start_date:
+            start_date = datetime.fromisoformat(date_range.start_date)
+            start_timestamp = int(start_date.timestamp())
+        
+        if date_range.end_date:
+            # Se temos apenas a data, queremos incluir o dia inteiro
+            end_date = datetime.fromisoformat(date_range.end_date)
+            end_date = datetime(end_date.year, end_date.month, end_date.day, 23, 59, 59)
+            end_timestamp = int(end_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)
+        
+        # Calcular divisão de receita entre app e estilistas
+        revenue_share = get_app_revenue_share(
+            revenue_data["successful_revenue"],
+            transfer_data["total_transferred_to_stylists"]
+        )
+        
+        # Obter top estilistas por faturamento
+        top_stylists = get_top_earning_stylists(top_stylists_limit, start_timestamp, end_timestamp)
+        
+        return {
+            "total_revenue": revenue_data["successful_revenue"],
+            "failed_revenue": revenue_data["failed_revenue"],
+            "total_transferred_to_stylists": transfer_data["total_transferred_to_stylists"],
+            "app_revenue": revenue_share["app_revenue"],
+            "app_revenue_percentage": revenue_share["app_percentage"],
+            "stylists_revenue_percentage": revenue_share["stylists_percentage"],
+            "payment_count": revenue_data["payment_count"],
+            "transfer_count": transfer_data["transfer_count"],
+            "currency": "BRL",
+            "period": {
+                "start_date": date_range.start_date,
+                "end_date": date_range.end_date
+            },
+            "top_earning_stylists": top_stylists
+        }
+        
+    except HTTPException as he:
+        raise he
+        
+    except Exception as e:
+        logger.error(f"❌ Erro ao gerar dashboard para período personalizado: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))