532 lines
29 KiB
Python
532 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""角色与权限(RBAC)。
|
||
|
||
改这个的原因:现在的"权限"是九处散落的 `roles=("admin","operator")` 元组。想给
|
||
运营加一个"能看统计但不能改模型"的角色,或者临时收回某人发版的能力,都得改代
|
||
码、重新发布。角色和能力是运营策略,不该固化在代码里。
|
||
|
||
模型是标准三层:
|
||
|
||
用户 ──role──→ 角色 ──role_permissions──→ 权限码
|
||
|
||
代码里只判**权限码**(`model:write`),永远不判角色名。这样加角色、调能力都只
|
||
是改数据;代码里那句 `require("model:write")` 一个字都不用动。
|
||
|
||
内置的三个角色可以改权限,但不能删——删掉 admin 就没人能进后台了。
|
||
|
||
权限码按「权限菜单」组织:一级菜单 → 页面 → 权限码,和管理后台左侧菜单一一对应,
|
||
角色界面照这个结构勾选。权限码有三个来源(`permissions.source`):
|
||
|
||
builtin 下面 PERMISSIONS 里登记的,随代码发布,界面上只读
|
||
custom 管理员在「权限菜单」页自己加的权限点或菜单链接,可改可删
|
||
discovered 代码里 require() 用到、却忘了在 PERMISSIONS 登记的码——API 启动时
|
||
自动登记到「未归类」,免得新功能上线了、角色界面里却勾不到
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
import sqlite3
|
||
from typing import Any, Iterable, NamedTuple
|
||
|
||
|
||
class Permission(NamedTuple):
|
||
code: str
|
||
name: str
|
||
group: str # 一级菜单
|
||
page: str # 页面(二级菜单);没有页面的纯接口权限也写一个说明性的名字
|
||
kind: str = "action" # page = 能打开这个页面;action = 页面里的按钮
|
||
# 新拆出来的权限码第一次上线时,自动授给已持有这些旧码之一的角色,上线前后能做的事不变。
|
||
implied_by: tuple[str, ...] = ()
|
||
|
||
|
||
# ── 权限菜单 ─────────────────────────────────────────────────────────────────
|
||
# 命名规则 `资源:动作`。每个页面一个「页面」码(能打开它),页面里**每个按钮**一个码——
|
||
# 角色界面里能单独勾掉「删除」却保留「编辑」。接口按按钮的码判,前端按同一个码显示按钮。
|
||
# 加页面或按钮时在这里登记一行;前端 `router/routes/modules/console.ts` 里每个页面的
|
||
# `meta.authority` 都必须在这里有,「权限菜单」页会把没登记的码标出来。
|
||
#
|
||
# 2026-10 拆按钮时**保留了原来的码**,只是把它收窄成其中一个按钮(如 model:write 现在只管「编辑」),
|
||
# 新拆出来的按钮码用 implied_by 在第一次上线时授给持有原码的角色——上线前后每个角色能做的事完全一样;
|
||
# 回滚到旧版本时旧码还在,也不会有人突然少了权限。
|
||
PERMISSIONS: list[Permission] = [
|
||
Permission("model:read", "查看模型清单", "AI 模型", "模型清单", "page"),
|
||
Permission("model:create", "新增模型", "AI 模型", "模型清单", implied_by=("model:write",)),
|
||
Permission("model:write", "编辑模型(含启用 / 停用、更换密钥)", "AI 模型", "模型清单"),
|
||
Permission("model:test", "测连通", "AI 模型", "模型清单", implied_by=("model:write",)),
|
||
Permission("model:delete", "删除模型", "AI 模型", "模型清单", implied_by=("model:write",)),
|
||
Permission("model-plan:read", "查看角色编排", "AI 模型", "角色编排", "page", ("model:read", "model:write")),
|
||
Permission("model-plan:write", "保存角色编排(生成新版本)", "AI 模型", "角色编排", implied_by=("model:write",)),
|
||
Permission("agent:read", "查看智能体与协作方案", "AI 模型", "智能体", "page"),
|
||
Permission("agent:create", "新增智能体", "AI 模型", "智能体", implied_by=("agent:write",)),
|
||
Permission("agent:write", "编辑智能体", "AI 模型", "智能体"),
|
||
Permission("agent:delete", "删除智能体", "AI 模型", "智能体", implied_by=("agent:write",)),
|
||
Permission("agent-plan:write", "保存协作方案(生成新版本)", "AI 模型", "智能体", implied_by=("agent:write",)),
|
||
Permission("stats:read", "查看调用统计、Token 用量与知识引用记录", "AI 模型", "调用统计", "page"),
|
||
Permission("desktop-account:read", "查看客户端账号", "桌面端", "客户端账号", "page"),
|
||
Permission("desktop-account:write", "修改账号策略(启用 / 禁用、自动备份)", "桌面端", "客户端账号"),
|
||
Permission("desktop-account:assign", "分配可查看该账号数据的管理端用户", "桌面端", "客户端账号",
|
||
implied_by=("desktop-account:write",)),
|
||
Permission("desktop-account:revoke", "强制下线", "桌面端", "客户端账号", implied_by=("desktop-account:write",)),
|
||
Permission("desktop-account:all", "查看全部客户端数据(不受账号分配限制)", "桌面端", "客户端账号"),
|
||
Permission("config:read", "查看客户端配置", "桌面端", "客户端配置", "page"),
|
||
Permission("config:write", "保存并发布客户端配置(能力开关、审核规则、MCP 等)", "桌面端", "客户端配置"),
|
||
Permission("release:read", "查看版本升级与升级进度", "桌面端", "版本升级", "page", ("config:read",)),
|
||
Permission("release:upload", "上传安装包", "桌面端", "版本升级", implied_by=("release:write",)),
|
||
Permission("release:write", "发布客户端版本", "桌面端", "版本升级"),
|
||
Permission("im:read", "查看归档概览", "聊天归档", "归档概览", "page"),
|
||
Permission("im:content:read", "查看聊天正文与素材", "聊天归档", "会话与消息", "page"),
|
||
Permission("im:export", "查看导出记录", "聊天归档", "导出中心", "page"),
|
||
Permission("im:export:create", "新建导出", "聊天归档", "导出中心", implied_by=("im:export",)),
|
||
Permission("im:export:download", "下载导出文件", "聊天归档", "导出中心", implied_by=("im:export",)),
|
||
Permission("im:identity:read", "查看人员唯一标识与患者关联", "聊天归档", "人员唯一标识", "page",
|
||
("im:identity:write",)),
|
||
Permission("im:identity:write", "确认绑定人员标识", "聊天归档", "人员唯一标识"),
|
||
Permission("im:patient:bind", "搜索并关联患者", "聊天归档", "人员唯一标识", implied_by=("im:identity:write",)),
|
||
Permission("im:patient:unbind", "解除患者关联", "聊天归档", "人员唯一标识", implied_by=("im:identity:write",)),
|
||
Permission("im:storage:read", "查看 COS 存储配置与用量", "聊天归档", "COS 存储", "page", ("im:storage:write",)),
|
||
Permission("im:storage:write", "保存存储配置", "聊天归档", "COS 存储"),
|
||
Permission("im:storage:test", "测试连接", "聊天归档", "COS 存储", implied_by=("im:storage:write",)),
|
||
Permission("im:import", "导入聊天记录", "聊天归档", "导入接口"),
|
||
Permission("knowledge:read", "查看知识中心(知识列表、详情、整理任务)", "知识中心", "知识加工与检索", "page"),
|
||
Permission("knowledge:run", "整理聊天记录(新建整理)", "知识中心", "知识加工与检索", implied_by=("knowledge:write",)),
|
||
Permission("knowledge:run:control", "暂停 / 继续 / 取消整理、换模型", "知识中心", "知识加工与检索",
|
||
implied_by=("knowledge:write",)),
|
||
Permission("knowledge:settings", "修改整理设置", "知识中心", "知识加工与检索", implied_by=("knowledge:write",)),
|
||
Permission("knowledge:watch", "开关新聊天自动整理", "知识中心", "知识加工与检索", implied_by=("knowledge:write",)),
|
||
Permission("knowledge:write", "编辑知识(保存草稿)", "知识中心", "知识加工与检索"),
|
||
Permission("knowledge:restore", "恢复历史版本为草稿", "知识中心", "知识加工与检索", implied_by=("knowledge:write",)),
|
||
Permission("knowledge:delete", "删除已驳回知识", "知识中心", "知识加工与检索", implied_by=("knowledge:write",)),
|
||
Permission("knowledge:review", "审核通过(含批量审核)", "知识中心", "知识加工与检索"),
|
||
Permission("knowledge:reject", "驳回", "知识中心", "知识加工与检索", implied_by=("knowledge:review",)),
|
||
Permission("knowledge:review:auto", "一键审核(后台审核任务)", "知识中心", "知识加工与检索",
|
||
implied_by=("knowledge:review",)),
|
||
Permission("knowledge:publish", "发布知识(含发布选中)", "知识中心", "知识加工与检索"),
|
||
Permission("knowledge:disable", "停用已发布知识", "知识中心", "知识加工与检索", implied_by=("knowledge:publish",)),
|
||
Permission("knowledge:enable", "开关「客服使用知识」", "知识中心", "知识加工与检索", implied_by=("knowledge:publish",)),
|
||
Permission("knowledge:search", "检索测试", "知识中心", "知识加工与检索", implied_by=("knowledge:read",)),
|
||
Permission("knowledge:export", "导出已发布知识", "知识中心", "知识加工与检索"),
|
||
Permission("role:read", "查看角色", "系统管理", "角色权限", "page", ("user:read",)),
|
||
Permission("role:create", "新增角色", "系统管理", "角色权限", implied_by=("role:write",)),
|
||
Permission("role:write", "修改角色名称与权限", "系统管理", "角色权限"),
|
||
Permission("role:delete", "删除角色", "系统管理", "角色权限", implied_by=("role:write",)),
|
||
Permission("permission:read", "查看权限菜单", "系统管理", "权限菜单", "page", ("role:read", "role:write")),
|
||
Permission("permission:create", "新增权限点、菜单链接", "系统管理", "权限菜单", implied_by=("role:write",)),
|
||
Permission("permission:write", "编辑权限点、菜单链接", "系统管理", "权限菜单", implied_by=("role:write",)),
|
||
Permission("permission:delete", "删除自定义权限点、菜单链接", "系统管理", "权限菜单", implied_by=("role:write",)),
|
||
Permission("user:read", "查看用户", "系统管理", "用户管理", "page"),
|
||
Permission("user:create", "新增用户", "系统管理", "用户管理", implied_by=("user:write",)),
|
||
Permission("user:write", "修改用户角色", "系统管理", "用户管理"),
|
||
Permission("user:status", "启用 / 停用用户", "系统管理", "用户管理", implied_by=("user:write",)),
|
||
Permission("audit:read", "查看审计日志", "系统管理", "审计日志", "page"),
|
||
]
|
||
|
||
PERMISSION_CODES = frozenset(item.code for item in PERMISSIONS)
|
||
|
||
UNGROUPED = "未归类"
|
||
CODE_PATTERN = re.compile(r"^[a-z][a-z0-9-]*(?::[a-z0-9-]+)+$")
|
||
ICON_PATTERN = re.compile(r"^[a-z0-9-]+:[a-z0-9-]+$")
|
||
CUSTOM_KINDS = {"action", "link"}
|
||
LINK_MODES = {"tab", "iframe"}
|
||
|
||
# ── 内置角色 ─────────────────────────────────────────────────────────────────
|
||
# 这里给的只是**初始**授权。装好之后运营可以在界面上改,改完立刻生效。
|
||
BUILTIN_ROLES: list[tuple[str, str, list[str]]] = [
|
||
("zyt_basic", "集团基础用户", []),
|
||
("admin", "管理员", sorted(PERMISSION_CODES)),
|
||
(
|
||
"operator",
|
||
"配置员",
|
||
[
|
||
"config:read", "config:write",
|
||
"model:read", "model:create", "model:write", "model:test", "model:delete",
|
||
"model-plan:read", "model-plan:write",
|
||
"agent:read", "agent:create", "agent:write", "agent:delete", "agent-plan:write",
|
||
"stats:read", "audit:read",
|
||
"release:read", "release:upload", "release:write",
|
||
"user:read", "role:read", "permission:read",
|
||
],
|
||
),
|
||
(
|
||
"viewer",
|
||
"只读用户",
|
||
[
|
||
"config:read", "model:read", "model-plan:read", "agent:read",
|
||
"release:read", "stats:read", "user:read", "role:read", "permission:read",
|
||
],
|
||
),
|
||
]
|
||
|
||
BUILTIN_ROLE_CODES = frozenset(code for code, _name, _perms in BUILTIN_ROLES)
|
||
|
||
SCHEMA = """
|
||
CREATE TABLE IF NOT EXISTS roles (
|
||
code TEXT PRIMARY KEY,
|
||
name TEXT NOT NULL,
|
||
builtin INTEGER NOT NULL DEFAULT 0,
|
||
created_at TEXT NOT NULL,
|
||
updated_at TEXT NOT NULL
|
||
);
|
||
CREATE TABLE IF NOT EXISTS permissions (
|
||
code TEXT PRIMARY KEY,
|
||
name TEXT NOT NULL,
|
||
group_name TEXT NOT NULL DEFAULT ''
|
||
);
|
||
CREATE TABLE IF NOT EXISTS role_permissions (
|
||
role_code TEXT NOT NULL REFERENCES roles(code) ON DELETE CASCADE,
|
||
permission_code TEXT NOT NULL REFERENCES permissions(code) ON DELETE CASCADE,
|
||
PRIMARY KEY (role_code, permission_code)
|
||
);
|
||
CREATE INDEX IF NOT EXISTS idx_role_perms ON role_permissions(role_code);
|
||
"""
|
||
|
||
# 权限菜单的列是后加的:老库只有 code/name/group_name,启动时按需补列。
|
||
# 只加列不改列——回滚到老版本时,老代码照样只读它认识的三列。
|
||
PERMISSION_COLUMNS: dict[str, str] = {
|
||
"page_name": "TEXT NOT NULL DEFAULT ''",
|
||
"kind": "TEXT NOT NULL DEFAULT 'action'",
|
||
"source": "TEXT NOT NULL DEFAULT 'builtin'",
|
||
"sort_order": "INTEGER NOT NULL DEFAULT 0",
|
||
"link_url": "TEXT NOT NULL DEFAULT ''",
|
||
"link_mode": "TEXT NOT NULL DEFAULT ''",
|
||
"icon": "TEXT NOT NULL DEFAULT ''",
|
||
"enabled": "INTEGER NOT NULL DEFAULT 1",
|
||
"created_at": "TEXT NOT NULL DEFAULT ''",
|
||
"updated_at": "TEXT NOT NULL DEFAULT ''",
|
||
}
|
||
|
||
def _ensure_columns(db) -> None:
|
||
present = {row[1] for row in db.execute("PRAGMA table_info(permissions)")}
|
||
for column, ddl in PERMISSION_COLUMNS.items():
|
||
if column in present:
|
||
continue
|
||
try:
|
||
db.execute(f"ALTER TABLE permissions ADD COLUMN {column} {ddl}")
|
||
except sqlite3.OperationalError as exc:
|
||
# API、模型网关、知识加工进程同时启动时会抢着补同一列,晚到的那个跳过即可。
|
||
if "duplicate column" not in str(exc).lower():
|
||
raise
|
||
|
||
|
||
def seed(db, now: str) -> None:
|
||
"""建表、同步内置权限菜单并写入内置角色。可重复执行。
|
||
|
||
只在角色**第一次**出现时写默认授权——之后运营改过的授权不能被一次重启冲掉。
|
||
API、模型网关、知识加工进程启动时都会跑这一步,所以它必须并发安全、幂等。
|
||
"""
|
||
db.executescript(SCHEMA)
|
||
_ensure_columns(db)
|
||
for index, item in enumerate(PERMISSIONS):
|
||
db.execute(
|
||
"""INSERT INTO permissions
|
||
(code,name,group_name,page_name,kind,source,sort_order,
|
||
link_url,link_mode,icon,enabled,created_at,updated_at)
|
||
VALUES (?,?,?,?,?,'builtin',?,'','','',1,?,?)
|
||
ON CONFLICT(code) DO UPDATE SET name=excluded.name,
|
||
group_name=excluded.group_name, page_name=excluded.page_name,
|
||
kind=excluded.kind, source='builtin', sort_order=excluded.sort_order,
|
||
link_url='', link_mode='', icon='', enabled=1""",
|
||
(item.code, item.name, item.group, item.page, item.kind, index, now, now),
|
||
)
|
||
# 代码里删掉的内置权限码要连授权一起清掉,否则界面上会显示一堆不存在的能力。
|
||
# 自定义和自动登记的条目不归这里管。
|
||
db.execute(
|
||
"DELETE FROM permissions WHERE source='builtin' AND code NOT IN "
|
||
f"({','.join('?' for _ in PERMISSION_CODES)})",
|
||
tuple(sorted(PERMISSION_CODES)),
|
||
)
|
||
db.execute(
|
||
"DELETE FROM role_permissions WHERE permission_code NOT IN (SELECT code FROM permissions)"
|
||
)
|
||
# 从旧码拆出来的页面 / 按钮权限:没有任何角色持有它(刚上线,或被不认识它的旧版本清掉了),
|
||
# 就按旧码补授——原来能做这件事的角色上线后照样能做。之后管理员总持有全部权限码,
|
||
# 这一步不会再生效,界面上收回的授权不会被重启冲回来。按登记顺序处理,所以
|
||
# 「旧码 → 新页面码 → 更新的码」这种链条一次就能补齐。
|
||
for item in PERMISSIONS:
|
||
if not item.implied_by:
|
||
continue
|
||
held = db.execute(
|
||
"SELECT 1 FROM role_permissions WHERE permission_code=? LIMIT 1", (item.code,)
|
||
).fetchone()
|
||
if held is None:
|
||
db.execute(
|
||
f"""INSERT OR IGNORE INTO role_permissions (role_code,permission_code)
|
||
SELECT DISTINCT role_code, ? FROM role_permissions
|
||
WHERE permission_code IN ({','.join('?' for _ in item.implied_by)})""",
|
||
(item.code, *item.implied_by),
|
||
)
|
||
for code, name, defaults in BUILTIN_ROLES:
|
||
existing = db.execute("SELECT code FROM roles WHERE code=?", (code,)).fetchone()
|
||
db.execute(
|
||
"""INSERT INTO roles (code,name,builtin,created_at,updated_at)
|
||
VALUES (?,?,1,?,?)
|
||
ON CONFLICT(code) DO UPDATE SET name=excluded.name, builtin=1,
|
||
updated_at=excluded.updated_at""",
|
||
(code, name, now, now),
|
||
)
|
||
if existing is None:
|
||
db.executemany(
|
||
"INSERT OR IGNORE INTO role_permissions (role_code,permission_code) "
|
||
"VALUES (?,?)",
|
||
[(code, item) for item in defaults],
|
||
)
|
||
# This fixed enrollment role must always stay empty; managers assign another
|
||
# local role to grant access, so later enrollments cannot inherit broad access.
|
||
db.execute("DELETE FROM role_permissions WHERE role_code='zyt_basic'")
|
||
# 管理员角色不能在界面里被削权;新增权限(含自定义、自动登记的)时也要给管理员补齐。
|
||
_grant_admin_everything(db)
|
||
|
||
|
||
def _grant_admin_everything(db) -> None:
|
||
db.execute(
|
||
"""INSERT OR IGNORE INTO role_permissions (role_code,permission_code)
|
||
SELECT 'admin', code FROM permissions"""
|
||
)
|
||
|
||
|
||
def all_codes(db) -> set[str]:
|
||
"""库里登记的全部权限码:内置 + 自定义 + 自动登记。"""
|
||
return {row[0] for row in db.execute("SELECT code FROM permissions")}
|
||
|
||
|
||
def permissions_of(db, role_code: str) -> set[str]:
|
||
rows = db.execute(
|
||
"SELECT permission_code FROM role_permissions WHERE role_code=?",
|
||
(str(role_code or ""),),
|
||
).fetchall()
|
||
return {row[0] for row in rows}
|
||
|
||
|
||
def grant(db, role_code: str, codes: list[str], now: str) -> set[str]:
|
||
"""把一个角色的授权整体替换成给定集合。返回实际生效的权限码。
|
||
|
||
整体替换而不是增量:界面上是一组勾选框,用户提交的就是"最终状态"。增量语义
|
||
会让"取消勾选"变成静默无效——那种 bug 只有在出事之后才会被发现。
|
||
"""
|
||
role = db.execute("SELECT code FROM roles WHERE code=?", (role_code,)).fetchone()
|
||
if role is None:
|
||
raise ValueError(f"角色不存在:{role_code}")
|
||
wanted = {str(item).strip() for item in (codes or []) if str(item).strip()}
|
||
known = all_codes(db)
|
||
unknown = wanted - known
|
||
if unknown:
|
||
raise ValueError(f"未知权限码:{'、'.join(sorted(unknown))}")
|
||
if role_code == "admin" and wanted != known:
|
||
# 管理员被削权之后就没人能再把权限加回来了,只能改库。这道闸必须在。
|
||
raise ValueError("管理员角色的权限不可修改,否则会把自己锁在门外")
|
||
if role_code == "zyt_basic" and wanted:
|
||
raise ValueError("集团基础用户不能授予业务权限,请为用户分配其他本地角色")
|
||
db.execute("DELETE FROM role_permissions WHERE role_code=?", (role_code,))
|
||
db.executemany(
|
||
"INSERT INTO role_permissions (role_code,permission_code) VALUES (?,?)",
|
||
[(role_code, item) for item in sorted(wanted)],
|
||
)
|
||
db.execute("UPDATE roles SET updated_at=? WHERE code=?", (now, role_code))
|
||
return wanted
|
||
|
||
|
||
# ── 权限菜单的读写 ───────────────────────────────────────────────────────────
|
||
def _weight(row: dict[str, Any]) -> int:
|
||
"""排序权重:内置按登记顺序,自定义排在内置之后,自动登记的排最后。"""
|
||
offset = {"builtin": 0, "custom": 1000}.get(row["source"], 9000)
|
||
return offset + int(row["sort_order"] or 0)
|
||
|
||
|
||
def catalog(db) -> list[dict[str, Any]]:
|
||
"""权限菜单:每个权限码一行,带上它挂在哪个菜单/页面、哪些角色持有它。
|
||
|
||
排序:内置菜单按 PERMISSIONS 的登记顺序(也就是左侧菜单的顺序),自定义菜单
|
||
排在后面;同一菜单里内置在前,自定义按管理员填的排序。
|
||
"""
|
||
cursor = db.execute(
|
||
"""SELECT code,name,group_name,page_name,kind,source,sort_order,
|
||
link_url,link_mode,icon,enabled,updated_at FROM permissions"""
|
||
)
|
||
columns = [item[0] for item in cursor.description]
|
||
rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
|
||
holders: dict[str, list[str]] = {}
|
||
for role_code, code in db.execute(
|
||
"SELECT role_code, permission_code FROM role_permissions ORDER BY role_code"
|
||
).fetchall():
|
||
holders.setdefault(code, []).append(role_code)
|
||
group_order: dict[str, int] = {}
|
||
for row in rows:
|
||
group_order[row["group_name"]] = min(group_order.get(row["group_name"], 1 << 30), _weight(row))
|
||
rows.sort(key=lambda row: (group_order[row["group_name"]], row["group_name"], _weight(row), row["code"]))
|
||
return [
|
||
{
|
||
**row,
|
||
"sort_order": int(row["sort_order"] or 0),
|
||
"enabled": bool(row["enabled"]),
|
||
"roles": holders.get(row["code"], []),
|
||
}
|
||
for row in rows
|
||
]
|
||
|
||
|
||
def custom_menus(db, permissions: Iterable[str]) -> list[dict[str, Any]]:
|
||
"""当前用户能看到的自定义菜单链接(左侧菜单用)。"""
|
||
allowed = set(permissions)
|
||
return [
|
||
{key: item[key] for key in ("code", "name", "group_name", "link_url", "link_mode", "icon", "sort_order")}
|
||
for item in catalog(db)
|
||
if item["kind"] == "link" and item["enabled"] and item["code"] in allowed
|
||
]
|
||
|
||
|
||
def _clean_text(value: Any, label: str, limit: int, *, required: bool) -> str:
|
||
text = " ".join(str(value or "").split())
|
||
if required and not text:
|
||
raise ValueError(f"{label}不能为空")
|
||
if len(text) > limit:
|
||
raise ValueError(f"{label}不能超过 {limit} 个字")
|
||
return text
|
||
|
||
|
||
def _clean_link(value: Any) -> str:
|
||
url = str(value or "").strip()
|
||
if not url:
|
||
raise ValueError("菜单链接需要填写链接地址")
|
||
if len(url) > 1000:
|
||
raise ValueError("链接地址太长")
|
||
if any(ch.isspace() or ord(ch) < 32 for ch in url):
|
||
raise ValueError("链接地址里不能有空格或控制字符")
|
||
lowered = url.lower()
|
||
# 只认 http(s) 绝对地址和本站路径;javascript:、data: 之类一律不收
|
||
if lowered.startswith(("http://", "https://")):
|
||
if len(url.split("//", 1)[1].split("/", 1)[0]) == 0:
|
||
raise ValueError("链接地址缺少域名")
|
||
return url
|
||
if url.startswith("/") and not url.startswith("//"):
|
||
return url
|
||
raise ValueError("链接地址只能是 http(s):// 开头的网址,或以 / 开头的本站路径")
|
||
|
||
|
||
def _validated_custom(data: dict[str, Any], code: str) -> dict[str, Any]:
|
||
kind = str(data.get("kind") or "action").strip()
|
||
if kind not in CUSTOM_KINDS:
|
||
raise ValueError("类型只能是「权限点」或「菜单链接」")
|
||
item = {
|
||
"code": code,
|
||
"name": _clean_text(data.get("name"), "名称", 40, required=True),
|
||
"group_name": _clean_text(data.get("group_name"), "所属菜单", 20, required=True),
|
||
"page_name": _clean_text(data.get("page_name"), "所属页面", 40, required=False),
|
||
"kind": kind,
|
||
"link_url": "",
|
||
"link_mode": "",
|
||
"icon": "",
|
||
"enabled": 1 if data.get("enabled", True) else 0,
|
||
}
|
||
try:
|
||
sort_order = int(data.get("sort_order") if data.get("sort_order") is not None else 0)
|
||
except (TypeError, ValueError):
|
||
raise ValueError("排序必须是数字") from None
|
||
if not 0 <= sort_order <= 999:
|
||
raise ValueError("排序取 0–999")
|
||
item["sort_order"] = sort_order
|
||
if kind == "link":
|
||
item["link_url"] = _clean_link(data.get("link_url"))
|
||
mode = str(data.get("link_mode") or "tab").strip()
|
||
if mode not in LINK_MODES:
|
||
raise ValueError("打开方式只能是「新窗口」或「内嵌」")
|
||
item["link_mode"] = mode
|
||
icon = str(data.get("icon") or "").strip()
|
||
if icon and not ICON_PATTERN.fullmatch(icon):
|
||
raise ValueError("图标写成 lucide:link 这样的格式")
|
||
item["icon"] = icon
|
||
return item
|
||
|
||
|
||
def _clean_code(value: Any) -> str:
|
||
code = str(value or "").strip().lower()
|
||
if not CODE_PATTERN.fullmatch(code) or len(code) > 64:
|
||
raise ValueError("权限码写成 资源:动作,例如 report:read(小写字母、数字、连字符)")
|
||
return code
|
||
|
||
|
||
def create_custom(db, data: dict[str, Any], now: str) -> dict[str, Any]:
|
||
"""新增一条自定义权限点或菜单链接。管理员自动持有它。"""
|
||
code = _clean_code(data.get("code"))
|
||
existing = db.execute("SELECT source FROM permissions WHERE code=?", (code,)).fetchone()
|
||
if existing is not None:
|
||
raise ValueError(f"权限码已存在:{code}")
|
||
item = _validated_custom(data, code)
|
||
db.execute(
|
||
"""INSERT INTO permissions
|
||
(code,name,group_name,page_name,kind,source,sort_order,
|
||
link_url,link_mode,icon,enabled,created_at,updated_at)
|
||
VALUES (?,?,?,?,?,'custom',?,?,?,?,?,?,?)""",
|
||
(
|
||
code, item["name"], item["group_name"], item["page_name"], item["kind"],
|
||
item["sort_order"], item["link_url"], item["link_mode"], item["icon"],
|
||
item["enabled"], now, now,
|
||
),
|
||
)
|
||
_grant_admin_everything(db)
|
||
return item
|
||
|
||
|
||
def update_custom(db, code: str, data: dict[str, Any], now: str) -> dict[str, Any]:
|
||
"""改一条自定义或自动登记的条目。自动登记的改过之后就算自定义(不再随代码自动删)。"""
|
||
code = _clean_code(code)
|
||
existing = db.execute("SELECT source FROM permissions WHERE code=?", (code,)).fetchone()
|
||
if existing is None:
|
||
raise ValueError(f"权限码不存在:{code}")
|
||
if existing[0] == "builtin":
|
||
raise ValueError("内置权限随代码发布,不能在这里修改")
|
||
item = _validated_custom(data, code)
|
||
db.execute(
|
||
"""UPDATE permissions SET name=?, group_name=?, page_name=?, kind=?, source='custom',
|
||
sort_order=?, link_url=?, link_mode=?, icon=?, enabled=?, updated_at=?
|
||
WHERE code=?""",
|
||
(
|
||
item["name"], item["group_name"], item["page_name"], item["kind"],
|
||
item["sort_order"], item["link_url"], item["link_mode"], item["icon"],
|
||
item["enabled"], now, code,
|
||
),
|
||
)
|
||
return item
|
||
|
||
|
||
def delete_custom(db, code: str) -> None:
|
||
"""删一条自定义条目,连同各角色上的授权。内置和自动登记的不能删。"""
|
||
code = str(code or "").strip().lower()
|
||
existing = db.execute("SELECT source FROM permissions WHERE code=?", (code,)).fetchone()
|
||
if existing is None:
|
||
raise ValueError(f"权限码不存在:{code}")
|
||
if existing[0] == "builtin":
|
||
raise ValueError("内置权限随代码发布,不能删除")
|
||
if existing[0] == "discovered":
|
||
raise ValueError("这个权限码还在代码里使用,不能删除;不再使用后会自动移除")
|
||
db.execute("DELETE FROM role_permissions WHERE permission_code=?", (code,))
|
||
db.execute("DELETE FROM permissions WHERE code=?", (code,))
|
||
|
||
|
||
def sync_code_permissions(db, used: Iterable[str], now: str) -> list[str]:
|
||
"""代码里实际用到的权限码 → 权限菜单。返回这次新登记的码。
|
||
|
||
require() 用到了、却没在 PERMISSIONS 里登记的码,登记到「未归类」并授给管理员——
|
||
功能一上线就能在角色界面里勾选;以前自动登记、现在代码里不再用到的,自动移除。
|
||
只有 API 进程调它:只有它知道自己注册了哪些接口。
|
||
"""
|
||
wanted = {str(code).strip() for code in used if str(code or "").strip()}
|
||
existing = {
|
||
row[0]: row[1] for row in db.execute("SELECT code, source FROM permissions").fetchall()
|
||
}
|
||
added = sorted(wanted - set(existing))
|
||
for code in added:
|
||
db.execute(
|
||
"""INSERT INTO permissions
|
||
(code,name,group_name,page_name,kind,source,sort_order,
|
||
link_url,link_mode,icon,enabled,created_at,updated_at)
|
||
VALUES (?,?,?,'','action','discovered',0,'','','',1,?,?)""",
|
||
(code, code, UNGROUPED, now, now),
|
||
)
|
||
stale = [code for code, source in existing.items() if source == "discovered" and code not in wanted]
|
||
for code in stale:
|
||
db.execute("DELETE FROM role_permissions WHERE permission_code=?", (code,))
|
||
db.execute("DELETE FROM permissions WHERE code=?", (code,))
|
||
if added:
|
||
_grant_admin_everything(db)
|
||
return added
|