Update app/api/dashboard.py

app/api/dashboard.py

@@ -1,434 +1,193 @@
-from fastapi import APIRouter, HTTPException, Depends
-from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, Depends
+from typing import Dict, Any
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime
 import os
 import psutil
+import sys
+import platform
 from pathlib import Path
+import json
+import asyncio
 
-logger = logging.getLogger(__name__)
+# Redis Client
+try:
+    import redis
+    REDIS_AVAILABLE = True
+except ImportError:
+    REDIS_AVAILABLE = False
 
+logger = logging.getLogger(__name__)
 router = APIRouter()
 
-# Mock data for demonstration - replace with actual database queries
-MOCK_STATS = {
-    "total_documents": 145,
-    "processed_today": 23,
-    "active_reports": 8,
-    "uptime": "99.8%"
-}
+# ----------------------------
+# Redis Connection
+# ----------------------------
+REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
+REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))
+REDIS_CACHE_TTL = 30  # seconds
+
+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}")
+
+# ----------------------------
+# In-memory fallback cache
+# ----------------------------
+LOCAL_CACHE = {}
+
+def set_cache(key: str, value: Any, ttl: int = REDIS_CACHE_TTL):
+    try:
+        if redis_client:
+            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}
+
+def get_cache(key: str):
+    try:
+        if redis_client:
+            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
+    except Exception:
+        return None
 
-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": "۱ روز پیش"
+# ----------------------------
+# 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
+# ----------------------------
 
 @router.get("/stats")
 async def get_dashboard_stats():
-    """
-    Get dashboard statistics
-    """
+    cache_key = "dashboard_stats"
+    cached = get_cache(cache_key)
+    if cached:
+        return {"success": True, "data": cached}
+
     try:
-        # Get actual system stats
-        stats = {}
-        
-        # Try to get document count from database
-        try:
-            # This would normally query your database
-            stats["total_documents"] = MOCK_STATS["total_documents"]
-            stats["processed_today"] = MOCK_STATS["processed_today"]
-            stats["active_reports"] = MOCK_STATS["active_reports"]
-        except Exception as e:
-            logger.warning(f"Could not get database stats: {e}")
-            stats.update(MOCK_STATS)
-        
-        # Get system uptime
+        stats = await query_database_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"
-        
-        # Get storage info
-        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
-        
-        # Get memory info
-        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"
-        
-        return {
-            "success": True,
-            "data": stats
-        }
-        
+
+        # 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)
+
+        # 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"
+
+        set_cache(cache_key, stats)
+        return {"success": True, "data": stats}
     except Exception as e:
-        logger.error(f"Error getting dashboard stats: {e}")
-        return {
-            "success": False,
-            "error": str(e),
-            "data": MOCK_STATS
-        }
+        logger.error(f"Error fetching stats: {e}")
+        return {"success": False, "error": str(e)}
+
 
 @router.get("/recent-activity")
 async def get_recent_activity(limit: int = 10):
-    """
-    Get recent system activities
-    """
-    try:
-        # This would normally query your database for recent activities
-        activities = MOCK_ACTIVITIES[:limit]
-        
-        return {
-            "success": True,
-            "activities": activities,
-            "total": len(activities)
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting recent activities: {e}")
-        return {
-            "success": False,
-            "error": str(e),
-            "activities": []
-        }
+    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)}
+
 
 @router.get("/system-info")
 async def get_system_info():
-    """
-    Get detailed system information
-    """
-    try:
-        system_info = {}
-        
-        # Basic system info
-        try:
-            system_info["platform"] = psutil.platform
-            system_info["cpu_count"] = psutil.cpu_count()
-            system_info["cpu_percent"] = psutil.cpu_percent(interval=1)
-        except Exception as e:
-            logger.warning(f"Could not get system info: {e}")
-            system_info.update({
-                "platform": "Unknown",
-                "cpu_count": "N/A",
-                "cpu_percent": 0
-            })
-        
-        # Application info
-        system_info["app_version"] = "2.0.0"
-        system_info["python_version"] = f"{psutil.sys.version_info.major}.{psutil.sys.version_info.minor}.{psutil.sys.version_info.micro}"
-        
-        # Directory info
-        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
-                }
-            }
-        except Exception as e:
-            logger.warning(f"Could not get directory info: {e}")
-            system_info["directories"] = {}
-        
-        return {
-            "success": True,
-            "system_info": system_info
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting system info: {e}")
-        return {
-            "success": False,
-            "error": str(e)
-        }
+    cache_key = "system_info"
+    cached = get_cache(cache_key)
+    if cached:
+        return {"success": True, "system_info": cached}
 
-@router.get("/health-check")
-async def dashboard_health_check():
-    """
-    Comprehensive health check for dashboard
-    """
     try:
-        health_status = {
-            "overall": "healthy",
-            "checks": {}
+        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}",
         }
