406 lines
20 KiB
Python
406 lines
20 KiB
Python
"""用户体系接口:登录/登出、个人资料、账号管理、会话与审计,外加请求级鉴权中间件。
|
||
|
||
鉴权放在**中间件**而不是几十个端点上:这个平台有 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()}
|