fourcal-pms/backend/app/api/system.py

539 lines
22 KiB
Python
Raw 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
import json
import logging
from typing import Any
from fastapi import APIRouter
from pydantic import BaseModel, Field
from sqlalchemy import select
from sqlalchemy.orm import Session
from .. import dicts as dict_store
from ..config import settings
from ..deps import DbSession, PrincipalOf
from ..envelope import conflict, forbidden, not_found, ok
from ..models import (
Effect,
FieldScope,
PermDataPolicy,
PermKind,
PermNode,
PermRole,
ScopeType,
SubjectType,
SystemConfig,
)
from ..service import data_scope, permissions
from ..service.calc import engine as calc_engine
from ..service.calc import rules as calc_rules
from ..service.biz import apply_sys_config
router = APIRouter(prefix="/system", tags=["system"])
logger = logging.getLogger("pms.api.system")
def _need(db, current: PrincipalOf, code: str) -> None:
if not current.permission.can(code):
raise forbidden(f"缺少权限:{code}")
# ---------------------------------------------------------------------------
# 菜单 / 权限目录
# ---------------------------------------------------------------------------
@router.get("/permissions/catalog")
def catalog(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:permission:view")
return ok({
"nodes": permissions.permission_catalog(db),
"kinds": list(PermKind.ALL),
"modules": data_scope.registered_modules(),
})
class NodeBody(BaseModel):
code: str = Field(min_length=1, max_length=128)
name: str = Field(min_length=1, max_length=128)
kind: str = PermKind.MENU
parentId: int = 0
path: str = ""
icon: str = ""
module: str = ""
sort: int = 100
visible: bool = True
enabled: bool = True
remark: str = ""
@router.post("/permissions/nodes")
def create_node(body: NodeBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:permission:edit")
if db.execute(select(PermNode).where(PermNode.code == body.code)).scalars().first():
raise conflict("duplicated_code", "权限码已存在")
node = PermNode(code=body.code, name=body.name, kind=body.kind, parent_id=body.parentId,
path=body.path, icon=body.icon, module=body.module, sort=body.sort,
visible=body.visible, enabled=body.enabled, remark=body.remark)
db.add(node)
db.commit()
return ok({"id": node.id})
@router.put("/permissions/nodes/{node_id}")
def update_node(node_id: int, body: NodeBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:permission:edit")
node = db.get(PermNode, node_id)
if node is None or node.is_deleted:
raise not_found("权限节点不存在")
for attr, value in (("name", body.name), ("kind", body.kind), ("parent_id", body.parentId),
("path", body.path), ("icon", body.icon), ("module", body.module),
("sort", body.sort), ("visible", body.visible), ("enabled", body.enabled),
("remark", body.remark)):
setattr(node, attr, value)
db.commit()
return ok({"id": node.id})
# ---------------------------------------------------------------------------
# 角色
# ---------------------------------------------------------------------------
class RoleBody(BaseModel):
code: str = Field(min_length=1, max_length=64)
name: str = Field(min_length=1, max_length=128)
enabled: bool = True
orderNumber: int = 100
remark: str = ""
@router.get("/roles")
def list_roles(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:view")
rows = db.execute(select(PermRole).where(PermRole.is_deleted.is_(False))
.order_by(PermRole.order_number, PermRole.id)).scalars().all()
return ok([{
"id": row.id, "code": row.code, "name": row.name, "builtin": row.builtin,
"enabled": row.enabled, "orderNumber": row.order_number, "remark": row.remark,
"permissionCount": len(permissions.role_permission_ids(db, row.id)),
} for row in rows])
@router.post("/roles")
def create_role(body: RoleBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:edit")
if db.execute(select(PermRole).where(PermRole.code == body.code)).scalars().first():
raise conflict("duplicated_code", "角色编码已存在")
role = PermRole(code=body.code, name=body.name, enabled=body.enabled,
order_number=body.orderNumber, remark=body.remark)
db.add(role)
db.commit()
return ok({"id": role.id})
@router.put("/roles/{role_id}")
def update_role(role_id: int, body: RoleBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:edit")
role = db.get(PermRole, role_id)
if role is None or role.is_deleted:
raise not_found("角色不存在")
role.name, role.enabled, role.order_number, role.remark = (
body.name, body.enabled, body.orderNumber, body.remark)
db.commit()
return ok({"id": role.id})
@router.delete("/roles/{role_id}")
def delete_role(role_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:edit")
role = db.get(PermRole, role_id)
if role is None or role.is_deleted:
raise not_found("角色不存在")
if role.builtin:
raise conflict("builtin_role", "内置角色不能删除")
role.is_deleted = True
db.commit()
return ok({"deleted": True})
@router.get("/roles/{role_id}/permissions")
def role_permissions(role_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:view")
return ok({"nodeIds": permissions.role_permission_ids(db, role_id)})
class NodeIdsBody(BaseModel):
nodeIds: list[int] = Field(default_factory=list)
@router.put("/roles/{role_id}/permissions")
def set_role_permissions(role_id: int, body: NodeIdsBody, db: DbSession,
current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:role:edit")
if db.get(PermRole, role_id) is None:
raise not_found("角色不存在")
count = permissions.set_role_permissions(db, role_id, body.nodeIds)
db.commit()
return ok({"count": count})
# ---------------------------------------------------------------------------
# 数据权限策略
# ---------------------------------------------------------------------------
class PolicyBody(BaseModel):
name: str = Field(min_length=1, max_length=128)
module: str = Field(min_length=1, max_length=64)
subjectType: str = SubjectType.ROLE
subjectId: int = 0
effect: str = Effect.ALLOW
scopeType: str = ScopeType.SELF
targetIds: list[int] = Field(default_factory=list)
includeChildren: bool = True
conditions: dict[str, Any] | None = None
priority: int = 100
enabled: bool = True
validFrom: str = ""
validTo: str = ""
remark: str = ""
@router.get("/data-policies")
def list_policies(db: DbSession, current: PrincipalOf, module: str = "") -> dict[str, Any]:
_need(db, current, "system:datapermission:view")
statement = select(PermDataPolicy).where(PermDataPolicy.is_deleted.is_(False))
if module:
statement = statement.where(PermDataPolicy.module == module)
rows = db.execute(statement.order_by(PermDataPolicy.module, PermDataPolicy.priority,
PermDataPolicy.id)).scalars().all()
return ok([_policy_view(db, row) for row in rows])
def _policy_view(db: Session, row: PermDataPolicy) -> dict[str, Any]:
labels = {item["module"]: item["label"] for item in data_scope.registered_modules()}
# covers 是这条策略真正管到哪几个模块:族代表一条管全族,成员模块上配的只管自己。
# 界面上不写清楚,管理员就会以为"某某 - budget"只管预算那一页。
covers = [{"module": key, "label": labels.get(key, key)}
for key in data_scope.policy_covers(row.module)]
return {
"id": row.id, "name": row.name, "module": row.module, "covers": covers,
"subjectType": row.subject_type, "subjectId": row.subject_id,
"effect": row.effect, "scopeType": row.scope_type,
"scopeLabel": dict_store.label(db, "scopeType", row.scope_type,
ScopeType.label(row.scope_type)),
"targetIds": _loads(row.target_ids_json, []),
"includeChildren": row.include_children,
"conditions": _loads(row.conditions_json, None),
"priority": row.priority, "enabled": row.enabled,
"validFrom": row.valid_from, "validTo": row.valid_to, "remark": row.remark,
}
def _loads(raw: str, default: Any) -> Any:
if not (raw or "").strip():
return default
try:
return json.loads(raw)
except json.JSONDecodeError:
return default
@router.post("/data-policies")
def create_policy(body: PolicyBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:datapermission:edit")
_validate_policy(body)
row = PermDataPolicy(
name=body.name, module=body.module, subject_type=body.subjectType, subject_id=body.subjectId,
effect=body.effect, scope_type=body.scopeType,
target_ids_json=json.dumps(body.targetIds), include_children=body.includeChildren,
conditions_json=json.dumps(body.conditions, ensure_ascii=False) if body.conditions else "",
priority=body.priority, enabled=body.enabled, valid_from=body.validFrom,
valid_to=body.validTo, remark=body.remark,
)
db.add(row)
db.commit()
return ok({"id": row.id})
@router.put("/data-policies/{policy_id}")
def update_policy(policy_id: int, body: PolicyBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:datapermission:edit")
row = db.get(PermDataPolicy, policy_id)
if row is None or row.is_deleted:
raise not_found("策略不存在")
_validate_policy(body)
row.name, row.module, row.subject_type, row.subject_id = body.name, body.module, body.subjectType, body.subjectId
row.effect, row.scope_type = body.effect, body.scopeType
row.target_ids_json = json.dumps(body.targetIds)
row.include_children = body.includeChildren
row.conditions_json = json.dumps(body.conditions, ensure_ascii=False) if body.conditions else ""
row.priority, row.enabled = body.priority, body.enabled
row.valid_from, row.valid_to = body.validFrom, body.validTo
row.remark = body.remark
db.commit()
return ok({"id": row.id})
@router.delete("/data-policies/{policy_id}")
def delete_policy(policy_id: int, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:datapermission:edit")
row = db.get(PermDataPolicy, policy_id)
if row is None or row.is_deleted:
raise not_found("策略不存在")
row.is_deleted = True
db.commit()
return ok({"deleted": True})
def _validate_policy(body: PolicyBody) -> None:
if body.module not in {item["module"] for item in data_scope.registered_modules()}:
raise conflict("unknown_module", f"未知的业务模块:{body.module}")
if body.scopeType not in ScopeType.ALL_TYPES:
raise conflict("unknown_scope", f"未知的数据范围:{body.scopeType}")
if body.subjectType not in SubjectType.ALL_TYPES:
raise conflict("unknown_subject", f"未知的主体类型:{body.subjectType}")
if body.subjectType != SubjectType.ALL and not body.subjectId:
raise conflict("subject_required", "除了「所有人」以外都必须选择具体主体")
if body.scopeType in (ScopeType.ORG_LIST, ScopeType.ACCOUNT_LIST) and not body.targetIds:
raise conflict("target_required", "「指定部门/指定人员」范围必须选择具体对象")
if body.conditions:
unknown = _unknown_fields(body.module, body.conditions)
if unknown:
raise conflict("unknown_condition_field",
"自定义条件里用了不支持的字段:" + "、".join(sorted(unknown)))
def _unknown_fields(module: str, tree: dict[str, Any], found: set[str] | None = None) -> set[str]:
spec = data_scope.spec_for(module)
allowed = set(spec.filterable.keys()) if spec else set()
unknown: set[str] = set()
for item in tree.get("items") or []:
unknown |= _unknown_fields(module, item)
field_name = tree.get("field")
if field_name and field_name not in allowed:
unknown.add(str(field_name))
return unknown
@router.get("/data-policies/options")
def policy_options(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
"""前端配置页要用的下拉数据,一次给全,省得配一条策略发五次请求。"""
_need(db, current, "system:datapermission:view")
specs = []
for item in data_scope.registered_modules():
spec = data_scope.spec_for(item["module"])
specs.append({
**item,
"filterable": sorted(spec.filterable.keys()) if spec else [],
"numeric": list(spec.numeric) if spec else [],
"covers": data_scope.policy_covers(item["module"]),
})
return ok({
"modules": specs,
# 这几组下拉值改从数据字典取:以前这里、权限模型里、前端各留一份中文名,
# 改一处漏两处("按人员/按账号"就是那么对不上的)。
"scopeTypes": dict_store.options(db, "scopeType"),
"subjectTypes": dict_store.options(db, "subjectType"),
"effects": dict_store.options(db, "effect"),
"operators": dict_store.options(db, "dataOperator"),
"dynamicValues": dict_store.options(db, "dynamicValue"),
"roles": [{"id": row.id, "name": row.name} for row in
db.execute(select(PermRole).where(PermRole.is_deleted.is_(False))).scalars().all()],
})
class ExplainBody(BaseModel):
accountId: int
module: str
@router.post("/data-policies/explain")
def explain(body: ExplainBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
""""我以这个人的身份打开这个模块会看到什么",配置完当场能验证。"""
_need(db, current, "system:datapermission:view")
from ..models import Account
account = db.get(Account, body.accountId)
if account is None or account.is_deleted:
raise not_found("账号不存在")
return ok(data_scope.explain(db, body.module, account))
# ---------------------------------------------------------------------------
# 字段权限
# ---------------------------------------------------------------------------
class FieldScopeBody(BaseModel):
module: str
field: str
roleId: int
mode: str = "hidden"
@router.get("/field-scopes")
def list_field_scopes(db: DbSession, current: PrincipalOf, module: str = "") -> dict[str, Any]:
_need(db, current, "system:datapermission:view")
statement = select(FieldScope).where(FieldScope.role_id.in_(
select(PermRole.id).where(PermRole.is_deleted.is_(False))))
if module:
statement = statement.where(FieldScope.module == module)
rows = db.execute(statement.order_by(FieldScope.module, FieldScope.field)).scalars().all()
roles = dict(db.execute(select(PermRole.id, PermRole.name)).all())
return ok([{"id": row.id, "module": row.module, "field": row.field, "roleId": row.role_id,
"roleName": roles.get(row.role_id, ""), "mode": row.mode} for row in rows])
@router.post("/field-scopes")
def set_field_scope(body: FieldScopeBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:datapermission:edit")
existing = db.execute(select(FieldScope).where(
FieldScope.module == body.module, FieldScope.field == body.field,
FieldScope.role_id == body.roleId)).scalars().first()
if existing:
existing.mode = body.mode
else:
db.add(FieldScope(module=body.module, field=body.field, role_id=body.roleId, mode=body.mode))
db.commit()
return ok({"saved": True})
# ---------------------------------------------------------------------------
# 业务参数
# ---------------------------------------------------------------------------
@router.get("/configs")
def list_configs(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:config:view")
rows = db.execute(select(SystemConfig).order_by(SystemConfig.group, SystemConfig.id)).scalars().all()
return ok([{"id": row.id, "code": row.code, "name": row.name, "value": row.value,
"valueType": row.value_type, "group": row.group, "editable": row.editable,
"remark": row.remark} for row in rows])
class ConfigBody(BaseModel):
value: str
@router.put("/configs/{code}")
def update_config(code: str, body: ConfigBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
_need(db, current, "system:config:edit")
if calc_rules.is_rule_code(code):
# 计算口径有专门的入口:那边按取值范围逐条校验、整套一起提交,
# 权限也是独立的(能改业务参数不等于能改财务口径)。
raise conflict("use_calc_rules", "计算口径请在「系统 → 计算口径」页面修改")
row = db.execute(select(SystemConfig).where(SystemConfig.code == code)).scalars().first()
if row is None:
raise not_found("参数不存在")
if not row.editable:
raise conflict("not_editable", "该参数不允许在界面上修改")
row.value = body.value
db.commit()
apply_sys_config(db)
return ok({"code": code, "value": row.value})
# ---------------------------------------------------------------------------
# 计算口径(system_config 里 group=calc / calc.* 那一批)
# ---------------------------------------------------------------------------
@router.get("/calc-rules")
def get_calc_rules(db: DbSession, current: PrincipalOf) -> dict[str, Any]:
"""口径清单:每条的当前生效值、默认值、库里的原样、取值范围与规则说明。
页面照着这份渲染(枚举给下拉、开关给拨把、数字给步进框),不在前端抄一份常量表——
前端那份和内核那份迟早对不上,而对不上的是算钱的口径。
"""
_need(db, current, "system:calcrule:view")
return ok(calc_rules.view(db))
class CalcRulesBody(BaseModel):
#: {"calc.money_scale": "2", ...};只提交改过的条也行
values: dict[str, str] = Field(default_factory=dict)
@router.put("/calc-rules")
def put_calc_rules(body: CalcRulesBody, db: DbSession, current: PrincipalOf) -> dict[str, Any]:
"""整页保存:先全部校验,有任何一条不合法就一条都不写。
一次改口径通常是成套改(比如同时调管理费率并升版本号),写一半比全不写危险得多。
"""
_need(db, current, "system:calcrule:edit")
if not body.values:
raise conflict("empty", "没有要保存的口径")
normalized: dict[str, str] = {}
problems: list[str] = []
for code, raw in body.values.items():
spec = calc_rules.spec_for(code)
if spec is None:
problems.append(f"{code}:不是计算口径参数")
continue
try:
normalized[code] = calc_rules.normalize(spec, raw)
except ValueError as exc:
problems.append(f"{spec.name}:{exc}")
if problems:
raise conflict("invalid_value", ";".join(problems))
rows = {row.code: row for row in
db.execute(select(SystemConfig).where(
SystemConfig.code.in_(list(normalized)))).scalars().all()}
for code, value in normalized.items():
row = rows.get(code)
if row is None:
# 老库还没补过参数:按默认值补一行再写,页面不必为此区分"新增"和"修改"
spec = calc_rules.spec_for(code)
row = SystemConfig(code=code, name=spec.name, value=spec.default_text,
value_type=spec.value_type, group=calc_rules.RULE_GROUP,
editable=True, remark=spec.remark)
db.add(row)
rows[code] = row
row.value = value
db.commit()
apply_sys_config(db)
logger.info("计算口径已更新:%s(操作人 %s)", calc_rules.describe(),
current.account.account)
return ok(calc_rules.view(db))
@router.get("/info")
def system_info() -> dict[str, Any]:
"""前端"关于"与排障要看的东西:档位、口径版本、能力开关。"""
return ok({
"env": settings.env,
"calcVersion": calc_engine.calc_version(),
"configFiles": settings.files,
"hubEnabled": settings.hub.enabled,
"ssoEnabled": settings.hub.sso_configured,
# 登录页据此决定表单长什么样:passwordLoginAllowed 管"账号口令框还留不留"
# (Hub 开着也要留,那框收的是统一身份账号),hubPasswordLogin 管"要不要摆验证码",
# localPasswordAllowed 管"本地自建账号的口令还认不认"(只影响提示语)。
"passwordLoginAllowed": settings.hub.password_login_allowed,
"hubPasswordLogin": settings.hub.hub_password_login,
"localPasswordAllowed": settings.hub.local_password_login_allowed,
"loginMode": settings.hub.mode,
# 口径的生效值,内核读到的就是这几个数(详情页汇总条与关于页共用)
"companyManageFeeRate": calc_rules.RULES.company_manage_fee_rate,
"travelBusinessLimitRate": calc_rules.RULES.travel_business_limit_rate,
"contributionRateAction": calc_rules.RULES.contribution_rate_action,
"calcRulesChanged": calc_rules.changed_count(),
"production": settings.is_production,
"warnings": settings_warnings(),
})
def settings_warnings() -> list[str]:
from ..config import warnings as prod_warnings
return prod_warnings(settings)