319 lines
9.9 KiB
Python
319 lines
9.9 KiB
Python
"""
|
|
Platform Analytics API Routes
|
|
|
|
Provides endpoints for retrieving analytics data from connected platforms.
|
|
"""
|
|
|
|
from fastapi import APIRouter, HTTPException, Depends, Query
|
|
from typing import Dict, Any, List, Optional
|
|
from loguru import logger
|
|
from pydantic import BaseModel
|
|
|
|
from services.analytics import PlatformAnalyticsService
|
|
from middleware.auth_middleware import get_current_user
|
|
|
|
router = APIRouter(prefix="/api/analytics", tags=["Platform Analytics"])
|
|
|
|
# Initialize analytics service
|
|
analytics_service = PlatformAnalyticsService()
|
|
|
|
|
|
class AnalyticsRequest(BaseModel):
|
|
"""Request model for analytics data"""
|
|
platforms: Optional[List[str]] = None
|
|
date_range: Optional[Dict[str, str]] = None
|
|
|
|
|
|
class AnalyticsResponse(BaseModel):
|
|
"""Response model for analytics data"""
|
|
success: bool
|
|
data: Dict[str, Any]
|
|
summary: Dict[str, Any]
|
|
error: Optional[str] = None
|
|
|
|
|
|
@router.get("/platforms")
|
|
async def get_platform_connection_status(current_user: dict = Depends(get_current_user)) -> Dict[str, Any]:
|
|
"""
|
|
Get connection status for all platforms
|
|
|
|
Args:
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
Connection status for each platform
|
|
"""
|
|
try:
|
|
user_id = current_user.get('id')
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
logger.info(f"Getting platform connection status for user: {user_id}")
|
|
|
|
status = await analytics_service.get_platform_connection_status(user_id)
|
|
|
|
return {
|
|
"success": True,
|
|
"platforms": status,
|
|
"total_connected": sum(1 for p in status.values() if p.get('connected', False))
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to get platform connection status: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get("/data")
|
|
async def get_analytics_data(
|
|
platforms: Optional[str] = Query(None, description="Comma-separated list of platforms (gsc,wix,wordpress)"),
|
|
current_user: dict = Depends(get_current_user)
|
|
) -> AnalyticsResponse:
|
|
"""
|
|
Get analytics data from connected platforms
|
|
|
|
Args:
|
|
platforms: Comma-separated list of platforms to get data from
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
Analytics data from specified platforms
|
|
"""
|
|
try:
|
|
user_id = current_user.get('id')
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
# Parse platforms parameter
|
|
platform_list = None
|
|
if platforms:
|
|
platform_list = [p.strip() for p in platforms.split(',') if p.strip()]
|
|
|
|
logger.info(f"Getting analytics data for user: {user_id}, platforms: {platform_list}")
|
|
|
|
# Get analytics data
|
|
analytics_data = await analytics_service.get_comprehensive_analytics(user_id, platform_list)
|
|
|
|
# Generate summary
|
|
summary = analytics_service.get_analytics_summary(analytics_data)
|
|
|
|
# Convert AnalyticsData objects to dictionaries
|
|
data_dict = {}
|
|
for platform, data in analytics_data.items():
|
|
data_dict[platform] = {
|
|
'platform': data.platform,
|
|
'metrics': data.metrics,
|
|
'date_range': data.date_range,
|
|
'last_updated': data.last_updated,
|
|
'status': data.status,
|
|
'error_message': data.error_message
|
|
}
|
|
|
|
return AnalyticsResponse(
|
|
success=True,
|
|
data=data_dict,
|
|
summary=summary,
|
|
error=None
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to get analytics data: {e}")
|
|
return AnalyticsResponse(
|
|
success=False,
|
|
data={},
|
|
summary={},
|
|
error=str(e)
|
|
)
|
|
|
|
|
|
@router.post("/data")
|
|
async def get_analytics_data_post(
|
|
request: AnalyticsRequest,
|
|
current_user: dict = Depends(get_current_user)
|
|
) -> AnalyticsResponse:
|
|
"""
|
|
Get analytics data from connected platforms (POST version)
|
|
|
|
Args:
|
|
request: Analytics request with platforms and date range
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
Analytics data from specified platforms
|
|
"""
|
|
try:
|
|
user_id = current_user.get('id')
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
logger.info(f"Getting analytics data for user: {user_id}, platforms: {request.platforms}")
|
|
|
|
# Get analytics data
|
|
analytics_data = await analytics_service.get_comprehensive_analytics(user_id, request.platforms)
|
|
|
|
# Generate summary
|
|
summary = analytics_service.get_analytics_summary(analytics_data)
|
|
|
|
# Convert AnalyticsData objects to dictionaries
|
|
data_dict = {}
|
|
for platform, data in analytics_data.items():
|
|
data_dict[platform] = {
|
|
'platform': data.platform,
|
|
'metrics': data.metrics,
|
|
'date_range': data.date_range,
|
|
'last_updated': data.last_updated,
|
|
'status': data.status,
|
|
'error_message': data.error_message
|
|
}
|
|
|
|
return AnalyticsResponse(
|
|
success=True,
|
|
data=data_dict,
|
|
summary=summary,
|
|
error=None
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to get analytics data: {e}")
|
|
return AnalyticsResponse(
|
|
success=False,
|
|
data={},
|
|
summary={},
|
|
error=str(e)
|
|
)
|
|
|
|
|
|
@router.get("/gsc")
|
|
async def get_gsc_analytics(
|
|
current_user: dict = Depends(get_current_user)
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Get Google Search Console analytics data specifically
|
|
|
|
Args:
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
GSC analytics data
|
|
"""
|
|
try:
|
|
user_id = current_user.get('id')
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
logger.info(f"Getting GSC analytics for user: {user_id}")
|
|
|
|
# Get GSC analytics
|
|
gsc_data = await analytics_service._get_gsc_analytics(user_id)
|
|
|
|
return {
|
|
"success": gsc_data.status == 'success',
|
|
"platform": gsc_data.platform,
|
|
"metrics": gsc_data.metrics,
|
|
"date_range": gsc_data.date_range,
|
|
"last_updated": gsc_data.last_updated,
|
|
"status": gsc_data.status,
|
|
"error": gsc_data.error_message
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to get GSC analytics: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get("/summary")
|
|
async def get_analytics_summary(current_user: dict = Depends(get_current_user)) -> Dict[str, Any]:
|
|
"""
|
|
Get a summary of analytics data across all connected platforms
|
|
|
|
Args:
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
Analytics summary
|
|
"""
|
|
try:
|
|
user_id = current_user.get('id')
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
logger.info(f"Getting analytics summary for user: {user_id}")
|
|
|
|
# Get analytics data from all platforms
|
|
analytics_data = await analytics_service.get_comprehensive_analytics(user_id)
|
|
|
|
# Generate summary
|
|
summary = analytics_service.get_analytics_summary(analytics_data)
|
|
|
|
return {
|
|
"success": True,
|
|
"summary": summary,
|
|
"platforms_connected": summary['connected_platforms'],
|
|
"platforms_total": summary['total_platforms']
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to get analytics summary: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get("/cache/test")
|
|
async def test_cache_endpoint(current_user: dict = Depends(get_current_user)) -> Dict[str, Any]:
|
|
"""
|
|
Test endpoint to verify cache routes are working
|
|
"""
|
|
return {
|
|
"success": True,
|
|
"message": "Cache endpoint is working",
|
|
"user_id": current_user.get('id'),
|
|
"timestamp": datetime.now().isoformat()
|
|
}
|
|
|
|
|
|
@router.post("/cache/clear")
|
|
async def clear_analytics_cache(
|
|
platform: Optional[str] = Query(None, description="Specific platform to clear cache for (optional)"),
|
|
current_user: dict = Depends(get_current_user)
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Clear analytics cache for a user
|
|
|
|
Args:
|
|
platform: Specific platform to clear cache for (optional, clears all if None)
|
|
current_user: Current authenticated user
|
|
|
|
Returns:
|
|
Cache clearing result
|
|
"""
|
|
try:
|
|
from datetime import datetime
|
|
user_id = current_user.get('id')
|
|
logger.info(f"Cache clear request received for user {user_id}, platform: {platform}")
|
|
|
|
if not user_id:
|
|
raise HTTPException(status_code=400, detail="User ID not found")
|
|
|
|
if platform:
|
|
# Clear cache for specific platform
|
|
analytics_service.invalidate_platform_cache(user_id, platform)
|
|
message = f"Cleared cache for {platform}"
|
|
else:
|
|
# Clear all cache for user
|
|
analytics_service.invalidate_user_cache(user_id)
|
|
message = "Cleared all analytics cache"
|
|
|
|
logger.info(f"Cache cleared for user {user_id}: {message}")
|
|
|
|
return {
|
|
"success": True,
|
|
"user_id": user_id,
|
|
"platform": platform,
|
|
"message": message,
|
|
"timestamp": datetime.now().isoformat()
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error clearing cache: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|