tg_loader/web/admin/views.py

"""
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