Aether/_deprecated_py_src/api/monitoring/user.py

"""普通用户可访问的监控与审计端点。"""

from __future__ import annotations

from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from typing import Any

from fastapi import APIRouter, Depends, HTTPException, Query, Request
from sqlalchemy.orm import Session

from src.api.base.adapter import ApiAdapter, ApiMode
from src.api.base.context import ApiRequestContext
from src.api.base.pagination import PaginationMeta, build_pagination_payload, paginate_query
from src.api.base.pipeline import get_pipeline
from src.core.logger import logger
from src.database import get_db
from src.models.database import ApiKey, AuditLog
from src.services.rate_limit.user_rpm_limiter import SYSTEM_RPM_CONFIG_KEY, get_user_rpm_limiter
from src.services.system.config import SystemConfigService

router = APIRouter(prefix="/api/monitoring", tags=["Monitoring"])
pipeline = get_pipeline()


@router.get("/my-audit-logs")
async def get_my_audit_logs(
    request: Request,
    event_type: str | None = Query(None, description="事件类型筛选"),
    days: int = Query(30, description="查询天数"),
    limit: int = Query(50, description="返回数量限制"),
    offset: int = Query(0, ge=0, description="偏移量"),
    db: Session = Depends(get_db),
) -> Any:
    """
    获取我的审计日志

    获取当前用户的审计日志记录。需要登录。

    **查询参数**:
    - `event_type`: 可选，事件类型筛选
    - `days`: 查询最近多少天的日志，默认 30 天
    - `limit`: 返回数量限制，默认 50
    - `offset`: 分页偏移量，默认 0

    **返回字段**:
    - `items`: 审计日志列表，每条日志包含：
      - `id`: 日志 ID
      - `event_type`: 事件类型
      - `description`: 事件描述
      - `ip_address`: IP 地址
      - `status_code`: HTTP 状态码
      - `created_at`: 创建时间
    - `meta`: 分页元数据（total, limit, offset, count）
    - `filters`: 筛选条件
    """
    adapter = UserAuditLogsAdapter(event_type=event_type, days=days, limit=limit, offset=offset)
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


@router.get("/rate-limit-status")
async def get_rate_limit_status(request: Request, db: Session = Depends(get_db)) -> Any:
    """
    获取速率限制状态

    获取当前用户所有活跃 API Key 的速率限制状态。需要登录。

    **返回字段**:
    - `user_id`: 用户 ID
    - `api_keys`: API Key 限流状态列表，每个包含：
      - `api_key_name`: API Key 名称
      - `limit`: 速率限制上限
      - `remaining`: 剩余可用次数
      - `reset_time`: 限制重置时间
      - `window`: 时间窗口
    """
    adapter = UserRateLimitStatusAdapter()
    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)


class AuthenticatedApiAdapter(ApiAdapter):
    """需要用户登录的适配器基类。"""

    mode = ApiMode.USER

    def authorize(self, context: ApiRequestContext) -> None:  # type: ignore[override]
        if not context.user:
            raise HTTPException(status_code=401, detail="未登录")


@dataclass
class UserAuditLogsAdapter(AuthenticatedApiAdapter):
    event_type: str | None
    days: int
    limit: int
    offset: int

    async def handle(self, context: ApiRequestContext) -> Any:  # type: ignore[override]
        db = context.db
        user = context.user
        if not user:
            raise HTTPException(status_code=401, detail="未登录")

        query = db.query(AuditLog).filter(AuditLog.user_id == user.id)
        if self.event_type:
            query = query.filter(AuditLog.event_type == self.event_type)

        cutoff_time = datetime.now(timezone.utc) - timedelta(days=self.days)
        query = query.filter(AuditLog.created_at >= cutoff_time)
        query = query.order_by(AuditLog.created_at.desc())

        total, logs = paginate_query(query, self.limit, self.offset)

        items = [
            {
                "id": log.id,
                "event_type": log.event_type,
                "description": log.description,
                "ip_address": log.ip_address,
                "status_code": log.status_code,
                "created_at": log.created_at.isoformat() if log.created_at else None,
            }
            for log in logs
        ]

        meta = PaginationMeta(
            total=total,
            limit=self.limit,
            offset=self.offset,
            count=len(items),
        )

        return build_pagination_payload(
            items,
            meta,
            filters={
                "event_type": self.event_type,
                "days": self.days,
            },
        )


