539 lines
22 KiB
Python
539 lines
22 KiB
Python
"""角色权限、菜单权限、数据权限、字段权限与业务参数。"""
|
||
|
||
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)
|