Update app/api/dashboard.py

app/api/dashboard.py

@@ -1,193 +1,282 @@
-from fastapi import APIRouter, Depends
-from typing import Dict, Any
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List, Dict, Any, Optional
 import logging
-from datetime import datetime
+from datetime import datetime, timedelta
 import os
 import psutil
-import sys
-import platform
 from pathlib import Path
+import redis
 import json
-import asyncio
+import platform
+import sys
 
-# Redis Client
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# ---------------------------
+# Redis connection
+# ---------------------------
 try:
-    import redis
+    redis_client = redis.Redis(host="localhost", port=6379, db=0)
+    redis_client.ping()
     REDIS_AVAILABLE = True
-except ImportError:
+    logger.info("✅ Redis connection established successfully.")
+except Exception:
     REDIS_AVAILABLE = False
+    logger.warning("⚠️ Redis connection failed. Using in-memory fallback cache.")
 
-logger = logging.getLogger(__name__)
-router = APIRouter()
-
-# ----------------------------
-# Redis Connection
-# ----------------------------
-REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
-REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))
-REDIS_CACHE_TTL = 30  # seconds
+# In-memory cache fallback
+memory_cache = {}
 
-redis_client = None
-if REDIS_AVAILABLE:
-    try:
-        redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)
-        redis_client.ping()
-        logger.info("✅ Connected to Redis")
-    except Exception as e:
-        redis_client = None
-        logger.warning(f"⚠️ Redis unavailable: {e}")
+# ---------------------------
+# Mock data
+# ---------------------------
+MOCK_STATS = {
+    "total_documents": 145,
+    "processed_today": 23,
+    "active_reports": 8,
+    "uptime": "99.8%"
+}
 
-# ----------------------------
-# In-memory fallback cache
-# ----------------------------
-LOCAL_CACHE = {}
+MOCK_ACTIVITIES = [
+    {"id": 1, "type": "upload", "title": "فایل جدید آپلود شد", "description": "document_contract_2024.pdf", "timestamp": "۲ ساعت پیش"},
+    {"id": 2, "type": "process", "title": "پردازش OCR تکمیل شد", "description": "استخراج متن از ۳ سند", "timestamp": "۴ ساعت پیش"},
+    {"id": 3, "type": "search", "title": "جستجو انجام شد", "description": "جستجو برای 'قرارداد خرید'", "timestamp": "۶ ساعت پیش"},
+    {"id": 4, "type": "export", "title": "گزارش صادر شد", "description": "گزارش آماری ماهانه", "timestamp": "۱ روز پیش"}
+]
 
-def set_cache(key: str, value: Any, ttl: int = REDIS_CACHE_TTL):
+# ---------------------------
+# Cache helper functions
+# ---------------------------
+def cache_set(key: str, value: dict, ttl: int = 30):
     try:
-        if redis_client:
+        if REDIS_AVAILABLE:
             redis_client.setex(key, ttl, json.dumps(value))
         else:
-            LOCAL_CACHE[key] = {"data": value, "expire": datetime.now().timestamp() + ttl}
-    except Exception:
-        LOCAL_CACHE[key] = {"data": value, "expire": datetime.now().timestamp() + ttl}
+            memory_cache[key] = {"data": value, "expire": datetime.now() + timedelta(seconds=ttl)}
+    except Exception as e:
+        logger.error(f"Cache set failed: {e}")
 
-def get_cache(key: str):
+def cache_get(key: str):
     try:
-        if redis_client:
+        if REDIS_AVAILABLE:
             data = redis_client.get(key)
             return json.loads(data) if data else None
         else:
-            cached = LOCAL_CACHE.get(key)
-            if cached and cached["expire"] > datetime.now().timestamp():
-                return cached["data"]
-            return None
+            if key in memory_cache and datetime.now() < memory_cache[key]["expire"]:
+                return memory_cache[key]["data"]
     except Exception:
         return None
+    return None
 
