Add source

web/admin/views.py

@@ -0,0 +1,176 @@
+"""
+Admin panel views - data retrieval logic
+"""
+from typing import List, Optional
+from sqlalchemy import select, func, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+from shared.database.models import User, Task
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def get_users_stats(session: AsyncSession) -> dict:
+    """Get user statistics"""
+    try:
+        # Total user count
+        total_users_result = await session.execute(
+            select(func.count(User.user_id))
+        )
+        total_users = total_users_result.scalar() or 0
+        
+        # Administrator count
+        admins_result = await session.execute(
+            select(func.count(User.user_id)).where(User.is_admin == True)
+        )
+        total_admins = admins_result.scalar() or 0
+        
+        # Blocked user count
+        blocked_result = await session.execute(
+            select(func.count(User.user_id)).where(User.is_blocked == True)
+        )
+        blocked_users = blocked_result.scalar() or 0
+        
+        # New users in last 7 days
+        week_ago = datetime.utcnow() - timedelta(days=7)
+        new_users_result = await session.execute(
+            select(func.count(User.user_id)).where(User.created_at >= week_ago)
+        )
+        new_users = new_users_result.scalar() or 0
+        
+        return {
+            "total": total_users,
+            "admins": total_admins,
+            "blocked": blocked_users,
+            "new_week": new_users
+        }
+    except Exception as e:
+        logger.error(f"Error getting user statistics: {e}")
+        return {"total": 0, "admins": 0, "blocked": 0, "new_week": 0}
+
+
+async def get_tasks_stats(session: AsyncSession) -> dict:
+    """Get task statistics"""
+    try:
+        # Total task count
+        total_tasks_result = await session.execute(
+            select(func.count(Task.id))
+        )
+        total_tasks = total_tasks_result.scalar() or 0
+        
+        # Active tasks (pending, processing)
+        active_tasks_result = await session.execute(
+            select(func.count(Task.id)).where(
+                Task.status.in_(["pending", "processing"])
+            )
+        )
+        active_tasks = active_tasks_result.scalar() or 0
+        
+        # Completed tasks
+        completed_tasks_result = await session.execute(
+            select(func.count(Task.id)).where(Task.status == "completed")
+        )
+        completed_tasks = completed_tasks_result.scalar() or 0
+        
+        # Failed tasks
+        failed_tasks_result = await session.execute(
+            select(func.count(Task.id)).where(Task.status == "failed")
+        )
+        failed_tasks = failed_tasks_result.scalar() or 0
+        
+        # Tasks in last 24 hours
+        day_ago = datetime.utcnow() - timedelta(hours=24)
+        recent_tasks_result = await session.execute(
+            select(func.count(Task.id)).where(Task.created_at >= day_ago)
+        )
+        recent_tasks = recent_tasks_result.scalar() or 0
+        
+        return {
+            "total": total_tasks,
+            "active": active_tasks,
+            "completed": completed_tasks,
+            "failed": failed_tasks,
+            "recent_24h": recent_tasks
+        }
+    except Exception as e:
+        logger.error(f"Error getting task statistics: {e}")
+        return {"total": 0, "active": 0, "completed": 0, "failed": 0, "recent_24h": 0}
+
+
+async def get_all_users(
+    session: AsyncSession,
+    limit: int = 100,
+    offset: int = 0,
+    search: Optional[str] = None
+) -> List[User]:
+    """Get user list"""
+    try:
+        query = select(User)
+        
+        if search:
+            # Search by username or user_id
+            try:
+                user_id = int(search)
+                query = query.where(User.user_id == user_id)
+            except ValueError:
+                query = query.where(User.username.ilike(f"%{search}%"))
+        
+        query = query.order_by(desc(User.created_at)).limit(limit).offset(offset)
+        result = await session.execute(query)
+        return list(result.scalars().all())
+    except Exception as e:
+        logger.error(f"Error getting users: {e}")
+        return []
+
+
+async def get_user_by_id(session: AsyncSession, user_id: int) -> Optional[User]:
+    """Get user by ID"""
+    try:
+        return await session.get(User, user_id)
+    except Exception as e:
+        logger.error(f"Error getting user: {e}")
+        return None
+
+
+async def get_all_tasks(
+    session: AsyncSession,
+    limit: int = 100,
+    offset: int = 0,
+    status_filter: Optional[str] = None,
+    user_id_filter: Optional[int] = None
+) -> List[Task]:
+    """Get task list"""
+    try:
+        query = select(Task)
+        
+        if status_filter:
+            query = query.where(Task.status == status_filter)
+        
+        if user_id_filter:
+            query = query.where(Task.user_id == user_id_filter)
+        
+        query = query.order_by(desc(Task.created_at)).limit(limit).offset(offset)
+        result = await session.execute(query)
+        tasks = list(result.scalars().all())
+        
+        # Load related users
+        for task in tasks:
+            await session.refresh(task, ["user"])
+        
+        return tasks
+    except Exception as e:
+        logger.error(f"Error getting tasks: {e}")
+        return []
+
+
+async def get_task_by_id(session: AsyncSession, task_id: int) -> Optional[Task]:
+    """Get task by ID"""
+    try:
+        task = await session.get(Task, task_id)
+        if task:
+            await session.refresh(task, ["user"])
+        return task
+    except Exception as e:
+        logger.error(f"Error getting task: {e}")
+        return None