-        
-        # Check database
-        try:
-            # This would check database connection
-            health_status["checks"]["database"] = {
-                "status": "healthy",
-                "message": "Database connection OK"
-            }
-        except Exception as e:
-            health_status["checks"]["database"] = {
-                "status": "unhealthy",
-                "message": f"Database error: {str(e)}"
-            }
-            health_status["overall"] = "degraded"
-        
-        # Check file system
-        try:
-            data_dir = Path("/app/data")
-            if not data_dir.exists():
-                data_dir.mkdir(parents=True, exist_ok=True)
-            
-            # Test write permissions
-            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": f"File system error: {str(e)}"
-            }
-            health_status["overall"] = "degraded"
-        
-        # Check memory usage
-        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": f"Could not check memory: {str(e)}"
-            }
-        
-        # Check disk usage
-        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": f"Could not check disk: {str(e)}"
+
+        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
             }
-        
-        return {
-            "success": True,
-            "health": health_status,
-            "timestamp": datetime.now().isoformat()
-        }
-        
+        info["directories"] = dirs
+
+        set_cache(cache_key, info)
+        return {"success": True, "system_info": info}
     except Exception as e:
-        logger.error(f"Error in health check: {e}")
-        return {
-            "success": False,
-            "error": str(e),
-            "health": {
-                "overall": "unhealthy",
-                "checks": {}
-            }
-        }
+        return {"success": False, "error": str(e)}
+
 
 @router.get("/performance-metrics")
 async def get_performance_metrics():
-    """
-    Get system performance metrics
-    """
     try:
-        metrics = {}
-        
-        # CPU 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:
-            logger.warning(f"Could not get CPU metrics: {e}")
-            metrics["cpu"] = {"percent": 0, "count": "N/A", "freq": None}
-        
-        # Memory metrics
-        try:
-            memory = psutil.virtual_memory()
-            metrics["memory"] = {
-                "total": memory.total,
-                "used": memory.used,
-                "free": memory.free,
-                "percent": memory.percent
-            }
-        except Exception as e:
-            logger.warning(f"Could not get memory metrics: {e}")
-            metrics["memory"] = {"total": 0, "used": 0, "free": 0, "percent": 0}
-        
-        # Disk metrics
-        try:
-            disk = psutil.disk_usage('/')
-            metrics["disk"] = {
-                "total": disk.total,
-                "used": disk.used,
-                "free": disk.free,
-                "percent": (disk.used / disk.total) * 100
-            }
-        except Exception as e:
-            logger.warning(f"Could not get disk metrics: {e}")
-            metrics["disk"] = {"total": 0, "used": 0, "free": 0, "percent": 0}
-        
-        # Network metrics (if available)
-        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 as e:
-            logger.warning(f"Could not get network metrics: {e}")
-            metrics["network"] = {"bytes_sent": 0, "bytes_recv": 0, "packets_sent": 0, "packets_recv": 0}
-        
-        return {
-            "success": True,
-            "metrics": metrics,
-            "timestamp": datetime.now().isoformat()
+        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())
         }
-        
+        return {"success": True, "metrics": metrics, "timestamp": datetime.now().isoformat()}
     except Exception as e:
-        logger.error(f"Error getting performance metrics: {e}")
-        return {
-            "success": False,
-            "error": str(e)
-        }
+        return {"success": False, "error": str(e)}
 
-def get_directory_size(path: Path) -> int:
-    """Get directory size in bytes"""
-    try:
-        total_size = 0
-        for dirpath, dirnames, 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
 
-@router.post("/log-activity")
-async def log_activity(activity_data: dict):
-    """
-    Log a new activity (for future database integration)
-    """
-    try:
-        # This would normally save to database
-        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)
-        }
-
-@router.get("/export-dashboard-data")
-async def export_dashboard_data():
-    """
-    Export dashboard data for backup or analysis
-    """
-    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)
-        }
+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