unis_hrms/app/api/v1/system.py

570 lines
23 KiB
Python
Raw Permalink 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.

"""系统管理: 用户 / 角色 / 权限 / 菜单 / 公告 / 通知 / 操作日志."""
from __future__ import annotations
from datetime import datetime
from typing import Annotated
from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel, Field
from sqlalchemy import delete, func, select, update
from ...core.deps import AuthContext, Session, apply_employee_scope, get_auth_context, require_perm
from ...core.errors import AppError
from ...core.permissions import MODULES, menu_catalogue_order
from ...core.security import hash_password
from ..crud import CrudSpec, build_router
from ...models.employee import Employee
from ...models.rbac import (
Announcement, Menu, Notification, OperationLog, Permission,
RefreshToken, Role, RolePermission, User, UserRole,
)
from ...schemas.common import Message
from ...schemas.system import (
AnnouncementCreate, AnnouncementRead, AnnouncementUpdate,
AssignPermissionsPayload, AssignRolesPayload, MenuCreate, MenuRead, MenuUpdate,
NotificationRead, OperationLogRead, ResetPasswordPayload,
RoleCreate, RoleRead, RoleUpdate, UserCreate, UserRead, UserUpdate,
)
router = APIRouter()
def _row_to_dict(obj, extra: dict | None = None) -> dict:
data = {c.name: getattr(obj, c.name) for c in obj.__table__.columns}
data.update(extra or {})
return data
# ------------------------------------------------------------------- 用户账号
async def attach_user_roles(session, rows: list[User]) -> None:
if not rows:
return
ids = [r.id for r in rows]
pairs = (
await session.execute(
select(UserRole.user_id, Role.id, Role.code, Role.name, Role.data_scope)
.join(Role, Role.id == UserRole.role_id)
.where(UserRole.user_id.in_(ids))
)
).all()
grouped: dict[int, list[dict]] = {i: [] for i in ids}
for user_id, rid, code, name, scope in pairs:
grouped[user_id].append({"id": rid, "code": code, "name": name, "data_scope": scope})
for row in rows:
row.__dict__["roles"] = grouped.get(row.id, [])
row.__dict__["role_ids"] = [r["id"] for r in grouped.get(row.id, [])]
def read_user(obj: User) -> dict:
return _row_to_dict(obj, {"roles": obj.__dict__.get("roles") or [],
"role_ids": obj.__dict__.get("role_ids") or []})
async def _user_before(action, data, obj, auth, session):
if action == "create":
if not data.get("password"):
raise AppError("请设置初始密码", "password_required")
data["password_hash"] = hash_password(data.pop("password"))
data.pop("password", None)
# role_ids 不是 user 表的列:先摘出来暂存,等 after_write 拿到 user_id 再写关联表,
# 否则「新建用户时勾选的角色」会被静默丢弃,账号建出来什么模块都打不开。
role_ids = data.pop("role_ids", None)
if role_ids is not None:
auth.__dict__["_pending_role_ids"] = list(role_ids)
if data.get("is_superuser") and not auth.user.is_superuser:
raise AppError("只有超级管理员可以授予超级权限", "forbidden", 403)
return data
async def _user_after(action, obj, auth, session):
"""落库 _user_before 暂存的角色绑定(新增与编辑用户共用)。"""
role_ids = auth.__dict__.pop("_pending_role_ids", None)
if role_ids is None:
return
role_ids = sorted({int(rid) for rid in role_ids})
if role_ids:
found = (await session.execute(select(Role.id).where(Role.id.in_(role_ids)))).scalars().all()
if len(found) != len(role_ids):
raise AppError("包含不存在的角色", "bad_role")
await session.execute(delete(UserRole).where(UserRole.user_id == obj.id))
for rid in role_ids:
session.add(UserRole(user_id=obj.id, role_id=rid))
await session.flush()
# 角色变了 => 旧的刷新令牌作废,避免长时间沿用过期权限组合
await session.execute(delete(RefreshToken).where(RefreshToken.user_id == obj.id))
async def _user_delete(obj, auth, session):
if obj.is_superuser:
raise AppError("超级管理员账号不可删除", "protected")
await session.execute(delete(UserRole).where(UserRole.user_id == obj.id))
await session.execute(delete(RefreshToken).where(RefreshToken.user_id == obj.id))
async def _users_filter_hook(stmt, filters, session):
"""``?role_ids=1,2`` —— 角色不是 user 表字段,用关联表子查询过滤。"""
ids = [int(v) for v in str(filters.get("role_ids") or "").split(",") if v.strip().isdigit()]
if not ids:
return stmt
sub = select(UserRole.user_id).where(UserRole.role_id.in_(ids))
return stmt.where(User.id.in_(sub))
async def _users_list_hook(stmt, auth, session):
if not auth.can("system:user:read") or auth.data_scope == "self":
return stmt.where(User.id == auth.user.id)
return stmt
users_custom = APIRouter()
@users_custom.get("/me", summary="当前用户(兼容路径)", include_in_schema=False)
async def users_me(session: Session, auth: AuthCtxDep):
await attach_user_roles(session, [auth.user])
return read_user(auth.user)
async def _role_before(action, data, obj, auth, session):
if obj is not None and obj.is_builtin:
if data.get("code") and data["code"] != obj.code:
raise AppError("内置角色的编码不允许修改", "protected")
if data.get("is_active") is False:
raise AppError("内置角色不允许停用", "protected")
if data.get("data_scope") and data["data_scope"] not in ("all", "dept_tree", "dept", "self"):
raise AppError("数据范围取值不合法", "bad_scope")
return data
async def _role_delete(obj, auth, session):
if obj.is_builtin:
raise AppError("内置角色不可删除", "protected")
users = (
await session.execute(select(func.count()).select_from(UserRole).where(UserRole.role_id == obj.id))
).scalar_one()
if users:
raise AppError(f"该角色下还有 {users} 个用户,请先解除关联", "in_use")
await session.execute(delete(RolePermission).where(RolePermission.role_id == obj.id))
async def attach_role_counts(session, rows: list[Role]) -> None:
if not rows:
return
ids = [r.id for r in rows]
perm_counts = dict(
(await session.execute(
select(RolePermission.role_id, func.count()).where(RolePermission.role_id.in_(ids))
.group_by(RolePermission.role_id)
)).all()
)
user_counts = dict(
(await session.execute(
select(UserRole.role_id, func.count()).where(UserRole.role_id.in_(ids))
.group_by(UserRole.role_id)
)).all()
)
for row in rows:
row.__dict__["permission_count"] = int(perm_counts.get(row.id, 0))
row.__dict__["user_count"] = int(user_counts.get(row.id, 0))
def read_role(obj: Role) -> dict:
return _row_to_dict(obj, {"permission_count": obj.__dict__.get("permission_count", 0),
"user_count": obj.__dict__.get("user_count", 0)})
AuthCtxDep = Annotated[AuthContext, Depends(get_auth_context)]
user_router = build_router(
CrudSpec(
model=User, create=UserCreate, update=UserUpdate, read=UserRead,
module="system", resource="user", label="用户", prefix="/users", tag="系统管理",
search_fields=("username", "name", "phone", "email"), filters=("is_active", "employee_id"),
order_by="id", order="asc", label_field="name", after_read=attach_user_roles,
before_write=_user_before, after_write=_user_after, extra_query=("role_ids",),
filter_hook=_users_filter_hook, on_delete=_user_delete, list_hook=_users_list_hook,
),
preface=[users_custom],
)
class GenerateAccountsPayload(BaseModel):
employee_ids: list[int] = Field(min_length=1)
role_ids: list[int] = Field(min_length=1)
password: str = Field(default="Hrms@123456", min_length=6, max_length=64)
@user_router.post("/from-employees", summary="根据员工档案批量生成账号")
async def generate_accounts_from_employees(
payload: GenerateAccountsPayload,
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:user:create"))],
):
"""按工号生成登录账号:一个员工档案最多绑定一个账号。
已绑定账号的档案会跳过并返回原因;账号名冲突时自动追加序号。
"""
role_ids = sorted({int(rid) for rid in payload.role_ids})
roles = (await session.execute(select(Role).where(Role.id.in_(role_ids)))).scalars().all()
if len(roles) != len(role_ids):
raise AppError("包含不存在的角色", "bad_role")
if any(not role.is_active for role in roles):
raise AppError("不能分配已停用的角色", "bad_role")
if not auth.user.is_superuser and any(role.code == "super_admin" for role in roles):
raise AppError("只有超级管理员可以分配超级管理员角色", "forbidden", 403)
role_map = {role.id: role for role in roles}
roles = [role_map[rid] for rid in role_ids]
employee_ids = sorted({int(eid) for eid in payload.employee_ids})
employee_stmt = select(Employee).where(Employee.id.in_(employee_ids))
employee_stmt = await apply_employee_scope(session, employee_stmt, auth, Employee.id)
employees = list((await session.execute(employee_stmt)).scalars().all())
if len(employees) != len(employee_ids):
raise AppError("包含不存在的员工档案", "not_found", 404)
linked = {
row[0]: row[1] for row in (
await session.execute(
select(User.employee_id, User.username).where(User.employee_id.in_(employee_ids))
)
).all()
}
usernames = {
username.casefold()
for username in (await session.execute(select(User.username))).scalars().all()
}
created: list[dict] = []
skipped: list[dict] = []
for emp in sorted(employees, key=lambda e: e.id):
if emp.id in linked:
skipped.append({"employee_id": emp.id, "name": emp.name,
"reason": f"已绑定账号 {linked[emp.id]}"})
continue
if emp.status == "resigned":
skipped.append({"employee_id": emp.id, "name": emp.name, "reason": "员工已离职"})
continue
if not emp.is_active:
skipped.append({"employee_id": emp.id, "name": emp.name, "reason": "档案已停用"})
continue
base = (emp.work_no or f"emp{emp.id:05d}").strip().lower().replace(" ", "") or f"emp{emp.id:05d}"
username, suffix = base, 2
while username.casefold() in usernames:
username = f"{base}{suffix}"
suffix += 1
usernames.add(username.casefold())
user = User(
username=username, password_hash=hash_password(payload.password),
name=emp.name, email=emp.email, phone=emp.phone, employee_id=emp.id,
is_active=bool(emp.is_active), is_superuser=False, remark="由员工档案生成",
)
session.add(user)
await session.flush()
for rid in role_ids:
session.add(UserRole(user_id=user.id, role_id=rid))
created.append({"employee_id": emp.id, "name": emp.name, "username": username})
await session.commit()
return {
"message": f"已生成 {len(created)} 个账号" + (f",跳过 {len(skipped)} 个" if skipped else ""),
"created": created,
"skipped": skipped,
"password": payload.password,
"roles": [role.name for role in roles],
}
@user_router.post("/{item_id}/roles", response_model=Message, summary="分配角色")
async def assign_roles(
item_id: int, payload: AssignRolesPayload, session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:user:assign_role"))],
):
user = await session.get(User, item_id)
if not user:
raise AppError("用户不存在", "not_found", 404)
roles = (await session.execute(select(Role).where(Role.id.in_(payload.role_ids)))).scalars().all()
if len(roles) != len(set(payload.role_ids)):
raise AppError("包含不存在的角色", "bad_role")
await session.execute(delete(UserRole).where(UserRole.user_id == item_id))
for role in roles:
session.add(UserRole(user_id=item_id, role_id=role.id))
await session.execute(delete(RefreshToken).where(RefreshToken.user_id == item_id))
await session.commit()
return Message(message=f"已为 {user.name} 配置 {len(roles)} 个角色")
@user_router.post("/{item_id}/reset-password", response_model=Message, summary="重置密码")
async def reset_password(
item_id: int, payload: ResetPasswordPayload, session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:user:reset"))],
):
user = await session.get(User, item_id)
if not user:
raise AppError("用户不存在", "not_found", 404)
user.password_hash = hash_password(payload.password)
await session.execute(delete(RefreshToken).where(RefreshToken.user_id == item_id))
await session.commit()
return Message(message=f"{user.name} 的密码已重置")
router.include_router(user_router)
role_router = build_router(
CrudSpec(
model=Role, create=RoleCreate, update=RoleUpdate, read=RoleRead,
module="system", resource="role", label="角色", prefix="/roles", tag="系统管理",
search_fields=("code", "name"), filters=("is_active", "data_scope"),
order_by="sort", order="asc",
after_read=attach_role_counts, before_write=_role_before, on_delete=_role_delete,
)
)
@role_router.get("/{item_id}/permissions", summary="角色的权限 ID")
async def role_permissions(
item_id: int, session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:role:read"))],
):
ids = (
await session.execute(select(RolePermission.permission_id).where(RolePermission.role_id == item_id))
).scalars().all()
return {"role_id": item_id, "permission_ids": list(ids)}
@role_router.put("/{item_id}/permissions", response_model=Message, summary="保存角色权限")
async def save_role_permissions(
item_id: int, payload: AssignPermissionsPayload, session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:role:assign"))],
):
role = await session.get(Role, item_id)
if not role:
raise AppError("角色不存在", "not_found", 404)
if role.code == "super_admin":
raise AppError("超级管理员默认拥有全部权限,无需配置", "protected")
valid = set(
(await session.execute(select(Permission.id).where(Permission.id.in_(payload.permission_ids))))
.scalars().all()
)
if set(payload.permission_ids) - valid:
raise AppError("包含无效的权限项", "bad_permission")
await session.execute(delete(RolePermission).where(RolePermission.role_id == item_id))
for pid in payload.permission_ids:
session.add(RolePermission(role_id=item_id, permission_id=pid))
if payload.data_scope:
role.data_scope = payload.data_scope
await session.commit()
return Message(message=f"角色「{role.name}」的权限已更新")
router.include_router(role_router)
@router.get("/permissions", summary="权限清单(按模块分组,顺序跟随主界面菜单)")
async def permission_catalogue(session: Session, auth: AuthCtxDep):
rows = (await session.execute(select(Permission))).scalars().all()
grouped: dict[str, dict] = {}
for perm in rows:
module_meta = MODULES.get(perm.module, {})
resource_meta = module_meta.get("resources", {}).get(perm.resource, {})
module = grouped.setdefault(
perm.module,
{"module": perm.module, "label": module_meta.get("label", perm.module),
"icon": module_meta.get("icon"), "resources": {}},
)
resource = module["resources"].setdefault(
perm.resource,
{"resource": perm.resource, "label": resource_meta.get("label", perm.resource), "actions": []},
)
resource["actions"].append({"id": perm.id, "code": perm.code, "name": perm.name,
"action": perm.action})
for module in grouped.values():
declared = MODULES.get(module["module"], {}).get("resources", {})
for resource in module["resources"].values():
actions = declared.get(resource["resource"], {}).get("actions", [])
# 权限点顺序 = 代码里声明的动作顺序(read/create/…),未登记的排末尾
resource["actions"].sort(
key=lambda a: (actions.index(a["action"]) if a["action"] in actions else len(actions),
a["id"]),
)
module["resources"] = list(module["resources"].values())
# 角色授权页的树必须和左侧主菜单同序,否则「系统管理排在最上面」非常别扭。
# 顺序的唯一来源是菜单树本身(menu_catalogue_order),不再按 module 字母排。
module_order, resource_order = menu_catalogue_order()
rank = module_order.index
modules = sorted(
grouped.values(),
key=lambda m: (rank(m["module"]) if m["module"] in module_order else len(module_order),
m["module"]),
)
for module in modules:
order = resource_order.get(module["module"], [])
module["resources"].sort(
key=lambda r: (order.index(r["resource"]) if r["resource"] in order else len(order),
r["resource"]),
)
return {"modules": modules, "total": len(rows)}
# ------------------------------------------------------------------ 菜单导航
menu_router = build_router(
CrudSpec(
model=Menu, create=MenuCreate, update=MenuUpdate, read=MenuRead,
module="system", resource="menu", label="菜单", prefix="/menus", tag="系统管理",
search_fields=("name", "path"), filters=("platform", "visible"), order_by="sort", order="asc",
)
)
@menu_router.get("/tree", summary="菜单树(管理视图)")
async def menu_tree(
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:menu:read"))],
platform: str = Query("web"),
):
rows = (
await session.execute(select(Menu).where(Menu.platform == platform).order_by(Menu.sort, Menu.id))
).scalars().all()
nodes = {m.id: {**_row_to_dict(m), "children": []} for m in rows}
roots = []
for node in nodes.values():
parent = nodes.get(node["parent_id"])
(parent["children"] if parent else roots).append(node)
return roots
router.include_router(menu_router)
# --------------------------------------------------------------- 公告 / 通知
router.include_router(build_router(CrudSpec(
model=Announcement, create=AnnouncementCreate, update=AnnouncementUpdate, read=AnnouncementRead,
module="system", resource="announcement", label="公告", prefix="/announcements", tag="系统管理",
search_fields=("title", "content"), filters=("category", "level", "is_published", "target"),
order_by="published_at", order="desc",
)))
async def _notification_scope(stmt, auth, session):
return stmt.where(Notification.user_id == auth.user.id)
notification_router = build_router(CrudSpec(
model=Notification, create=NotificationRead, update=NotificationRead, read=NotificationRead,
module="selfservice", resource="home", label="站内消息", prefix="/notifications", tag="员工自助",
search_fields=("title",), filters=("category", "is_read"), order_by="created_at", order="desc",
list_hook=_notification_scope, write=False, options=False,
))
@notification_router.post("/read-all", response_model=Message, summary="全部标记已读")
async def notifications_read_all(session: Session, auth: AuthCtxDep):
await session.execute(
update(Notification)
.where(Notification.user_id == auth.user.id, Notification.is_read.is_(False))
.values(is_read=True)
)
await session.commit()
return Message(message="已全部标记为已读")
router.include_router(notification_router)
# ------------------------------------------------------------------ 操作日志
router.include_router(build_router(CrudSpec(
model=OperationLog, create=OperationLogRead, update=OperationLogRead, read=OperationLogRead,
module="system", resource="log", label="操作日志", prefix="/logs", tag="系统管理",
search_fields=("username", "module", "action", "path"), filters=("user_id", "module", "action", "method", "status_code"),
date_range_fields=("created_at",), order_by="created_at", order="desc",
write=False, deletable=False, options=False,
)))
# --------------------------------------------------------------- 数据维护 ----
class PurgePayload(BaseModel):
"""破坏性操作必须手打确认短语,避免误点。"""
confirm: str
keep_username: str | None = None
PURGE_PHRASE = "unis_hrms"
maintenance_router = APIRouter()
def _download(data: bytes, filename: str, media_type: str):
from urllib.parse import quote
from fastapi.responses import StreamingResponse
import io
return StreamingResponse(
io.BytesIO(data),
media_type=media_type,
headers={"Content-Disposition": f"attachment; filename*=UTF-8''{quote(filename)}"},
)
@maintenance_router.get("/overview", summary="数据概况")
async def maintenance_overview(
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:maintenance:read"))],
):
from ...services import maintenance
return await maintenance.overview(session)
@maintenance_router.get("/backup", summary="一键备份(下载 zip)")
async def maintenance_backup(
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:maintenance:backup"))],
):
from ...services import maintenance
data = await maintenance.build_backup_zip(session)
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
return _download(data, f"UNIS-HRMS-备份-{stamp}.zip", "application/zip")
@maintenance_router.get("/export", summary="导出全部数据(Excel)")
async def maintenance_export(
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:maintenance:export"))],
):
from ...services import maintenance
data = await maintenance.build_export_workbook(session)
stamp = datetime.now().strftime("%Y%m%d")
return _download(
data, f"UNIS-HRMS-数据导出-{stamp}.xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
)
@maintenance_router.post("/purge", summary="清空全部业务数据(仅保留系统管理员)")
async def maintenance_purge(
payload: PurgePayload,
session: Session,
auth: Annotated[AuthContext, Depends(require_perm("system:maintenance:purge"))],
):
from ...services import maintenance
if not auth.user.is_superuser:
raise AppError("只有超级管理员可以清空数据", "forbidden", 403)
if payload.confirm.strip() != PURGE_PHRASE:
raise AppError(f"请完整输入「{PURGE_PHRASE}」后再执行", "confirm_required")
if payload.keep_username and payload.keep_username.strip() != auth.user.username:
raise AppError("只能保留当前登录的系统管理员账号", "bad_keep_user")
result = await maintenance.purge_all_data(session)
return {
"message": f"已清空全部业务数据,保留 {len(result['kept_users'])} 个系统管理员账号",
**result,
}
router.include_router(maintenance_router, prefix="/maintenance")