570 lines
23 KiB
Python
570 lines
23 KiB
Python
"""系统管理: 用户 / 角色 / 权限 / 菜单 / 公告 / 通知 / 操作日志."""
|
||
|
||
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")
|