"""用户体系接口:登录/登出、个人资料、账号管理、会话与审计,外加请求级鉴权中间件。 鉴权放在**中间件**而不是几十个端点上:这个平台有 200 多个路由,逐个加 `Depends` 既容易漏(漏一个就是「未登录也能删项目」),也让业务签名变脏。 中间件统一把用户挂到 `request.state.user` 并写入 contextvar, 端点按需 `Depends(require_user)` 取用,事件日志自动带上操作人。 """ from __future__ import annotations from fastapi import APIRouter, Depends, HTTPException, Request from fastapi.encoders import jsonable_encoder from fastapi.responses import JSONResponse from sqlalchemy import desc, select from sqlalchemy.orm import Session from app import schemas from app.config import settings from app.db import get_db from app.models import EventLog, User, UserSession from app.models.base import now_utc from app.models.user import Role from app.services import auth as auth_service from app.services.auth import AuthError router = APIRouter(tags=["auth"]) SAFE_METHODS = {"GET", "HEAD", "OPTIONS"} # 完全放行:健康检查给监控/容器探针,登录/状态给未登录的前端引导登录页 PUBLIC_PATHS = {"/", "/health", "/docs", "/redoc", "/openapi.json", "/favicon.ico"} PUBLIC_PREFIXES = ("/api/auth/state", "/api/auth/login") # 后端托管前端产物时,这些前缀之外的 GET 一律视为「页面壳与哈希资源」。 SPA_PROTECTED_PREFIXES = ("/api", "/media", "/health", "/docs", "/redoc", "/openapi.json") # 只有管理员能写的接口前缀(模型配置影响全平台出片,观摩/制作不能改) ADMIN_WRITE_PREFIXES = ("/api/users", "/api/providers") # ------------------------------------------------------------------ 中间件 def _token_from(request: Request) -> tuple[str, str]: """返回 (token, 来源),来源用于日志。Authorization 头优先,便于脚本调用。""" header = request.headers.get("authorization") or "" if header.lower().startswith("bearer "): return header[7:].strip(), "header" return request.cookies.get(settings.cookie_name) or "", "cookie" def _deny(status: int, detail: str, *, www: bool = False): from fastapi.responses import JSONResponse headers = {"WWW-Authenticate": "Bearer"} if www else None return JSONResponse(status_code=status, content={"detail": detail}, headers=headers) async def auth_middleware(request: Request, call_next): """校验会话 → 挂到 request.state → 角色闸门 → 放行。""" if not settings.auth_enabled: request.state.user = auth_service.local_user() request.state.session = None with auth_service.request_context(None): return await call_next(request) path = request.url.path if settings.serve_frontend_enabled() \ and request.method in SAFE_METHODS and not path.startswith(SPA_PROTECTED_PREFIXES): # 页面壳和 /assets/*.js 里没有任何业务数据(数据都在 /api 后面), # 未登录时也必须发得出去,否则直接在地址栏打开 # http://server:8000/projects/3 会拿到一坨 {"detail":"请先登录"}, # 用户看到的是白屏 JSON 而不是登录页。 token, _source = _token_from(request) db = next(get_db()) try: user, session = auth_service.resolve_token(db, token) if token else (None, None) finally: db.close() request.state.user = user request.state.session = session with auth_service.request_context(user): return await call_next(request) if path in PUBLIC_PATHS or path.startswith(PUBLIC_PREFIXES): # 已登录也顺手解析一次,登录页据此直接跳回工作台 token, _source = _token_from(request) db = next(get_db()) try: user, session = auth_service.resolve_token(db, token) if token else (None, None) finally: db.close() request.state.user = user request.state.session = session with auth_service.request_context(user): return await call_next(request) token, source = _token_from(request) if not token: return _deny(401, "请先登录", www=True) db = next(get_db()) try: user, session = auth_service.resolve_token(db, token) finally: db.close() if user is None: return _deny(401, "登录已过期,请重新登录", www=True) if request.method not in SAFE_METHODS and not Role.at_least(user.role, Role.EDITOR): return _deny(403, f"「{Role.label(user.role)}」角色只能浏览,不能修改数据") if request.method not in SAFE_METHODS and path.startswith(ADMIN_WRITE_PREFIXES) \ and user.role != Role.ADMIN: return _deny(403, "模型配置与账号管理仅管理员可修改") request.state.user = user request.state.session = session with auth_service.request_context(user): return await call_next(request) # ------------------------------------------------------------------ 依赖 def session_cookie(response, token: str) -> None: response.set_cookie(key=settings.cookie_name, value=token, max_age=int(auth_service.ttl().total_seconds()), httponly=True, secure=settings.cookie_secure, samesite="lax", path="/") def client_ip(request: Request) -> str: fwd = request.headers.get("x-forwarded-for") or "" if fwd: return fwd.split(",")[0].strip() return request.client.host if request.client else "" def require_user(request: Request, db: Session = Depends(get_db)) -> User: user = getattr(request.state, "user", None) if user is None: raise HTTPException(401, "请先登录") if not settings.auth_enabled: return user # 虚拟账号不在 users 表里,不做回查 fresh = db.get(User, user.id) if fresh is None or not fresh.is_active: raise HTTPException(401, "登录状态已失效,请重新登录") return fresh def require_admin(user: User = Depends(require_user)) -> User: if user.role != Role.ADMIN: raise HTTPException(403, "仅管理员可操作") return user def _actor_of(request: Request) -> User | None: return getattr(request.state, "user", None) # ------------------------------------------------------------------ 登录态 @router.get("/api/auth/state") def auth_state(request: Request, db: Session = Depends(get_db)) -> dict: """前端启动时问一次:要不要登录、当前是谁。未登录也返回 200,避免满屏 401。""" user = getattr(request.state, "user", None) return {"auth_enabled": settings.auth_enabled, "authenticated": user is not None, "user": auth_service.public_user(db, user) if user else None, "login_hint": {"username": settings.bootstrap_username} if settings.auth_enabled else {}} @router.post("/api/auth/login") def login(payload: schemas.LoginRequest, request: Request, db: Session = Depends(get_db)): user = auth_service.authenticate(db, payload.username, payload.password) label = (request.headers.get("user-agent") or "")[:120] session, token = auth_service.issue_session(db, user, ip=client_ip(request), label=label) auth_service.log_audit(db, "user.login", message=f"{user.username} 登录成功", entity_id=user.id, actor=user, data={"ip": client_ip(request)}) db.commit() # 注意:starlette 的 JSONResponse 走的是标准库 json.dumps, # 直接把带 datetime 的字典交给它会抛「Object of type datetime is not JSON serializable」 # ——也就是「点登录必然 500」。必须先过一遍 FastAPI 的 jsonable_encoder。 body = JSONResponse(content=jsonable_encoder({ "ok": True, "result": {"user": auth_service.public_user(db, user), "session": auth_service.public_session(session, current_id=session.id)}})) session_cookie(body, token) return body @router.post("/api/auth/logout") def logout(request: Request, db: Session = Depends(get_db)): current = getattr(request.state, "session", None) user = getattr(request.state, "user", None) if current is not None: # 中间件里的 ORM 对象来自另一个(已关闭的)Session,直接改它的字段不会被 # 本请求的 Session 跟踪——退出登录会「看起来成功了」但令牌依旧有效。 # 必须按主键在当前 Session 里重新取一行再撤销。 row = db.get(UserSession, current.id) if row is not None: auth_service.revoke(db, row) if user is not None: auth_service.log_audit(db, "user.logout", message=f"{user.username} 退出登录", entity_id=user.id, actor=user) db.commit() body = JSONResponse(content={"ok": True, "result": {"logged_out": True}}) body.delete_cookie(settings.cookie_name, path="/") return body # ------------------------------------------------------------------ 个人 @router.get("/api/auth/me") def me(request: Request, user: User = Depends(require_user), db: Session = Depends(get_db)) -> dict: current = getattr(request.state, "session", None) rows = db.scalars(select(UserSession).where(UserSession.user_id == user.id) .order_by(desc(UserSession.last_seen_at)).limit(20)).all() return {"user": auth_service.public_user(db, user), "sessions": [auth_service.public_session(row, current_id=getattr(current, "id", None)) for row in rows if row.active]} @router.patch("/api/auth/me") def update_me(payload: schemas.ProfileUpdate, user: User = Depends(require_user), db: Session = Depends(get_db)) -> dict: if payload.display_name is not None: user.display_name = (payload.display_name or "").strip()[:80] or user.username if payload.email is not None: user.email = (payload.email or "").strip()[:160] if payload.prefs is not None: # 界面偏好(主题、每页条数…)跟账号走,换台机器登录不用再调一遍 merged = dict(user.prefs_json or {}) merged.update(payload.prefs) user.prefs_json = merged db.commit() return auth_service.public_user(db, user) @router.post("/api/auth/password") def change_password(payload: schemas.PasswordChange, request: Request, user: User = Depends(require_user), db: Session = Depends(get_db)) -> dict: if not auth_service.verify_password(payload.current_password, user.password_hash): raise HTTPException(400, "当前密码不正确") if payload.new_password == payload.current_password: raise HTTPException(400, "新密码不能与当前密码相同") current = getattr(request.state, "session", None) auth_service.set_password(db, user, payload.new_password, actor=None, must_change=False) auth_service.log_audit(db, "user.password_changed", message=f"{user.username} 修改了自己的密码", entity_id=user.id, actor=user) db.commit() # 改密即踢掉其它设备上的会话,当前这个保留,用户不会被自己踢下线 others = auth_service.revoke_all(db, user.id, except_session_id=getattr(current, "id", None)) # 注意:前端 api.unwrap() 只保留 result,因此 revoked_sessions 必须放进 result 里, # 否则界面上「已注销 N 个其它会话」的提示永远是 0。 return {"ok": True, "result": {"user": auth_service.public_user(db, user), "revoked_sessions": others}} @router.delete("/api/auth/sessions/{session_id}") def revoke_my_session(session_id: int, request: Request, user: User = Depends(require_user), db: Session = Depends(get_db)) -> dict: row = db.get(UserSession, session_id) if row is None or row.user_id != user.id: raise HTTPException(404, "会话不存在") current = getattr(request.state, "session", None) if current is not None and current.id == row.id: raise HTTPException(400, "不能注销当前正在使用的会话,请直接退出登录") auth_service.revoke(db, row) return {"ok": True, "result": {"revoked": row.id}} # ------------------------------------------------------------------ 账号管理 #: 状态筛选的三档(页面顶部四张统计卡里的三张就是这三档,见 UI规范 §12) STATUS_FILTERS = ("active", "disabled", "pending") @router.get("/api/users") def list_users(db: Session = Depends(get_db), _: User = Depends(require_admin), q: str = "", role: str = "", status: str = "") -> dict: """账号列表。筛选一律在服务端做(与资产库 / 模型管理中心同口径): `q` 跨字段、`role` 单档、`status`=正常 / 已停用 / 待改初始密码。 `counts` 恒为全库数,统计卡才不会因为「一点就把自己数字点没」而跳字。""" rows = db.scalars(select(User).order_by(User.id)).all() keyword = q.strip().lower() if role and role not in Role.ALL: raise HTTPException(400, "角色只能是 管理员 / 制作 / 观摩") if status and status not in STATUS_FILTERS: raise HTTPException(400, "状态只能是 正常 / 已停用 / 待改初始密码") out = [] for row in rows: if role and row.role != role: continue if status == "active" and not row.is_active: continue if status == "disabled" and row.is_active: continue if status == "pending" and not (row.must_change_password and row.is_active): continue if keyword and keyword not in " ".join([row.username, row.display_name, row.email, row.note]).lower(): continue out.append(auth_service.public_user(db, row)) return {"items": out, "counts": auth_service.counts(db), "roles": [{"value": v, "label": Role.label(v)} for v in Role.ALL]} @router.post("/api/users") def create_user(payload: schemas.UserCreate, request: Request, db: Session = Depends(get_db), actor: User = Depends(require_admin)) -> dict: user = auth_service.create_user(db, username=payload.username, password=payload.password, display_name=payload.display_name, email=payload.email, role=payload.role, actor=actor, note=payload.note, must_change=True) return {"ok": True, "result": auth_service.public_user(db, user)} def _load_user(db: Session, user_id: int) -> User: row = db.get(User, user_id) if row is None: raise HTTPException(404, "账号不存在") return row def _is_last_admin(db: Session, user: User) -> bool: if user.role != Role.ADMIN: return False others = db.scalars(select(User).where(User.role == Role.ADMIN, User.is_active.is_(True), User.id != user.id)).all() return not others @router.patch("/api/users/{user_id}") def update_user(user_id: int, payload: schemas.UserUpdate, db: Session = Depends(get_db), actor: User = Depends(require_admin)) -> dict: row = _load_user(db, user_id) changed: list[str] = [] if payload.display_name is not None: row.display_name = (payload.display_name or "").strip()[:80] or row.username changed.append("显示名") if payload.email is not None: row.email = (payload.email or "").strip()[:160] changed.append("邮箱") if payload.note is not None: row.note = (payload.note or "")[:500] if payload.role is not None and payload.role != row.role: if payload.role not in Role.ALL: raise HTTPException(400, "角色只能是 管理员 / 制作 / 观摩") if _is_last_admin(db, row): raise HTTPException(400, "至少要保留一个可用的管理员") if row.id == actor.id: raise HTTPException(400, "不能修改自己的角色,请让另一位管理员调整") row.role = payload.role changed.append(f"角色→{Role.label(row.role)}") if payload.is_active is not None and bool(payload.is_active) != bool(row.is_active): if not payload.is_active and row.id == actor.id: raise HTTPException(400, "不能停用当前登录的账号") if not payload.is_active and _is_last_admin(db, row): raise HTTPException(400, "至少要保留一个可用的管理员") row.is_active = bool(payload.is_active) changed.append("启用" if row.is_active else "停用") if not row.is_active: auth_service.revoke_all(db, row.id) db.commit() auth_service.log_audit(db, "user.updated", message=f"更新账号 {row.username}:" + ("、".join(changed) or "备注"), entity_id=row.id, actor=actor) db.commit() return {"ok": True, "result": auth_service.public_user(db, row)} @router.delete("/api/users/{user_id}") def disable_user(user_id: int, db: Session = Depends(get_db), actor: User = Depends(require_admin)) -> dict: """停用而非物理删除:历史事件里的 actor 名字要能一直追溯到人。""" row = _load_user(db, user_id) if row.id == actor.id: raise HTTPException(400, "不能停用当前登录的账号") if _is_last_admin(db, row): raise HTTPException(400, "至少要保留一个可用的管理员") row.is_active = False auth_service.revoke_all(db, row.id) auth_service.log_audit(db, "user.disabled", message=f"停用账号 {row.username}", entity_id=row.id, actor=actor) db.commit() return {"ok": True, "result": auth_service.public_user(db, row)} @router.post("/api/users/{user_id}/password") def admin_reset_password(user_id: int, payload: schemas.AdminPasswordReset, db: Session = Depends(get_db), actor: User = Depends(require_admin)) -> dict: row = _load_user(db, user_id) auth_service.set_password(db, row, payload.new_password, actor=actor, must_change=payload.must_change, revoke_sessions=payload.revoke_sessions) auth_service.log_audit(db, "user.password_reset", message=f"{actor.username} 重置了 {row.username} 的密码", entity_id=row.id, actor=actor) db.commit() return {"ok": True, "result": auth_service.public_user(db, row)} @router.post("/api/users/{user_id}/sessions/revoke") def kick_user_sessions(user_id: int, db: Session = Depends(get_db), actor: User = Depends(require_admin)) -> dict: row = _load_user(db, user_id) count = auth_service.revoke_all(db, row.id) auth_service.log_audit(db, "user.sessions_revoked", message=f"注销 {row.username} 的 {count} 个登录会话", entity_id=row.id, actor=actor) db.commit() return {"ok": True, "result": {"revoked": count}} # ------------------------------------------------------------------ 审计 @router.get("/api/users/audit") def audit_trail(db: Session = Depends(get_db), _: User = Depends(require_admin), limit: int = 80) -> dict: rows = db.scalars(select(EventLog).where(EventLog.action.like("user.%")) .order_by(desc(EventLog.id)).limit(max(10, min(limit, 500)))).all() return {"items": [{"id": e.id, "action": e.action, "level": e.level, "message": e.message, "actor": e.actor, "entity_id": e.entity_id, "data": e.data_json or {}, "created_at": e.created_at} for e in rows], "counts": auth_service.counts(db), "server_time": now_utc()}