-# ----------------------------
-# Simulated database query
-# ----------------------------
-async def query_database_stats():
-    """
-    TODO: Replace with actual DB query logic
-    """
-    await asyncio.sleep(0.1)  # simulate async query
-    return {
-        "total_documents": 200,
-        "processed_today": 35,
-        "active_reports": 10
-    }
-
-# ----------------------------
-# Endpoints
-# ----------------------------
+# ---------------------------
+# Helper function
+# ---------------------------
+def get_directory_size(path: Path) -> int:
+    try:
+        total_size = 0
+        for dirpath, _, filenames in os.walk(path):
+            for filename in filenames:
+                filepath = os.path.join(dirpath, filename)
+                try:
+                    total_size += os.path.getsize(filepath)
+                except (OSError, FileNotFoundError):
+                    pass
+        return total_size
+    except Exception:
+        return 0
+
+# ---------------------------
+# API Endpoints
+# ---------------------------
 
 @router.get("/stats")
 async def get_dashboard_stats():
-    cache_key = "dashboard_stats"
-    cached = get_cache(cache_key)
-    if cached:
-        return {"success": True, "data": cached}
-
     try:
-        stats = await query_database_stats()
+        cache_key = "dashboard_stats"
+        cached_data = cache_get(cache_key)
+        if cached_data:
+            return {"success": True, "data": cached_data}
+
+        stats = {}
+        try:
+            stats.update(MOCK_STATS)
+        except Exception as e:
+            logger.warning(f"Database stats unavailable: {e}")
+            stats.update(MOCK_STATS)
 
-        # Uptime
         try:
             uptime_seconds = psutil.boot_time()
             uptime = datetime.now() - datetime.fromtimestamp(uptime_seconds)
-            stats["uptime"] = f"{uptime.days}d {uptime.seconds // 3600}h"
+            stats["uptime"] = f"{uptime.days}d {uptime.seconds//3600}h"
         except Exception:
             stats["uptime"] = "N/A"
 
-        # Storage
-        disk_usage = psutil.disk_usage('/')
-        stats["storage_used"] = f"{disk_usage.used // (1024**3)}GB"
-        stats["storage_total"] = f"{disk_usage.total // (1024**3)}GB"
-        stats["storage_percent"] = round((disk_usage.used / disk_usage.total) * 100, 1)
+        try:
+            disk_usage = psutil.disk_usage('/')
+            stats["storage_used"] = f"{disk_usage.used // (1024**3)}GB"
+            stats["storage_total"] = f"{disk_usage.total // (1024**3)}GB"
+            stats["storage_percent"] = round((disk_usage.used / disk_usage.total) * 100, 1)
+        except Exception:
+            stats["storage_used"] = "N/A"
+            stats["storage_total"] = "N/A"
+            stats["storage_percent"] = 0
 
-        # Memory
-        memory = psutil.virtual_memory()
-        stats["memory_percent"] = round(memory.percent, 1)
-        stats["memory_used"] = f"{memory.used // (1024**2)}MB"
-        stats["memory_total"] = f"{memory.total // (1024**2)}MB"
+        try:
+            memory = psutil.virtual_memory()
+            stats["memory_percent"] = round(memory.percent, 1)
+            stats["memory_used"] = f"{memory.used // (1024**2)}MB"
+            stats["memory_total"] = f"{memory.total // (1024**2)}MB"
+        except Exception:
+            stats["memory_percent"] = 0
+            stats["memory_used"] = "N/A"
+            stats["memory_total"] = "N/A"
 
-        set_cache(cache_key, stats)
+        cache_set(cache_key, stats)
         return {"success": True, "data": stats}
     except Exception as e:
-        logger.error(f"Error fetching stats: {e}")
-        return {"success": False, "error": str(e)}
-
+        logger.error(f"Error in /stats: {e}")
+        return {"success": False, "error": str(e), "data": MOCK_STATS}
 
 @router.get("/recent-activity")
 async def get_recent_activity(limit: int = 10):
