Update app.py

app.py

@@ -1,19 +1,19 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Query
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pathlib import Path
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import asyncio
-import ccxt
 import random
+import ccxt
 
 app = FastAPI(title="Crypto Data Source API")
 
 # ------------------------------
-# CORS middleware
+# CORS
 # ------------------------------
 app.add_middleware(
     CORSMiddleware,
@@ -29,38 +29,101 @@ app.add_middleware(
 BASE_DIR = Path(__file__).resolve().parent
 INDEX_FILE = BASE_DIR / "index.html"
 STATIC_DIR = BASE_DIR / "static"
-
 START_TIME = datetime.now(timezone.utc)
 
-# اگر static directory وجود دارد، برای فایل‌های استاتیک mount می‌کنیم
 if STATIC_DIR.exists() and STATIC_DIR.is_dir():
     app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 
+# ------------------------------
+# داده‌های نمونه برای Providerها / Keys
+# ------------------------------
+BASE_PROVIDERS: List[Dict[str, Any]] = [
+    {"name": "Binance Spot", "category": "market_data", "has_key": False, "priority": 5},
+    {"name": "Binance Futures", "category": "market_data", "has_key": False, "priority": 4},
+    {"name": "CoinGecko", "category": "market_data", "has_key": False, "priority": 4},
+    {"name": "CoinPaprika", "category": "market_data", "has_key": False, "priority": 3},
+    {"name": "Etherscan", "category": "blockchain", "has_key": True, "priority": 4},
+    {"name": "BscScan", "category": "blockchain", "has_key": True, "priority": 3},
+    {"name": "TronScan", "category": "blockchain", "has_key": False, "priority": 3},
+    {"name": "CryptoPanic", "category": "news", "has_key": False, "priority": 2},
+]
+
+CUSTOM_APIS: List[Dict[str, Any]] = []
+
+API_KEYS: List[Dict[str, str]] = [
+    {"provider": "Binance", "key_masked": "BINANCE-****-****-1234"},
+    {"provider": "Etherscan", "key_masked": "ETHERSCAN-****-****-ABCD"},
+    {"provider": "BscScan", "key_masked": "BSCSCAN-****-****-5678"},
+]
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+# ------------------------------
+# کمکی: ساخت snapshot از provider ها
+# ------------------------------
+def _generate_providers_snapshot() -> List[Dict[str, Any]]:
+    now = _utc_now()
+    providers: List[Dict[str, Any]] = []
+
+    all_providers = BASE_PROVIDERS + CUSTOM_APIS
+
+    for base in all_providers:
+        # response time between 80ms and 900ms
+        rt = random.randint(80, 900)
+        # staleness between 0 and 30 minutes
+        minutes_ago = random.uniform(0, 30)
+        last_fetch_dt = now - timedelta(minutes=minutes_ago)
+
+        # تعیین وضعیت بر اساس response time
+        if rt < 300:
+            status = "online"
+        elif rt < 700:
+            status = "degraded"
+        else:
+            status = "offline"
+
+        providers.append(
+            {
+                "name": base["name"],
+                "category": base["category"],
+                "status": status,
+                "response_time_ms": rt,
+                "last_fetch": last_fetch_dt.isoformat(),
+                "has_key": bool(base.get("has_key", False)),
+                "priority": int(base.get("priority", 3)),
+            }
+        )
+
+    return providers
+
 
 # ------------------------------
-# API های پایه (health / markets / ticker)
+# APIهای پایه ccxt
 # ------------------------------
 @app.get("/api/health")
 async def health_check():
-    """ساده‌ترین health endpoint برای چک وضعیت و نسخه ccxt"""
+    """Health ساده برای تست سرویس."""
     return {
         "status": "online",
         "version": "1.0.0",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "timestamp": _utc_now().isoformat(),
         "ccxt_version": ccxt.__version__,
     }
 
 
 @app.get("/api/markets")
 async def get_markets():
-    """نمونه‌ی گرفتن مارکت‌ها از بایننس (با ccxt)"""
+    """نمونه گرفتن لیست مارکت‌ها از Binance."""
     try:
         exchange = ccxt.binance()
         markets = exchange.load_markets()
         return {
             "success": True,
             "total_markets": len(markets),
-            "markets": list(markets.keys())[:50],  # فقط ۵۰ تای اول
+            "markets": list(markets.keys())[:50],
         }
     except Exception as e:  # noqa: BLE001
         return {"success": False, "error": str(e)}
@@ -68,7 +131,7 @@ async def get_markets():
 
 @app.get("/api/ticker/{symbol}")
 async def get_ticker(symbol: str):
-    """نمونه‌ی گرفتن تیکر برای یک symbol مشخص (مثلاً BTC/USDT)"""
+    """نمونه گرفتن تیکر از Binance (مثال: BTC/USDT)."""
     try:
         exchange = ccxt.binance()
         ticker = exchange.fetch_ticker(symbol)
@@ -78,141 +141,302 @@ async def get_ticker(symbol: str):
 
 
 # ------------------------------
-# API هایی که فرانت انتظار دارد
-# /api/status
-# /api/categories
-# /api/charts/health-history
-# /api/charts/compliance
+# /api/status – مطابق انتظار فرانت
 # ------------------------------
-
 @app.get("/api/status")
 async def api_status():
-    """
-    وضعیت کلی سیستم برای داشبورد.
-    فرانت معمولاً از این برای کارت‌های Status / Uptime / Errors استفاده می‌کند.
-    """
-    now = datetime.now(timezone.utc)
+    providers = _generate_providers_snapshot()
+    total = len(providers)
+    online = sum(1 for p in providers if p["status"] == "online")
+    offline = sum(1 for p in providers if p["status"] == "offline")
+    degraded = sum(1 for p in providers if p["status"] == "degraded")
+
+    avg_response = (
+        sum(p["response_time_ms"] for p in providers) / total if total else 0
+    )
+
+    # متریک‌های ساده
+    total_requests_hour = random.randint(200, 1200)
+    total_failures_hour = random.randint(0, max(20, degraded * 2 + offline * 5))
+
+    if offline == 0 and degraded <= max(1, total // 4):
+        system_health = "healthy"
+    else:
+        system_health = "degraded"
+
+    now = _utc_now()
     uptime_seconds = (now - START_TIME).total_seconds()
-    uptime_human = str(timedelta(seconds=int(uptime_seconds)))
 
-    # این مقادیر می‌تونه بعداً به داده‌های واقعی متصل شود
     return {
         "status": "online",
         "service": "crypto-data-source",
         "version": "1.0.0",
         "timestamp": now.isoformat(),
         "uptime_seconds": uptime_seconds,
-        "uptime_human": uptime_human,
-        "components": {
-            "api": "healthy",
-            "market_data": "healthy",
-            "websocket": "healthy",
-            "database": "ok",
-        },
-        "metrics": {
-            "requests_per_minute": random.randint(5, 25),
-            "error_rate_percent": round(random.uniform(0.0, 2.5), 2),
-            "avg_latency_ms": random.randint(100, 400),
-        },
+        "total_providers": total,
+        "online": online,
+        "offline": offline,
+        "degraded": degraded,
+        "avg_response_time_ms": int(avg_response),
+        "system_health": system_health,
+        "total_requests_hour": total_requests_hour,
+        "total_failures_hour": total_failures_hour,
     }
 
 
-@app.get("/api/categories")
-async def api_categories():
-    """
-    لیست دسته‌بندی‌هایی که داشبورد می‌خواهد نشان دهد
-    (برای فیلترها / تب‌ها / کارت‌ها).
+# ------------------------------
+# /api/providers – لیست Providerها
+# ------------------------------
+@app.get("/api/providers")
+async def api_providers():
     """
-    categories: List[Dict[str, Any]] = [
-        {
-            "id": "health",
-            "name": "System Health",
-            "description": "Overall status of all data providers and services.",
-            "enabled": True,
-        },
-        {
-            "id": "market_data",
-            "name": "Market Data",
-            "description": "Spot & derivatives price feeds from crypto exchanges.",
-            "enabled": True,
-        },
-        {
-            "id": "compliance",
-            "name": "Compliance & Limits",
-            "description": "Rate limits, API key usage and provider compliance checks.",
-            "enabled": True,
-        },
+    خروجی: آرایه‌ای از provider ها
+    [
+      {
+        name, category, status, response_time_ms,
+        last_fetch, has_key, priority
+      }, ...
     ]
-    return {"success": True, "categories": categories}
+    """
+    return _generate_providers_snapshot()
 
 
-def _generate_time_series_points(
-    hours: int,
-    base_value: float,
-    noise: float,
-    kind: str = "score",
-) -> List[Dict[str, Any]]:
+# ------------------------------
+# /api/categories – خلاصه per category
+# ------------------------------
+@app.get("/api/categories")
+async def api_categories():
     """
-    ساخت یک سری زمانی ساده برای نمودارها.
+    فرانت انتظار دارد آرایه مستقیم دریافت کند، نه شیء.
+
+    هر category: name, status, online_sources, total_sources, avg_response_time_ms
     """
-    now = datetime.now(timezone.utc)
-    points: List[Dict[str, Any]] = []
-    total_points = max(12, hours)  # حداقل ۱۲ نقطه
-
-    for i in range(total_points):
-        ts = now - timedelta(hours=hours * (total_points - 1 - i) / total_points)
-        value = base_value + random.uniform(-noise, noise)
-        value = max(0.0, min(1.0, value))  # clamp بین ۰ و ۱
-
-        if kind == "score":
-            point = {
-                "timestamp": ts.isoformat(),
-                "score": round(value, 3),
-                "status": "ok" if value > 0.6 else "degraded",
-            }
-        else:  # compliance
-            point = {
-                "timestamp": ts.isoformat(),
-                "compliance_ratio": round(value, 3),
-                "violations": random.randint(0, 3) if value < 0.8 else 0,
+    providers = _generate_providers_snapshot()
+    by_cat: Dict[str, List[Dict[str, Any]]] = {}
+    for p in providers:
+        by_cat.setdefault(p["category"], []).append(p)
+
+    categories: List[Dict[str, Any]] = []
+    for category, items in by_cat.items():
+        total_sources = len(items)
+        online_sources = sum(1 for i in items if i["status"] == "online")
+        avg_rt = (
+            sum(i["response_time_ms"] for i in items) / total_sources
+            if total_sources
+            else 0
+        )
+        status = "online" if online_sources > 0 else "offline"
+        categories.append(
+            {
+                "name": category,
+                "status": status,
+                "online_sources": online_sources,
+                "total_sources": total_sources,
+                "avg_response_time_ms": int(avg_rt),
             }
-        points.append(point)
+        )
 
-    return points
+    return categories
 
 
+# ------------------------------
+# /api/charts/health-history – برای نمودار سلامت
+# ------------------------------
 @app.get("/api/charts/health-history")
 async def api_chart_health_history(hours: int = 24):
     """
-    داده‌های نمودار سری زمانی برای سلامت سیستم در X ساعت گذشته.
+    فرانت انتظار دارد:
+      { timestamps: [...], success_rate: [...] }  // success_rate بین 0 تا 100
     """
-    points = _generate_time_series_points(hours=hours, base_value=0.9, noise=0.1, kind="score")
-    return {
-        "success": True,
-        "range_hours": hours,
-        "series": points,
-    }
+    now = _utc_now()
+    points = max(12, hours)
+    timestamps: List[str] = []
+    success_rate: List[float] = []
+
+    for i in range(points):
+        ts = now - timedelta(hours=(hours * (points - 1 - i) / points))
+        base = 90  # درصد پایه
+        noise = random.uniform(-10, 5)
+        value = max(50.0, min(100.0, base + noise))
+        timestamps.append(ts.isoformat())
+        success_rate.append(round(value, 2))
 
+    return {"timestamps": timestamps, "success_rate": success_rate}
 
+
+# ------------------------------
+# /api/charts/compliance – برای نمودار Bar
+# ------------------------------
 @app.get("/api/charts/compliance")
 async def api_chart_compliance(days: int = 7):
     """
-    داده‌های نمودار سری زمانی برای وضعیت کامپلاینس در X روز گذشته.
+    فرانت انتظار دارد:
+      { dates: [...], compliance_percentage: [...] }  // 0..100
     """
-    # تبدیل days به hours برای ساخت سری
-    hours = days * 24
-    points = _generate_time_series_points(hours=hours, base_value=0.85, noise=0.15, kind="compliance")
-    return {
-        "success": True,
-        "range_days": days,
-        "series": points,
-    }
+    today = _utc_now().date()
+    dates: List[str] = []
+    compliance_percentage: List[float] = []
+
+    for i in range(days):
+        d = today - timedelta(days=(days - 1 - i))
+        base = 88
+        noise = random.uniform(-8, 5)
+        value = max(60.0, min(100.0, base + noise))
+        dates.append(d.isoformat())
+        compliance_percentage.append(round(value, 2))
+
+    return {"dates": dates, "compliance_percentage": compliance_percentage}
+
+
+# ------------------------------
+# /api/freshness – جدول تازگی داده‌ها
+# ------------------------------
+@app.get("/api/freshness")
+async def api_freshness():
+    """
+    فرانت انتظار دارد آرایه‌ای از آیتم‌ها:
+      provider, category, fetch_time, staleness_minutes, ttl_minutes, status
+    """
+    providers = _generate_providers_snapshot()
+    items: List[Dict[str, Any]] = []
+
+    for p in providers:
+        fetch_time = datetime.fromisoformat(p["last_fetch"])
+        staleness_minutes = (_utc_now() - fetch_time).total_seconds() / 60.0
+        ttl_minutes = 30
+        status = "fresh" if staleness_minutes <= ttl_minutes else "stale"
+        items.append(
+            {
+                "provider": p["name"],
+                "category": p["category"],
+                "fetch_time": fetch_time.isoformat(),
+                "staleness_minutes": round(staleness_minutes, 1),
+                "ttl_minutes": ttl_minutes,
+                "status": status,
+            }
+        )
+
+    return items
 
 
 # ------------------------------
-# WebSocket /ws/live – برای داشبورد زنده
+# /api/logs – لیست لاگ‌ها
 # ------------------------------
+@app.get("/api/logs")
+async def api_logs():
+    """
+    فرمت آیتم لاگ:
+      timestamp, provider, endpoint, status, http_code, response_time_ms, error_message?
+    """
+    providers = _generate_providers_snapshot()
+    logs: List[Dict[str, Any]] = []
+    now = _utc_now()
+
+    for p in providers:
+        # یک لاگ موفق
+        logs.append(
+            {
+                "timestamp": (now - timedelta(minutes=random.randint(0, 60))).isoformat(),
+                "provider": p["name"],
+                "endpoint": "/api/status",
+                "status": "success",
+                "http_code": 200,
+                "response_time_ms": p["response_time_ms"],
+                "error_message": None,
+            }
+        )
 
+        # احتمالاً یک لاگ خطا
+        if p["status"] != "online" and random.random() < 0.5:
+            logs.append(
+                {
+                    "timestamp": (
+                        now - timedelta(minutes=random.randint(0, 60))
+                    ).isoformat(),
+                    "provider": p["name"],
+                    "endpoint": "/api/markets",
+                    "status": "error",
+                    "http_code": random.choice([429, 500, 504]),
+                    "response_time_ms": random.randint(500, 2000),
+                    "error_message": "Upstream error or timeout",
+                }
+            )
+
+    # مرتب‌سازی نزولی بر اساس زمان
+    logs.sort(key=lambda x: x["timestamp"], reverse=True)
+    return logs
+
+
+# ------------------------------
+# /api/failures – خطاهای اخیر
+# ------------------------------
+@app.get("/api/failures")
+async def api_failures():
+    """
+    خروجی:
+      { recent_failures: [ {timestamp, provider, error_type, error_message, retry_attempted}, ... ] }
+    """
+    logs = await api_logs()
+    failures: List[Dict[str, Any]] = []
+
+    for log in logs:
+        if log["status"] == "error":
+            failures.append(
+                {
+                    "timestamp": log["timestamp"],
+                    "provider": log["provider"],
+                    "error_type": "HTTP " + str(log["http_code"]),
+                    "error_message": log["error_message"] or "Unknown error",
+                    "retry_attempted": random.random() < 0.6,
+                }
+            )
+
+    return {"recent_failures": failures}
+
+
+# ------------------------------
+# /api/config/keys – نمایش کلیدها
+# ------------------------------
+@app.get("/api/config/keys")
+async def api_config_keys():
+    """
+    فرانت انتظار دارد آرایه‌ای از آیتم‌ها:
+      provider, key_masked
+    """
+    return API_KEYS
+
+
+# ------------------------------
+# /api/custom/add – افزودن API سفارشی
+# ------------------------------
+@app.post("/api/custom/add")
+async def api_custom_add(
+    name: str = Query(...),
+    url: str = Query(...),
+    category: str = Query(...),
+    test_field: Optional[str] = Query(None),
+):
+    """
+    از روی فرانت با POST و query string صدا زده می‌شود.
+    در این نسخه، API را فقط در حافظه (CUSTOM_APIS) نگه می‌داریم.
+    """
+    CUSTOM_APIS.append(
+        {
+            "name": name,
+            "url": url,
+            "category": category or "other",
+            "test_field": test_field,
+            "has_key": False,
+            "priority": 3,
+        }
+    )
+
+    return {"success": True, "message": "Custom API added successfully"}
+
+
+# ------------------------------
+# WebSocket /ws/live – برای داشبورد
+# ------------------------------
 class LiveConnections:
     def __init__(self) -> None:
         self.active: List[WebSocket] = []
@@ -230,7 +454,6 @@ class LiveConnections:
             try:
                 await ws.send_json(message)
             except Exception:
-                # اگر ارسال به هر دلیلی fail شد، آن اتصال را حذف می‌کنیم
                 self.disconnect(ws)
 
 
@@ -240,29 +463,26 @@ live_manager = LiveConnections()
 @app.websocket("/ws/live")
 async def websocket_live(websocket: WebSocket):
     """
-    WebSocket ساده برای فرانت که هر چند ثانیه یک بار
-    وضعیت/متریک‌های زنده را ارسال می‌کند.
+    WebSocket ساده برای ارسال متریک‌های زنده.
     """
     await live_manager.connect(websocket)
     try:
-        # پیام خوشامد
         await websocket.send_json(
             {
                 "type": "welcome",
                 "service": "crypto-data-source",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": _utc_now().isoformat(),
             }
         )
 
         while True:
-            # اینجا می‌تونی بعداً داده واقعی مثل health providers, latency و ... بفرستی
             payload = {
                 "type": "live_metrics",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": _utc_now().isoformat(),
                 "metrics": {
                     "cpu_usage": random.randint(5, 40),
-                    "memory_usage": random.randint(20, 70),
-                    "active_requests": random.randint(1, 20),
+                    "memory_usage": random.randint(20, 75),
+                    "active_requests": random.randint(1, 30),
                     "error_rate_percent": round(random.uniform(0.0, 3.0), 2),
                 },
             }
@@ -275,21 +495,17 @@ async def websocket_live(websocket: WebSocket):
 
 
 # ------------------------------
-# Frontend routing (بدون پوشه frontend/)
+# سرو کردن index.html و SPA routing
 # ------------------------------
-
 @app.get("/")
 async def root():
-    """
-    اگر index.html کنار همین فایل باشد، همان را برمی‌گرداند.
-    در غیر این صورت، یک پیام JSON برمی‌گرداند.
-    """
+    """اگر index.html کنار فایل باشد، همان را می‌فرستیم، در غیر این صورت JSON ساده."""
     if INDEX_FILE.exists():
         return FileResponse(INDEX_FILE)
     return JSONResponse(
         {
             "message": "No frontend index.html found in project root.",
-            "hint": "Place an index.html file next to this Python file or use /docs for the API.",
+            "hint": "Place index.html next to this Python file or use /docs for the API.",
             "api_docs": "/docs",
         }
     )
@@ -298,29 +514,25 @@ async def root():
 @app.get("/{full_path:path}")
 async def spa_catch_all(full_path: str):
     """
-    برای روتینگ سمت فرانت (SPA):
-    - اگر مسیر با api/ شروع شود و endpointی وجود نداشته باشد، 404 منطقی می‌دهیم
-    - اگر فایلی با همان مسیر داخل static وجود داشته باشد، همان فایل سرو می‌شود
-    - در غیر این صورت، اگر index.html وجود داشته باشد، همان برگردانده می‌شود
+    برای روتینگ سمت فرانت:
+      - مسیرهای /api/* اگر endpoint نداشته باشند: 404 JSON
+      - بقیه مسیرها: index.html (اگر باشد) یا 404
     """
-    # اگر مسیر API است، ولی endpoint تعریف نشده:
     if full_path.startswith("api/"):
         return JSONResponse(
             {"error": "API endpoint not found", "path": full_path},
             status_code=404,
         )
 
-    # اگر فایل static موجود است
+    # اگر فایل static با همین مسیر وجود دارد
     if STATIC_DIR.exists():
         candidate_file = STATIC_DIR / full_path
         if candidate_file.is_file():
             return FileResponse(candidate_file)
 
-    # در نهایت، اگر index.html داریم، به عنوان SPA برمی‌گردانیم
     if INDEX_FILE.exists():
         return FileResponse(INDEX_FILE)
 
-    # هیچ چیز پیدا نشد:
     return JSONResponse(
         {"error": "No frontend available for this path.", "path": full_path},
         status_code=404,
@@ -328,7 +540,7 @@ async def spa_catch_all(full_path: str):
 
 
 # ------------------------------
-# Local run
+# اجرای لوکال
 # ------------------------------
 if __name__ == "__main__":
     import uvicorn