243 lines
9.6 KiB
Python
243 lines
9.6 KiB
Python
"""认证与当前用户上下文: 登录 / 刷新 / 登出 / 我的信息 / 我的菜单."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import datetime, timedelta, timezone
|
||
|
||
import jwt
|
||
from fastapi import APIRouter, Query, Request
|
||
from sqlalchemy import delete, select, update
|
||
|
||
from ...core.config import settings
|
||
from ...core.deps import AuthCtx, Session, load_user_context
|
||
from ...core.errors import AppError
|
||
from ...core.security import create_token, decode_token, hash_password, new_token_id, verify_password
|
||
from ...db.base import utcnow
|
||
from ...models.rbac import Menu, Notification, RefreshToken, Role, User, UserRole
|
||
from ...schemas.common import Message
|
||
from ...schemas.system import (
|
||
ChangePasswordPayload, LoginPayload, MenuNode, RefreshPayload, TokenResponse, UserRead,
|
||
)
|
||
|
||
router = APIRouter(prefix="/auth", tags=["认证"])
|
||
|
||
|
||
async def _user_read(session, user: User) -> UserRead:
|
||
roles = (
|
||
await session.execute(
|
||
select(Role).join(UserRole, UserRole.role_id == Role.id).where(UserRole.user_id == user.id)
|
||
)
|
||
).scalars().all()
|
||
data = UserRead.model_validate(user)
|
||
payload = data.model_dump()
|
||
payload["roles"] = [{"id": r.id, "code": r.code, "name": r.name, "data_scope": r.data_scope}
|
||
for r in roles]
|
||
payload["role_ids"] = [r.id for r in roles]
|
||
return UserRead.model_validate(payload)
|
||
|
||
|
||
async def _issue_tokens(session, user: User, *, family: str | None = None,
|
||
user_agent: str | None = None) -> tuple[str, str, int]:
|
||
access, _, _ = create_token(user.id, "access", extra={"username": user.username})
|
||
refresh, jti, expires_at = create_token(user.id, "refresh")
|
||
session.add(
|
||
RefreshToken(
|
||
user_id=user.id, jti=jti, family=family or new_token_id(),
|
||
user_agent=(user_agent or "")[:255] or None, expires_at=expires_at,
|
||
)
|
||
)
|
||
now = datetime.now(timezone.utc)
|
||
return access, refresh, max(60, int((expires_at - now).total_seconds()))
|
||
|
||
|
||
@router.post("/login", response_model=TokenResponse, summary="账号密码登录")
|
||
async def login(payload: LoginPayload, request: Request, session: Session):
|
||
user = (
|
||
await session.execute(select(User).where(User.username == payload.username.strip()))
|
||
).scalar_one_or_none()
|
||
if not user or not verify_password(payload.password, user.password_hash):
|
||
raise AppError("用户名或密码不正确", "bad_credentials", 401)
|
||
if not user.is_active:
|
||
raise AppError("账号已被停用,请联系 HR 管理员", "user_inactive", 403)
|
||
access, refresh, ttl = await _issue_tokens(
|
||
session, user, user_agent=request.headers.get("user-agent")
|
||
)
|
||
user.last_login_at = utcnow()
|
||
await session.commit()
|
||
return TokenResponse(
|
||
access_token=access, refresh_token=refresh, expires_in=ttl,
|
||
user=await _user_read(session, user),
|
||
)
|
||
|
||
|
||
@router.post("/refresh", response_model=TokenResponse, summary="刷新访问令牌")
|
||
async def refresh(payload: RefreshPayload, request: Request, session: Session):
|
||
try:
|
||
claims = decode_token(payload.refresh_token, "refresh")
|
||
except jwt.PyJWTError:
|
||
raise AppError("登录已失效,请重新登录", "token_invalid", 401)
|
||
row = (
|
||
await session.execute(select(RefreshToken).where(RefreshToken.jti == claims["jti"]))
|
||
).scalar_one_or_none()
|
||
if not row:
|
||
raise AppError("登录已失效,请重新登录", "token_unknown", 401)
|
||
if row.revoked_at: # replay of a rotated token -> kill the whole family
|
||
await session.execute(
|
||
update(RefreshToken)
|
||
.where(RefreshToken.family == row.family, RefreshToken.revoked_at.is_(None))
|
||
.values(revoked_at=utcnow())
|
||
)
|
||
await session.commit()
|
||
raise AppError("检测到登录凭证异常使用,请重新登录", "token_reuse", 401)
|
||
user = await session.get(User, row.user_id)
|
||
if not user or not user.is_active:
|
||
raise AppError("账号不可用", "user_inactive", 401)
|
||
row.revoked_at = utcnow()
|
||
access, new_refresh, ttl = await _issue_tokens(
|
||
session, user, family=row.family, user_agent=request.headers.get("user-agent")
|
||
)
|
||
await session.commit()
|
||
return TokenResponse(
|
||
access_token=access, refresh_token=new_refresh, expires_in=ttl,
|
||
user=await _user_read(session, user),
|
||
)
|
||
|
||
|
||
@router.post("/logout", response_model=Message, summary="退出登录")
|
||
async def logout(session: Session, auth: AuthCtx, payload: RefreshPayload | None = None):
|
||
if payload and payload.refresh_token:
|
||
try:
|
||
claims = decode_token(payload.refresh_token, "refresh")
|
||
except jwt.PyJWTError:
|
||
claims = {}
|
||
jti = claims.get("jti")
|
||
if jti:
|
||
row = (
|
||
await session.execute(select(RefreshToken).where(RefreshToken.jti == jti))
|
||
).scalar_one_or_none()
|
||
if row:
|
||
await session.execute(
|
||
update(RefreshToken)
|
||
.where(RefreshToken.family == row.family, RefreshToken.revoked_at.is_(None))
|
||
.values(revoked_at=utcnow())
|
||
)
|
||
await session.commit()
|
||
return Message(message="已退出登录")
|
||
|
||
|
||
@router.get("/me", summary="当前登录用户 (含权限与数据范围)")
|
||
async def me(session: Session, auth: AuthCtx):
|
||
from ...models.employee import Employee
|
||
|
||
employee = await session.get(Employee, auth.employee_id) if auth.employee_id else None
|
||
return {
|
||
"user": (await _user_read(session, auth.user)).model_dump(),
|
||
"permissions": sorted(auth.permissions),
|
||
"roles": auth.role_codes,
|
||
"data_scope": auth.data_scope,
|
||
"is_staff": auth.is_staff,
|
||
"employee": (
|
||
{
|
||
"id": employee.id, "name": employee.name, "work_no": employee.work_no,
|
||
"department_id": employee.department_id, "position_id": employee.position_id,
|
||
"job_level_id": employee.job_level_id, "status": employee.status,
|
||
"avatar": employee.avatar, "phone": employee.phone, "email": employee.email,
|
||
}
|
||
if employee else None
|
||
),
|
||
}
|
||
|
||
|
||
@router.get("/menus", response_model=list[MenuNode], summary="当前用户可见菜单")
|
||
async def my_menus(session: Session, auth: AuthCtx, platform: str = Query("web")):
|
||
if platform == "web" and auth.data_scope == "self":
|
||
from ...core.permissions import SELF_WEB_MENU_TREE
|
||
|
||
return [
|
||
MenuNode(
|
||
id=-(index + 1),
|
||
name=node["name"],
|
||
path=node["path"],
|
||
icon=node["icon"],
|
||
perm_code=node["perm"],
|
||
sort=node["sort"],
|
||
platform="web",
|
||
children=[],
|
||
)
|
||
for index, node in enumerate(SELF_WEB_MENU_TREE)
|
||
if auth.can(node["perm"])
|
||
]
|
||
rows = (
|
||
await session.execute(select(Menu).where(Menu.platform == platform).order_by(Menu.sort, Menu.id))
|
||
).scalars().all()
|
||
nodes = {
|
||
m.id: MenuNode(id=m.id, name=m.name, path=m.path, icon=m.icon, perm_code=m.perm_code,
|
||
sort=m.sort, platform=m.platform, children=[])
|
||
for m in rows
|
||
if m.visible and (not m.perm_code or auth.can(m.perm_code))
|
||
}
|
||
# keep parents whose children survived the permission filter
|
||
by_id = {m.id: m for m in rows}
|
||
result: list[MenuNode] = []
|
||
for node in nodes.values():
|
||
parent = by_id.get(node.id)
|
||
parent_node = nodes.get(parent.parent_id) if parent and parent.parent_id else None
|
||
if parent_node:
|
||
parent_node.children.append(node)
|
||
elif not parent.parent_id or parent.parent_id not in nodes:
|
||
result.append(node)
|
||
|
||
def _sort(items: list[MenuNode]):
|
||
items.sort(key=lambda n: (n.sort, n.id))
|
||
for item in items:
|
||
_sort(item.children)
|
||
|
||
def _prune(items: list[MenuNode]) -> list[MenuNode]:
|
||
# 分组节点本身没有 path,子项全部无权限时整组隐藏,避免出现点不动的死菜单
|
||
kept: list[MenuNode] = []
|
||
for item in items:
|
||
item.children = _prune(item.children)
|
||
if item.path or item.children:
|
||
kept.append(item)
|
||
return kept
|
||
|
||
result[:] = _prune(result)
|
||
_sort(result)
|
||
return result
|
||
|
||
|
||
@router.post("/change-password", response_model=Message, summary="修改我的密码")
|
||
async def change_password(payload: ChangePasswordPayload, session: Session, auth: AuthCtx):
|
||
if not verify_password(payload.old_password, auth.user.password_hash):
|
||
raise AppError("原密码不正确", "bad_password")
|
||
auth.user.password_hash = hash_password(payload.new_password)
|
||
await session.execute(
|
||
delete(RefreshToken).where(RefreshToken.user_id == auth.user.id)
|
||
)
|
||
await session.commit()
|
||
return Message(message="密码已更新,其它设备需要重新登录")
|
||
|
||
|
||
@router.put("/profile", summary="更新我的联系方式")
|
||
async def update_profile(payload: dict, session: Session, auth: AuthCtx):
|
||
allowed = {"name", "phone", "email", "avatar"}
|
||
changed = {k: v for k, v in payload.items() if k in allowed}
|
||
for key, value in changed.items():
|
||
setattr(auth.user, key, value)
|
||
await session.commit()
|
||
return await _user_read(session, auth.user)
|
||
|
||
|
||
@router.get("/unread-count", summary="未读消息数")
|
||
async def unread_count(session: Session, auth: AuthCtx):
|
||
from sqlalchemy import func
|
||
|
||
total = (
|
||
await session.execute(
|
||
select(func.count()).select_from(Notification).where(
|
||
Notification.user_id == auth.user.id, Notification.is_read.is_(False)
|
||
)
|
||
)
|
||
).scalar_one()
|
||
return {"count": int(total)}
|