-    cache_key = f"recent_activity_{limit}"
-    cached = get_cache(cache_key)
-    if cached:
-        return {"success": True, "activities": cached, "total": len(cached)}
-
-    # TODO: Replace with DB query
-    activities = [
-        {"id": 1, "type": "upload", "title": "فایل جدید آپلود شد", "description": "document_contract_2024.pdf", "timestamp": "۲ ساعت پیش"},
-        {"id": 2, "type": "process", "title": "پردازش OCR تکمیل شد", "description": "استخراج متن از ۳ سند", "timestamp": "۴ ساعت پیش"},
-    ][:limit]
-
-    set_cache(cache_key, activities)
-    return {"success": True, "activities": activities, "total": len(activities)}
-
+    try:
+        return {"success": True, "activities": MOCK_ACTIVITIES[:limit], "total": len(MOCK_ACTIVITIES[:limit])}
+    except Exception as e:
+        logger.error(f"Error in /recent-activity: {e}")
+        return {"success": False, "error": str(e), "activities": []}
 
 @router.get("/system-info")
 async def get_system_info():
-    cache_key = "system_info"
-    cached = get_cache(cache_key)
-    if cached:
-        return {"success": True, "system_info": cached}
-
     try:
-        info = {
-            "platform": platform.platform(),
-            "cpu_count": psutil.cpu_count(),
-            "cpu_percent": psutil.cpu_percent(interval=1),
-            "app_version": "2.1.0",
-            "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        }
+        system_info = {}
+        try:
+            system_info["platform"] = platform.platform()
+            system_info["cpu_count"] = psutil.cpu_count()
+            system_info["cpu_percent"] = psutil.cpu_percent(interval=1)
+        except Exception as e:
+            logger.warning(f"System info error: {e}")
+            system_info.update({"platform": "Unknown", "cpu_count": "N/A", "cpu_percent": 0})
+
+        system_info["app_version"] = "2.0.0"
+        system_info["python_version"] = sys.version
 
-        dirs = {}
-        for name in ["data", "logs", "cache"]:
-            path = Path(f"/app/{name}")
-            dirs[name] = {
-                "exists": path.exists(),
-                "size": get_directory_size(path) if path.exists() else 0
+        try:
+            data_dir = Path("/app/data")
+            logs_dir = Path("/app/logs")
+            cache_dir = Path("/app/cache")
+            system_info["directories"] = {
+                "data": {"exists": data_dir.exists(), "size": get_directory_size(data_dir) if data_dir.exists() else 0},
+                "logs": {"exists": logs_dir.exists(), "size": get_directory_size(logs_dir) if logs_dir.exists() else 0},
+                "cache": {"exists": cache_dir.exists(), "size": get_directory_size(cache_dir) if cache_dir.exists() else 0},
             }
-        info["directories"] = dirs
+        except Exception as e:
+            logger.warning(f"Directory info error: {e}")
+            system_info["directories"] = {}
 
-        set_cache(cache_key, info)
-        return {"success": True, "system_info": info}
+        return {"success": True, "system_info": system_info}
     except Exception as e:
+        logger.error(f"Error in /system-info: {e}")
         return {"success": False, "error": str(e)}
 
+@router.get("/health-check")
+async def dashboard_health_check():
+    try:
+        health_status = {"overall": "healthy", "checks": {}}
+        try:
+            health_status["checks"]["database"] = {"status": "healthy", "message": "Database connection OK"}
+        except Exception as e:
+            health_status["checks"]["database"] = {"status": "unhealthy", "message": str(e)}
+            health_status["overall"] = "degraded"
+
+        try:
+            data_dir = Path("/app/data")
+            if not data_dir.exists():
+                data_dir.mkdir(parents=True, exist_ok=True)
+            test_file = data_dir / "health_check.tmp"
+            test_file.write_text("test")
+            test_file.unlink()
+            health_status["checks"]["filesystem"] = {"status": "healthy", "message": "File system OK"}
+        except Exception as e:
+            health_status["checks"]["filesystem"] = {"status": "unhealthy", "message": str(e)}
+            health_status["overall"] = "degraded"
+
+        try:
+            memory = psutil.virtual_memory()
+            if memory.percent > 90:
+                health_status["checks"]["memory"] = {"status": "warning", "message": f"High memory usage: {memory.percent}%"}
+                health_status["overall"] = "degraded"
+            else:
+                health_status["checks"]["memory"] = {"status": "healthy", "message": f"Memory usage OK: {memory.percent}%"}
+        except Exception as e:
+            health_status["checks"]["memory"] = {"status": "unknown", "message": str(e)}
+
+        try:
+            disk = psutil.disk_usage('/')
+            disk_percent = (disk.used / disk.total) * 100
+            if disk_percent > 90:
+                health_status["checks"]["disk"] = {"status": "warning", "message": f"High disk usage: {disk_percent:.1f}%"}
+                health_status["overall"] = "degraded"
+            else:
+                health_status["checks"]["disk"] = {"status": "healthy", "message": f"Disk usage OK: {disk_percent:.1f}%"}
+        except Exception as e:
+            health_status["checks"]["disk"] = {"status": "unknown", "message": str(e)}
+
+        return {"success": True, "health": health_status, "timestamp": datetime.now().isoformat()}
+    except Exception as e:
+        logger.error(f"Error in health-check: {e}")
+        return {"success": False, "error": str(e), "health": {"overall": "unhealthy", "checks": {}}}
 
 @router.get("/performance-metrics")
 async def get_performance_metrics():
     try:
-        metrics = {
-            "cpu": {"percent": psutil.cpu_percent(interval=1), "count": psutil.cpu_count()},
-            "memory": dict(psutil.virtual_memory()._asdict()),
-            "disk": dict(psutil.disk_usage('/')._asdict()),
-            "network": dict(psutil.net_io_counters()._asdict())
-        }
+        metrics = {}
+        try:
+            metrics["cpu"] = {"percent": psutil.cpu_percent(interval=1), "count": psutil.cpu_count(), "freq": psutil.cpu_freq()._asdict() if psutil.cpu_freq() else None}
+        except Exception as e:
+            metrics["cpu"] = {"percent": 0, "count": "N/A", "freq": None}
+        try:
+            memory = psutil.virtual_memory()
+            metrics["memory"] = {"total": memory.total, "used": memory.used, "free": memory.free, "percent": memory.percent}
+        except Exception:
+            metrics["memory"] = {"total": 0, "used": 0, "free": 0, "percent": 0}
+        try:
+            disk = psutil.disk_usage('/')
+            metrics["disk"] = {"total": disk.total, "used": disk.used, "free": disk.free, "percent": (disk.used / disk.total) * 100}
+        except Exception:
+            metrics["disk"] = {"total": 0, "used": 0, "free": 0, "percent": 0}
+        try:
+            network = psutil.net_io_counters()
+            metrics["network"] = {"bytes_sent": network.bytes_sent, "bytes_recv": network.bytes_recv, "packets_sent": network.packets_sent, "packets_recv": network.packets_recv}
+        except Exception:
+            metrics["network"] = {"bytes_sent": 0, "bytes_recv": 0, "packets_sent": 0, "packets_recv": 0}
+
         return {"success": True, "metrics": metrics, "timestamp": datetime.now().isoformat()}
     except Exception as e:
+        logger.error(f"Error in performance-metrics: {e}")
         return {"success": False, "error": str(e)}
 
+@router.post("/log-activity")
+async def log_activity(activity_data: dict):
+    try:
+        logger.info(f"Activity logged: {activity_data}")
+        return {"success": True, "message": "Activity logged successfully"}
+    except Exception as e:
+        logger.error(f"Error logging activity: {e}")
+        return {"success": False, "error": str(e)}
 
-def get_directory_size(path: Path) -> int:
-    total_size = 0
-    for dirpath, _, filenames in os.walk(path):
-        for filename in filenames:
-            filepath = os.path.join(dirpath, filename)
-            try:
-                total_size += os.path.getsize(filepath)
-            except (OSError, FileNotFoundError):
-                pass
-    return total_size
+@router.get("/export-dashboard-data")
+async def export_dashboard_data():
+    try:
+        export_data = {
+            "timestamp": datetime.now().isoformat(),
+            "stats": await get_dashboard_stats(),
+            "activities": await get_recent_activity(),
+            "system_info": await get_system_info(),
+            "performance": await get_performance_metrics()
+        }
+        return {"success": True, "data": export_data}
+    except Exception as e:
+        logger.error(f"Error exporting dashboard data: {e}")
+        return {"success": False, "error": str(e)}