nex_animation/backend/app/api/auth.py

389 lines
19 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""用户体系接口:登录/登出、个人资料、账号管理、会话与审计,外加请求级鉴权中间件。
鉴权放在**中间件**而不是几十个端点上:这个平台有 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}}
# ------------------------------------------------------------------ 账号管理
@router.get("/api/users")
def list_users(db: Session = Depends(get_db), _: User = Depends(require_admin),
q: str = "", role: str = "") -> dict:
rows = db.scalars(select(User).order_by(User.id)).all()
keyword = q.strip().lower()
out = []
for row in rows:
if role and row.role != role:
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()}