class UserRateLimitStatusAdapter(AuthenticatedApiAdapter):
    async def handle(self, context: ApiRequestContext) -> Any:  # type: ignore[override]
        db = context.db
        user = context.user
        if not user:
            raise HTTPException(status_code=401, detail="未登录")

        api_keys = (
            db.query(ApiKey)
            .filter(ApiKey.user_id == user.id, ApiKey.is_active.is_(True))
            .order_by(ApiKey.created_at.desc())
            .all()
        )

        try:
            limiter = await get_user_rpm_limiter()
            system_default_raw = SystemConfigService.get_config(
                db, SYSTEM_RPM_CONFIG_KEY, default=0
            )
            system_default = max(int(system_default_raw or 0), 0)
            reset_at = limiter.get_reset_at()
            window = f"{limiter.bucket_seconds}s"
        except Exception as exc:
            logger.warning("读取新 RPM 限流状态失败，回退插件状态接口: {}", exc)
            limiter = None
            system_default = 0
            reset_at = None
            window = None

        rate_limit_info = []
        for key in api_keys:
            if limiter is not None:
                if key.is_standalone:
                    user_limit = key.rate_limit if key.rate_limit is not None else system_default
                    user_scope_key = limiter.get_standalone_rpm_key(key.id)
                    key_limit = 0
                else:
                    user_limit = user.rate_limit if user.rate_limit is not None else system_default
                    user_scope_key = limiter.get_user_rpm_key(user.id)
                    key_limit = max(int(key.rate_limit or 0), 0)

                user_count = (
                    await limiter.get_scope_count(user_scope_key)
                    if user_limit and user_limit > 0
                    else 0
                )
                key_count = (
                    await limiter.get_scope_count(limiter.get_key_rpm_key(key.id))
                    if key_limit > 0
                    else 0
                )
                user_remaining = max(user_limit - user_count, 0) if user_limit > 0 else None
                key_remaining = max(key_limit - key_count, 0) if key_limit > 0 else None

                scoped_statuses: list[tuple[str, int, int]] = []
                if user_limit > 0 and user_remaining is not None:
                    scoped_statuses.append(("user", user_limit, user_remaining))
                if key_limit > 0 and key_remaining is not None:
                    scoped_statuses.append(("key", key_limit, key_remaining))

                primary_scope = (
                    min(scoped_statuses, key=lambda item: item[2]) if scoped_statuses else None
                )
                rate_limit_info.append(
                    {
                        "api_key_name": key.name or f"Key-{key.id}",
                        "limit": primary_scope[1] if primary_scope else None,
                        "remaining": primary_scope[2] if primary_scope else None,
                        "scope": primary_scope[0] if primary_scope else None,
                        "reset_time": reset_at.isoformat() if reset_at else None,
                        "window": window,
                        "user_limit": user_limit,
                        "user_remaining": user_remaining,
                        "key_limit": key_limit if key_limit > 0 else None,
                        "key_remaining": key_remaining,
                    }
                )
                continue

            rate_limit_info.append(
                {
                    "api_key_name": key.name or f"Key-{key.id}",
                    "limit": None,
                    "remaining": None,
                    "scope": None,
                    "reset_time": None,
                    "window": None,
                    "user_limit": None,
                    "user_remaining": None,
                    "key_limit": None,
                    "key_remaining": None,
                }
            )

        return {"user_id": user.id, "api_keys": rate_limit_info}