) : {};
+}
+
+function stringValue(value: unknown) {
+ return typeof value === "string" ? value : value === undefined || value === null ? "" : String(value);
+}
+
+function numberValue(value: unknown) {
+ const number = Number(value || 0);
+ return Number.isFinite(number) ? number : 0;
+}
diff --git a/src/features/policy-config/components/PolicyInstanceDrawer.jsx b/src/features/policy-config/components/PolicyInstanceDrawer.jsx
new file mode 100644
index 0000000..8d6fe6b
--- /dev/null
+++ b/src/features/policy-config/components/PolicyInstanceDrawer.jsx
@@ -0,0 +1,114 @@
+import MenuItem from "@mui/material/MenuItem";
+import TextField from "@mui/material/TextField";
+import { Button } from "@/shared/ui/Button.jsx";
+import { RegionSelect } from "@/shared/ui/RegionSelect.jsx";
+import { SideDrawer } from "@/shared/ui/SideDrawer.jsx";
+import { TimeRangeFilter } from "@/shared/ui/TimeRangeFilter.jsx";
+import styles from "@/features/policy-config/policy-config.module.css";
+
+export function PolicyInstanceDrawer({ page }) {
+ const saving = page.loadingAction === "instance-create";
+ const disabled = saving || !page.abilities.canCreateInstance;
+ const form = page.instanceForm;
+ const selectedTemplateValue = `${form.templateCode}:${form.templateVersion}`;
+ const patch = (value) => page.setInstanceForm((current) => ({ ...current, ...value }));
+
+ return (
+
+
+
+
+ }
+ as="form"
+ className={styles.instanceDrawer}
+ contentClassName={styles.drawerBody}
+ open={page.instanceDrawerOpen}
+ title="创建 App 策略实例"
+ width="wide"
+ onClose={saving ? undefined : page.closeInstanceDrawer}
+ onSubmit={page.submitInstance}
+ >
+
+
+
实例配置
+
+
+ patch({ instanceCode: event.target.value })}
+ />
+ {
+ const [templateCode, templateVersion] = String(event.target.value).split(":");
+ patch({ templateCode, templateVersion });
+ }}
+ >
+ {page.templateOptions.map((option) => (
+
+ ))}
+ {!page.templateOptions.length ? : null}
+
+ patch({ regionScopeMode: event.target.value, regionId: "" })}
+ >
+
+
+
+ {form.regionScopeMode === "region_id" ? (
+ patch({ regionId })}
+ />
+ ) : null}
+ patch({ status: event.target.value })}
+ >
+
+
+
+ patch({ effectiveFrom: range.startMs, effectiveTo: range.endMs })}
+ />
+
+
+
+ );
+}
diff --git a/src/features/policy-config/components/PolicyRuleEditorDrawer.jsx b/src/features/policy-config/components/PolicyRuleEditorDrawer.jsx
new file mode 100644
index 0000000..1a6e07c
--- /dev/null
+++ b/src/features/policy-config/components/PolicyRuleEditorDrawer.jsx
@@ -0,0 +1,481 @@
+import AddOutlined from "@mui/icons-material/AddOutlined";
+import DeleteOutlineOutlined from "@mui/icons-material/DeleteOutlineOutlined";
+import InputAdornment from "@mui/material/InputAdornment";
+import MenuItem from "@mui/material/MenuItem";
+import TextField from "@mui/material/TextField";
+import { AdminSwitch } from "@/shared/ui/AdminSwitch.jsx";
+import { Button } from "@/shared/ui/Button.jsx";
+import { IconButton } from "@/shared/ui/IconButton.jsx";
+import { JsonEditorField } from "@/shared/ui/JsonEditorField.jsx";
+import { SideDrawer } from "@/shared/ui/SideDrawer.jsx";
+import styles from "@/features/policy-config/policy-config.module.css";
+
+const agentPeriods = [["rolling_30d", "rolling_30d"]];
+const bdPeriods = [["utc_calendar_month", "utc_calendar_month"]];
+const gameInvitePeriods = [["rolling_30d", "rolling_30d"]];
+const taskAssets = [
+ ["POINT", "POINT"],
+ ["COIN", "COIN"],
+];
+
+export function PolicyRuleEditorDrawer({ page }) {
+ const saving = page.loadingAction === "template-save";
+ const disabled = saving || !page.abilities.canSaveTemplate;
+ const form = page.templateForm;
+
+ return (
+
+
+
+
+ }
+ as="form"
+ className={styles.ruleDrawer}
+ contentClassName={styles.drawerBody}
+ open={page.templateDrawerOpen}
+ title={page.editingTemplate ? "编辑收益政策模板" : "新增收益政策模板"}
+ width="wide"
+ onClose={saving ? undefined : page.closeTemplateDrawer}
+ onSubmit={page.submitTemplate}
+ >
+
+
+
+
+
+
+
+
+ updateRule(page.setTemplateForm, { rawJson })}
+ />
+
+ );
+}
+
+function TemplateBaseFields({ disabled, form, setForm }) {
+ const patch = (value) => setForm((current) => ({ ...current, ...value }));
+ return (
+
+
+
模板基础
+
+
+ patch({ name: event.target.value })} />
+ patch({ templateCode: event.target.value })} />
+ patch({ templateVersion: event.target.value })} />
+ patch({ status: event.target.value })}>
+
+
+
+ patch({ description: event.target.value })} />
+
+
+ );
+}
+
+function GlobalRuleSection({ disabled, form, setForm }) {
+ return (
+
+
+
全局口径
+
+
+ updateRule(setForm, { pointsPerUsd })} />
+ updateRule(setForm, { googleCoinPerUsd })} />
+ updateRule(setForm, { allowSelfBrushing })}
+ />
+
+
+ );
+}
+
+function HostRuleSection({ disabled, form, setForm }) {
+ return (
+
+
+
主播收益
+
+
+ updateSection(setForm, "host", { pointRatioPercent })} />
+ updateSection(setForm, "host", { minimumWithdrawPoints })} />
+ updateSection(setForm, "host", { withdrawFeeBps })} />
+ updateSection(setForm, "host", { affectsRoomHeat })}
+ />
+
+
+ );
+}
+
+function AgentRuleSection({ disabled, form, setForm }) {
+ const agent = form.agent;
+ return (
+
+
+
Agent 规则
+ } onClick={() => addAgentLevel(setForm)}>
+ 添加等级
+
+
+
+ updateSection(setForm, "agent", { period })} />
+ updateSection(setForm, "agent", { supportRatioPercent })} />
+ updateSection(setForm, "agent", { supportDays })} />
+ updateSection(setForm, "agent", { qualifiedHostMin })} />
+ updateAgentDifferential(setForm, { enabled })} />
+ updateAgentDifferential(setForm, { maxDepth })} />
+ updateAgentDifferential(setForm, { crossLevelFormula: event.target.value })} />
+
+
+
+ 等级
+ 名称
+ 最小 USD
+ 最大 USD
+ 比例
+ 合格主播
+ 人工
+
+
+ {agent.levels.map((level, index) => (
+
+
updateAgentLevel(setForm, index, { level: value })} />
+ updateAgentLevel(setForm, index, { name: event.target.value })} />
+ updateAgentLevel(setForm, index, { minUsd: value })} />
+ updateAgentLevel(setForm, index, { maxUsd: value })} />
+ updateAgentLevel(setForm, index, { ratioPercent: value })} />
+ updateAgentLevel(setForm, index, { qualifiedHostMin: value })} />
+ updateAgentLevel(setForm, index, { manualReview: event.target.checked })} />
+ removeAgentLevel(setForm, index)} />
+
+ ))}
+
+
BD 规则
+ } onClick={() => addBDLevel(setForm)}>
+ 添加等级
+
+
+
+ updateSection(setForm, "bd", { period })} />
+ updateSection(setForm, "bd", { base: event.target.value })} />
+ updateSection(setForm, "bd", { qualifiedAgencyMin })} />
+ updateSection(setForm, "bd", { qualifiedHostPerAgencyMin })} />
+
+
+
+ 等级
+ 名称
+ 门槛 USD
+ 固定工资
+ 提成
+
+
+ {bd.levels.map((level, index) => (
+
+ updateBDLevel(setForm, index, { level: value })} />
+ updateBDLevel(setForm, index, { name: event.target.value })} />
+ updateBDLevel(setForm, index, { thresholdUsd: value })} />
+ updateBDLevel(setForm, index, { salaryUsd: value })} />
+ updateBDLevel(setForm, index, { commissionPercent: value })} />
+ removeBDLevel(setForm, index)} />
+
+ ))}
+
+
经理规则
+
+
+ updateSection(setForm, "manager", { coinSellerRechargeThresholdUsd })} />
+ updateSection(setForm, "manager", { coinSellerRechargeCommissionPercent })} />
+ updateSection(setForm, "manager", { hostPointCommissionPercent })} />
+
+
+ );
+}
+
+function CoinSellerRuleSection({ disabled, form, setForm }) {
+ const coinSeller = form.coinSeller;
+ return (
+
+
+
币商规则
+ } onClick={() => addCoinSellerLevel(setForm)}>
+ 添加档位
+
+
+
+ updateSection(setForm, "coinSeller", { withdrawOrderEnabled })} />
+ updateSection(setForm, "coinSeller", { orderTimeoutSeconds })} />
+ updateSection(setForm, "coinSeller", { sellerPointSettlePercent })} />
+ updateSection(setForm, "coinSeller", { sellerPointRewardPercent })} />
+ updateSection(setForm, "coinSeller", { successRateCloseThresholdPercent })} />
+
+
+
+ 名称
+ 累计门槛
+ 单次门槛
+ 金币/USD
+ 订单
+
+
+ {coinSeller.levels.map((level, index) => (
+
+
updateCoinSellerLevel(setForm, index, { name: event.target.value })} />
+ updateCoinSellerLevel(setForm, index, { thresholdUsd: value })} />
+ updateCoinSellerLevel(setForm, index, { singleRechargeThresholdUsd: value })} />
+ updateCoinSellerLevel(setForm, index, { coinPerUsd: value })} />
+ updateCoinSellerLevel(setForm, index, { withdrawOrderEnabled: event.target.checked })} />
+ removeCoinSellerLevel(setForm, index)} />
+
+ ))}
+
+
任务与游戏邀请
+
+
+ updateSection(setForm, "tasks", { rewardAssetType })} />
+ updateSection(setForm, "tasks", { newHost7dMaxPoints })} />
+ updateSection(setForm, "gameInvite", { enabled })} />
+ updateSection(setForm, "gameInvite", { period })} />
+
+
+ );
+}
+
+function NumberField({ bare = false, disabled, label, onChange, prefix, suffix, value }) {
+ return (
+ {prefix} : undefined,
+ endAdornment: suffix ? {suffix} : undefined,
+ },
+ }}
+ type="number"
+ value={value}
+ onChange={(event) => onChange(event.target.value)}
+ />
+ );
+}
+
+function SelectField({ disabled, label, onChange, options, value }) {
+ return (
+ onChange(event.target.value)}>
+ {options.map(([optionValue, optionLabel]) => (
+
+ ))}
+
+ );
+}
+
+function SwitchField({ checked, disabled, label, onChange }) {
+ return (
+
+
{label}
+
onChange(event.target.checked)} />
+
+ page.setActiveTab(value)}>
+
+
+
+
+ {page.activeTab === "templates" ? : }
+
+
+
+ );
+}
+
+function TemplatePanel({ page }) {
+ const items = page.templates.data.items || [];
+ const total = page.templates.data.total || 0;
+ const columns = templateColumns.map((column) =>
+ column.key === "actions" ? { ...column, render: (item) => } : column,
+ );
+ return (
+ <>
+ page.openTemplateEditor(null)}>
+
+
+ ) : null
+ }
+ filters={
+
+ }
+ />
+
+
+ 0 ? { page: page.templatePage, pageSize: page.templates.data.pageSize || 50, total, onPageChange: page.setTemplatePage } : undefined}
+ rowKey={(item) => `${item.templateCode}:${item.templateVersion}`}
+ />
+
+
+
+ );
+}
+
+function InstancePanel({ page }) {
+ const items = page.instances.data.items || [];
+ const total = page.instances.data.total || 0;
+ const columns = instanceColumns.map((column) => {
+ if (column.key === "status") {
+ return { ...column, render: (item) => };
+ }
+ if (column.key === "actions") {
+ return { ...column, render: (item) => };
+ }
+ return column;
+ });
+ return (
+ <>
+ page.openInstanceCreator(null)}>
+
+
+ ) : null
+ }
+ filters={
+
+ }
+ />
+
+
+ 0 ? { page: page.instancePage, pageSize: page.instances.data.pageSize || 50, total, onPageChange: page.setInstancePage } : undefined}
+ rowKey={(item) => item.instanceId}
+ />
+
+
+
+ );
+}
+
+function TemplateIdentity({ item }) {
+ return (
+
+ {item.name}
+ {item.templateCode}
+ 版本 {item.templateVersion}
+
+ );
+}
+
+function TemplateRuntimeSummary({ item }) {
+ const rule = item.ruleJson || {};
+ const host = rule.host || {};
+ const tasks = rule.tasks || {};
+ return (
+
+ {formatNumber(rule.points_per_usd)} POINT/USD
+ 主播 {formatNumber(host.point_ratio_percent)}% 入 POINT
+ 提现手续费 {formatNumber(host.withdraw_fee_bps)} bps
+ 任务资产 {tasks.reward_asset_type || "-"}
+
+ );
+}
+
+function TeamPolicySummary({ item }) {
+ const rule = item.ruleJson || {};
+ const agentLevels = Array.isArray(rule.agent?.levels) ? rule.agent.levels : [];
+ const bdLevels = Array.isArray(rule.bd?.levels) ? rule.bd.levels : [];
+ const coinSellerLevels = Array.isArray(rule.coin_seller?.levels) ? rule.coin_seller.levels : [];
+ return (
+
+ Agent {agentLevels.length} 档 · BD {bdLevels.length} 档
+ 币商 {coinSellerLevels.length} 档
+ {rule.allow_self_brushing ? "允许自刷" : "不允许自刷"}
+
+ );
+}
+
+function TemplateActions({ item, page }) {
+ if (!page.abilities.canSaveTemplate) {
+ return null;
+ }
+ return (
+ page.openTemplateEditor(item)}>
+
+
+ );
+}
+
+function InstanceIdentity({ item }) {
+ return (
+
+ {item.instanceCode}
+ {item.appCode || "-"}
+
+ {item.templateCode} · {item.templateVersion}
+
+
+ );
+}
+
+function InstanceScope({ item, regionLabelMap = {} }) {
+ return (
+
+ {regionScopeLabel(item.regionScope, regionLabelMap)}
+ 开始 {formatMillis(item.effectiveFromMs)}
+ 结束 {item.effectiveToMs ? formatMillis(item.effectiveToMs) : "长期有效"}
+
+ );
+}
+
+function PublishSummary({ item }) {
+ return (
+
+ {publishStatusLabel(item.publishStatus)}
+ {item.lastPublishedAtMs ? formatMillis(item.lastPublishedAtMs) : "未发布"}
+ {item.publishError ? {item.publishError} : null}
+
+ );
+}
+
+function InstanceStatusSwitch({ item, page }) {
+ const action = `instance-status-${item.instanceId}`;
+ return (
+ page.toggleInstanceStatus(item, event.target.checked)}
+ />
+ );
+}
+
+function InstanceActions({ item, page }) {
+ const action = `instance-publish-${item.instanceId}`;
+ if (!page.abilities.canPublishInstance) {
+ return null;
+ }
+ return (
+ page.publishInstance(item)}
+ >
+
+
+ );
+}
+
+function statusLabel(status) {
+ return status === "active" ? "启用" : "停用";
+}
+
+function publishStatusLabel(status) {
+ switch (status) {
+ case "published":
+ return "已发布";
+ case "failed":
+ return "发布失败";
+ default:
+ return "草稿";
+ }
+}
+
+function regionScopeLabel(scope, labels) {
+ if (scope === "all_active_regions" || !scope) {
+ return "全部启用地区";
+ }
+ if (String(scope).startsWith("region_id:")) {
+ const regionId = String(scope).replace("region_id:", "");
+ return labels[regionId] || `区域 ${regionId}`;
+ }
+ return scope;
+}
+
+function formatNumber(value) {
+ const number = Number(value || 0);
+ return Number.isFinite(number) ? number.toLocaleString("en-US") : "-";
+}
diff --git a/src/features/policy-config/permissions.js b/src/features/policy-config/permissions.js
new file mode 100644
index 0000000..67f2ce7
--- /dev/null
+++ b/src/features/policy-config/permissions.js
@@ -0,0 +1,14 @@
+import { useAuth } from "@/app/auth/AuthProvider.jsx";
+import { PERMISSIONS } from "@/app/permissions";
+
+export function usePolicyConfigAbilities() {
+ const { can } = useAuth();
+
+ return {
+ canCreateInstance: can(PERMISSIONS.policyInstanceCreate),
+ canPublishInstance: can(PERMISSIONS.policyInstancePublish),
+ canSaveTemplate: can(PERMISSIONS.policyTemplateCreate),
+ canUpdateInstance: can(PERMISSIONS.policyInstanceUpdate),
+ canView: can(PERMISSIONS.policyTemplateView),
+ };
+}
diff --git a/src/features/policy-config/policy-config.module.css b/src/features/policy-config/policy-config.module.css
new file mode 100644
index 0000000..251155c
--- /dev/null
+++ b/src/features/policy-config/policy-config.module.css
@@ -0,0 +1,174 @@
+.tabsBar {
+ display: flex;
+ align-items: center;
+ min-height: 48px;
+ border-bottom: 1px solid var(--border);
+ padding: 0 16px;
+}
+
+.tab {
+ min-height: 48px;
+ text-transform: none;
+}
+
+.toolbarFilters {
+ display: flex;
+ flex-wrap: wrap;
+ align-items: center;
+ gap: 10px;
+}
+
+.stack {
+ display: flex;
+ min-width: 0;
+ flex-direction: column;
+ gap: 4px;
+}
+
+.name {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ color: var(--text-primary);
+ font-weight: 720;
+}
+
+.meta {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ color: var(--text-tertiary);
+ font-size: 12px;
+}
+
+.errorText {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ color: var(--danger);
+ font-size: 12px;
+}
+
+.ruleDrawer,
+.instanceDrawer {
+ width: min(1120px, calc(100vw - 32px));
+}
+
+.drawerBody {
+ display: flex;
+ flex-direction: column;
+ gap: 18px;
+}
+
+.formSection {
+ display: flex;
+ flex-direction: column;
+ gap: 14px;
+}
+
+.sectionHeader {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 12px;
+}
+
+.sectionHeader h3 {
+ margin: 0;
+ color: var(--text-primary);
+ font-size: 15px;
+ font-weight: 760;
+ letter-spacing: 0;
+}
+
+.formGrid {
+ display: grid;
+ grid-template-columns: repeat(3, minmax(180px, 1fr));
+ gap: 12px;
+ align-items: start;
+}
+
+.fieldWide {
+ grid-column: 1 / -1;
+}
+
+.timeRangeField {
+ grid-column: span 2;
+}
+
+.switchField {
+ display: flex;
+ min-height: var(--control-height);
+ align-items: center;
+ justify-content: space-between;
+ gap: 12px;
+ border: 1px solid var(--border);
+ border-radius: 8px;
+ background: var(--bg-card);
+ padding: 0 12px;
+ color: var(--text-secondary);
+ font-size: var(--admin-font-size);
+}
+
+.levelTable {
+ display: flex;
+ min-width: 0;
+ flex-direction: column;
+ gap: 8px;
+ overflow-x: auto;
+}
+
+.agentLevelHeader,
+.agentLevelRow,
+.bdLevelHeader,
+.bdLevelRow,
+.coinSellerLevelHeader,
+.coinSellerLevelRow {
+ display: grid;
+ min-width: 920px;
+ align-items: center;
+ gap: 8px;
+}
+
+.agentLevelHeader,
+.bdLevelHeader,
+.coinSellerLevelHeader {
+ min-height: 34px;
+ border-radius: 8px;
+ background: var(--bg-card-strong);
+ padding: 0 10px;
+ color: var(--text-tertiary);
+ font-size: 12px;
+ font-weight: 720;
+}
+
+.agentLevelRow,
+.bdLevelRow,
+.coinSellerLevelRow {
+ min-height: 44px;
+}
+
+.agentLevelHeader,
+.agentLevelRow {
+ grid-template-columns: 72px minmax(130px, 1fr) 110px 110px 120px 110px 76px 44px;
+}
+
+.bdLevelHeader,
+.bdLevelRow {
+ grid-template-columns: 72px minmax(160px, 1fr) 130px 130px 120px 44px;
+}
+
+.coinSellerLevelHeader,
+.coinSellerLevelRow {
+ grid-template-columns: minmax(160px, 1fr) 130px 130px 130px 92px 44px;
+}
+
+@media (max-width: 900px) {
+ .formGrid {
+ grid-template-columns: 1fr;
+ }
+
+ .timeRangeField {
+ grid-column: auto;
+ }
+}
diff --git a/src/features/policy-config/routes.js b/src/features/policy-config/routes.js
new file mode 100644
index 0000000..bab7b7b
--- /dev/null
+++ b/src/features/policy-config/routes.js
@@ -0,0 +1,12 @@
+import { MENU_CODES, PERMISSIONS } from "@/app/permissions";
+
+export const policyConfigRoutes = [
+ {
+ label: "收益政策模板",
+ loader: () => import("./pages/PolicyConfigPage.jsx").then((module) => module.PolicyConfigPage),
+ menuCode: MENU_CODES.policyTemplate,
+ pageKey: "policy-config",
+ path: "/policy/templates",
+ permission: PERMISSIONS.policyTemplateView,
+ },
+];
diff --git a/src/features/policy-config/schema.test.ts b/src/features/policy-config/schema.test.ts
new file mode 100644
index 0000000..8926742
--- /dev/null
+++ b/src/features/policy-config/schema.test.ts
@@ -0,0 +1,312 @@
+import { describe, expect, test } from "vitest";
+import {
+ defaultPolicyRule,
+ policyInstancePayloadFromForm,
+ policyRuleFormSchema,
+ ruleFormFromJson,
+ ruleJsonFromForm,
+ ruleObjectFromForm,
+ type PolicyInstanceForm,
+ type PolicyRuleForm,
+} from "./schema";
+
+type RuleRecord = Record;
+
+function validRuleForm(): PolicyRuleForm {
+ return ruleFormFromJson(defaultPolicyRule());
+}
+
+function clone(value: TValue): TValue {
+ return JSON.parse(JSON.stringify(value)) as TValue;
+}
+
+function record(value: unknown): RuleRecord {
+ return value && typeof value === "object" && !Array.isArray(value) ? (value as RuleRecord) : {};
+}
+
+function recordArray(value: unknown): RuleRecord[] {
+ return Array.isArray(value) ? value.map(record) : [];
+}
+
+function invalidRuleMessages(form: PolicyRuleForm): string[] {
+ const result = policyRuleFormSchema.safeParse(form);
+ if (result.success) {
+ throw new Error("expected policy rule form to be invalid");
+ }
+ return result.error.issues.map((issue) => issue.message);
+}
+
+function expectInvalidRule(form: PolicyRuleForm, message: string) {
+ expect(invalidRuleMessages(form)).toContain(message);
+}
+
+function baseInstanceForm(): PolicyInstanceForm {
+ return {
+ effectiveFrom: "",
+ effectiveTo: "",
+ instanceCode: " huwaa_policy ",
+ regionId: "",
+ regionScopeMode: "all_active_regions",
+ status: "active",
+ templateCode: " first_google70000_coin_seller_92000_100000_v1 ",
+ templateVersion: " v1 ",
+ };
+}
+
+describe("policy rule form schema", () => {
+ test("hydrates and serializes the Huwaa default policy rule", () => {
+ const form = validRuleForm();
+
+ expect(form).toMatchObject({
+ allowSelfBrushing: true,
+ googleCoinPerUsd: "70000",
+ host: {
+ affectsRoomHeat: false,
+ minimumWithdrawPoints: "1000000",
+ pointRatioPercent: "70",
+ withdrawFeeBps: "500",
+ },
+ pointsPerUsd: "100000",
+ });
+ expect(form.agent.levels).toHaveLength(4);
+ expect(form.agent.levels[3]).toMatchObject({ level: "4", manualReview: true, maxUsd: "0", minUsd: "2000" });
+ expect(form.bd.levels).toHaveLength(12);
+ expect(form.coinSeller.levels.map((level) => level.coinPerUsd)).toEqual(["92000", "96000", "100000"]);
+
+ const rule = ruleObjectFromForm(form);
+ expect(rule).toMatchObject({
+ allow_self_brushing: true,
+ coin_seller: {
+ levels: [
+ { coin_per_usd: 92000, name: "Beginner", threshold_usd: 100, withdraw_order_enabled: false },
+ { coin_per_usd: 96000, name: "Standard", threshold_usd: 500, withdraw_order_enabled: false },
+ { coin_per_usd: 100000, name: "Senior", single_recharge_threshold_usd: 1000, withdraw_order_enabled: true },
+ ],
+ seller_point_reward_percent: 5,
+ seller_point_settle_percent: 95,
+ },
+ google_coin_per_usd: 70000,
+ host: { withdraw_fee_bps: 500 },
+ points_per_usd: 100000,
+ });
+ expect(JSON.parse(ruleJsonFromForm(form))).toMatchObject({ google_coin_per_usd: 70000, points_per_usd: 100000 });
+ });
+
+ test("preserves unknown JSON fields while visual fields override known policy keys", () => {
+ const base = defaultPolicyRule();
+ const baseAgent = record(base.agent);
+ const baseBD = record(base.bd);
+ const baseCoinSeller = record(base.coin_seller);
+ const baseAgentLevels = recordArray(baseAgent.levels);
+ const baseBDLevels = recordArray(baseBD.levels);
+ const baseCoinSellerLevels = recordArray(baseCoinSeller.levels);
+ const rawRule = {
+ ...base,
+ future_top_level: "preserve-top",
+ agent: {
+ ...baseAgent,
+ future_agent: "preserve-agent",
+ levels: [{ ...baseAgentLevels[0], future_agent_level: "preserve-agent-level" }, ...baseAgentLevels.slice(1)],
+ },
+ bd: {
+ ...baseBD,
+ future_bd: "preserve-bd",
+ levels: [{ ...baseBDLevels[0], future_bd_level: "preserve-bd-level" }, ...baseBDLevels.slice(1)],
+ },
+ coin_seller: {
+ ...baseCoinSeller,
+ future_coin_seller: "preserve-coin-seller",
+ levels: [{ ...baseCoinSellerLevels[0], future_coin_seller_level: "preserve-coin-seller-level" }, ...baseCoinSellerLevels.slice(1)],
+ },
+ game_invite: { ...record(base.game_invite), future_game_invite: "preserve-game-invite" },
+ host: { ...record(base.host), future_host: "preserve-host" },
+ tasks: { ...record(base.tasks), future_tasks: "preserve-tasks" },
+ };
+ const form = ruleFormFromJson(rawRule);
+
+ form.allowSelfBrushing = false;
+ form.googleCoinPerUsd = "71000";
+ form.host.pointRatioPercent = "72.5";
+ form.agent.levels[0].ratioPercent = "6";
+ form.bd.levels[0].commissionPercent = "1.75";
+ form.coinSeller.levels[0].coinPerUsd = "93000";
+ form.gameInvite.enabled = false;
+ form.tasks.rewardAssetType = "COIN";
+
+ const rule = ruleObjectFromForm(form);
+ expect(rule).toMatchObject({
+ allow_self_brushing: false,
+ future_top_level: "preserve-top",
+ google_coin_per_usd: 71000,
+ agent: {
+ future_agent: "preserve-agent",
+ },
+ bd: {
+ future_bd: "preserve-bd",
+ },
+ coin_seller: {
+ future_coin_seller: "preserve-coin-seller",
+ },
+ game_invite: { enabled: false, future_game_invite: "preserve-game-invite" },
+ host: { future_host: "preserve-host", point_ratio_percent: 72.5 },
+ tasks: { future_tasks: "preserve-tasks", reward_asset_type: "COIN" },
+ });
+ expect(recordArray(record(rule.agent).levels)[0]).toMatchObject({ future_agent_level: "preserve-agent-level", ratio_percent: 6 });
+ expect(recordArray(record(rule.bd).levels)[0]).toMatchObject({ commission_percent: 1.75, future_bd_level: "preserve-bd-level" });
+ expect(recordArray(record(rule.coin_seller).levels)[0]).toMatchObject({ coin_per_usd: 93000, future_coin_seller_level: "preserve-coin-seller-level" });
+ });
+
+ test("does not reattach removed level unknown fields by array index", () => {
+ const base = defaultPolicyRule();
+ const baseAgent = record(base.agent);
+ const baseBD = record(base.bd);
+ const baseCoinSeller = record(base.coin_seller);
+ const baseAgentLevels = recordArray(baseAgent.levels);
+ const baseBDLevels = recordArray(baseBD.levels);
+ const baseCoinSellerLevels = recordArray(baseCoinSeller.levels);
+ const form = ruleFormFromJson({
+ ...base,
+ agent: {
+ ...baseAgent,
+ levels: [{ ...baseAgentLevels[0], marker: "deleted-agent-level" }, { ...baseAgentLevels[1], marker: "kept-agent-level" }],
+ },
+ bd: {
+ ...baseBD,
+ levels: [{ ...baseBDLevels[0], marker: "deleted-bd-level" }, { ...baseBDLevels[1], marker: "kept-bd-level" }],
+ },
+ coin_seller: {
+ ...baseCoinSeller,
+ levels: [
+ { ...baseCoinSellerLevels[0], marker: "deleted-coin-seller-level" },
+ { ...baseCoinSellerLevels[1], marker: "kept-coin-seller-level" },
+ ],
+ },
+ });
+
+ form.agent.levels = form.agent.levels.slice(1);
+ form.bd.levels = form.bd.levels.slice(1);
+ form.coinSeller.levels = form.coinSeller.levels.slice(1);
+
+ const rule = ruleObjectFromForm(form);
+ expect(recordArray(record(rule.agent).levels)[0]).toMatchObject({ level: 2, marker: "kept-agent-level" });
+ expect(recordArray(record(rule.bd).levels)[0]).toMatchObject({ level: 2, marker: "kept-bd-level" });
+ expect(recordArray(record(rule.coin_seller).levels)[0]).toMatchObject({ name: "Standard", marker: "kept-coin-seller-level" });
+ });
+
+ test("rejects non-object and invalid advanced JSON", () => {
+ const nonObjectJson = validRuleForm();
+ nonObjectJson.rawJson = "[]";
+ expect(invalidRuleMessages(nonObjectJson).some((message) => message.includes("规则 JSON 必须是对象"))).toBe(true);
+
+ const invalidJson = validRuleForm();
+ invalidJson.rawJson = "{bad json";
+ expect(invalidRuleMessages(invalidJson).some((message) => message.startsWith("JSON 格式错误："))).toBe(true);
+ expect(() => ruleFormFromJson("[]")).toThrow("规则 JSON 必须是对象");
+ });
+
+ test("rejects invalid Agent level identity, thresholds, and ratio range", () => {
+ const duplicateLevel = validRuleForm();
+ duplicateLevel.agent.levels[1].level = duplicateLevel.agent.levels[0].level;
+ expectInvalidRule(duplicateLevel, "Agent 等级必须为不重复的正整数");
+
+ const invalidWindow = validRuleForm();
+ invalidWindow.agent.levels[0].minUsd = "100";
+ invalidWindow.agent.levels[0].maxUsd = "100";
+ expectInvalidRule(invalidWindow, "Agent 最大 USD 必须大于最小 USD，0 表示无上限");
+
+ const invalidRatio = validRuleForm();
+ invalidRatio.agent.levels[0].ratioPercent = "101";
+ expectInvalidRule(invalidRatio, "Agent 提成比例必须在 0-100 之间");
+ });
+
+ test("rejects invalid BD level identity, increasing threshold, and commission range", () => {
+ const duplicateLevel = validRuleForm();
+ duplicateLevel.bd.levels[1].level = duplicateLevel.bd.levels[0].level;
+ expectInvalidRule(duplicateLevel, "BD 等级必须为不重复的正整数");
+
+ const nonIncreasingThreshold = validRuleForm();
+ nonIncreasingThreshold.bd.levels[1].thresholdUsd = nonIncreasingThreshold.bd.levels[0].thresholdUsd;
+ expectInvalidRule(nonIncreasingThreshold, "BD 收入门槛必须逐级递增");
+
+ const invalidCommission = validRuleForm();
+ invalidCommission.bd.levels[0].commissionPercent = "0";
+ expectInvalidRule(invalidCommission, "BD 提成比例必须在 0-100 之间");
+ });
+
+ test("rejects invalid coin seller level thresholds, percentages, and host fee bps", () => {
+ const missingThreshold = validRuleForm();
+ missingThreshold.coinSeller.levels[0].thresholdUsd = "";
+ missingThreshold.coinSeller.levels[0].singleRechargeThresholdUsd = "";
+ expectInvalidRule(missingThreshold, "币商等级必须配置累计门槛或单次充值门槛");
+
+ const invalidCoinRate = validRuleForm();
+ invalidCoinRate.coinSeller.levels[0].coinPerUsd = "0";
+ expectInvalidRule(invalidCoinRate, "币商金币单价必须大于 0");
+
+ const invalidPercent = validRuleForm();
+ invalidPercent.coinSeller.sellerPointSettlePercent = "101";
+ expectInvalidRule(invalidPercent, "币商结算比例必须在 0-100 之间");
+
+ const invalidPercentTotal = validRuleForm();
+ invalidPercentTotal.coinSeller.sellerPointSettlePercent = "96";
+ invalidPercentTotal.coinSeller.sellerPointRewardPercent = "5";
+ expectInvalidRule(invalidPercentTotal, "币商结算比例和奖励比例合计不能超过 100");
+
+ const invalidFeeBps = validRuleForm();
+ invalidFeeBps.host.withdrawFeeBps = "10001";
+ expectInvalidRule(invalidFeeBps, "提现手续费 bps 必须在 0-10000 之间");
+ });
+});
+
+describe("policy instance payload", () => {
+ test("builds all_active_regions payload and trims template fields", () => {
+ expect(policyInstancePayloadFromForm(baseInstanceForm())).toEqual({
+ effective_from_ms: 0,
+ effective_to_ms: 0,
+ instance_code: "huwaa_policy",
+ region_scope: "all_active_regions",
+ status: "active",
+ template_code: "first_google70000_coin_seller_92000_100000_v1",
+ template_version: "v1",
+ });
+ });
+
+ test("builds region_id scope and preserves UTC epoch millisecond boundaries", () => {
+ const startMs = Date.UTC(2026, 0, 1, 0, 0, 0, 0);
+ const endMs = startMs + 1;
+
+ expect(
+ policyInstancePayloadFromForm({
+ ...baseInstanceForm(),
+ effectiveFrom: startMs,
+ effectiveTo: endMs,
+ regionId: "1001",
+ regionScopeMode: "region_id",
+ }),
+ ).toMatchObject({
+ effective_from_ms: 1767225600000,
+ effective_to_ms: 1767225600001,
+ region_scope: "region_id:1001",
+ });
+ });
+
+ test("rejects missing region id and invalid effective time boundaries", () => {
+ const startMs = Date.UTC(2026, 0, 1, 0, 0, 0, 0);
+
+ expect(() => policyInstancePayloadFromForm({ ...baseInstanceForm(), regionScopeMode: "region_id" })).toThrow("请选择适用区域");
+ expect(() => policyInstancePayloadFromForm({ ...baseInstanceForm(), effectiveFrom: startMs, effectiveTo: startMs })).toThrow("生效时间范围不正确");
+ expect(() => policyInstancePayloadFromForm({ ...baseInstanceForm(), effectiveFrom: startMs, effectiveTo: startMs - 1 })).toThrow("生效时间范围不正确");
+ expect(() => policyInstancePayloadFromForm({ ...baseInstanceForm(), effectiveFrom: "-1", effectiveTo: "" })).toThrow("生效时间范围不正确");
+ });
+
+ test("truncates decimal millisecond inputs after schema validation accepts the range", () => {
+ const form = clone(baseInstanceForm());
+ form.effectiveFrom = "1767225600000.9";
+ form.effectiveTo = "1767225600002.1";
+
+ expect(policyInstancePayloadFromForm(form)).toMatchObject({
+ effective_from_ms: 1767225600000,
+ effective_to_ms: 1767225600002,
+ });
+ });
+});
diff --git a/src/features/policy-config/schema.ts b/src/features/policy-config/schema.ts
new file mode 100644
index 0000000..029e8e0
--- /dev/null
+++ b/src/features/policy-config/schema.ts
@@ -0,0 +1,783 @@
+import { z } from "zod";
+
+export const DEFAULT_POLICY_TEMPLATE_CODE = "first_google70000_coin_seller_92000_100000_v1";
+export const DEFAULT_POLICY_TEMPLATE_VERSION = "v1";
+
+const statusValues = ["active", "disabled"] as const;
+const rewardAssetValues = ["COIN", "POINT"] as const;
+const regionScopeModes = ["all_active_regions", "region_id"] as const;
+
+type NumericInput = number | string;
+type RuleObject = Record;
+
+export interface AgentLevelForm {
+ extra?: RuleObject;
+ level: NumericInput;
+ manualReview: boolean;
+ maxUsd: NumericInput;
+ minUsd: NumericInput;
+ name: string;
+ qualifiedHostMin: NumericInput;
+ ratioPercent: NumericInput;
+}
+
+export interface BDLevelForm {
+ commissionPercent: NumericInput;
+ extra?: RuleObject;
+ level: NumericInput;
+ name: string;
+ salaryUsd: NumericInput;
+ thresholdUsd: NumericInput;
+}
+
+export interface CoinSellerLevelForm {
+ coinPerUsd: NumericInput;
+ extra?: RuleObject;
+ name: string;
+ singleRechargeThresholdUsd: NumericInput;
+ thresholdUsd: NumericInput;
+ withdrawOrderEnabled: boolean;
+}
+
+export interface PolicyRuleForm {
+ agent: {
+ differential: {
+ crossLevelFormula: string;
+ enabled: boolean;
+ maxDepth: NumericInput;
+ };
+ levels: AgentLevelForm[];
+ period: string;
+ qualifiedHostMin: NumericInput;
+ supportDays: NumericInput;
+ supportRatioPercent: NumericInput;
+ };
+ allowSelfBrushing: boolean;
+ bd: {
+ base: string;
+ levels: BDLevelForm[];
+ period: string;
+ qualifiedAgencyMin: NumericInput;
+ qualifiedHostPerAgencyMin: NumericInput;
+ };
+ coinSeller: {
+ levels: CoinSellerLevelForm[];
+ orderTimeoutSeconds: NumericInput;
+ sellerPointRewardPercent: NumericInput;
+ sellerPointSettlePercent: NumericInput;
+ successRateCloseThresholdPercent: NumericInput;
+ withdrawOrderEnabled: boolean;
+ };
+ gameInvite: {
+ enabled: boolean;
+ period: string;
+ };
+ googleCoinPerUsd: NumericInput;
+ host: {
+ affectsRoomHeat: boolean;
+ minimumWithdrawPoints: NumericInput;
+ pointRatioPercent: NumericInput;
+ withdrawFeeBps: NumericInput;
+ };
+ manager: {
+ coinSellerRechargeCommissionPercent: NumericInput;
+ coinSellerRechargeThresholdUsd: NumericInput;
+ hostPointCommissionPercent: NumericInput;
+ };
+ pointsPerUsd: NumericInput;
+ rawJson: string;
+ tasks: {
+ newHost7dMaxPoints: NumericInput;
+ rewardAssetType: (typeof rewardAssetValues)[number];
+ };
+}
+
+export interface PolicyTemplateForm {
+ description: string;
+ name: string;
+ rule: PolicyRuleForm;
+ status: (typeof statusValues)[number];
+ templateCode: string;
+ templateVersion: string;
+}
+
+export interface PolicyInstanceForm {
+ effectiveFrom: NumericInput | "";
+ effectiveTo: NumericInput | "";
+ instanceCode: string;
+ regionId: NumericInput | "";
+ regionScopeMode: (typeof regionScopeModes)[number];
+ status: (typeof statusValues)[number];
+ templateCode: string;
+ templateVersion: string;
+}
+
+const agentLevelSchema = z.object({
+ extra: z.record(z.string(), z.unknown()).optional(),
+ level: z.union([z.string(), z.number()]),
+ manualReview: z.boolean(),
+ maxUsd: z.union([z.string(), z.number()]),
+ minUsd: z.union([z.string(), z.number()]),
+ name: z.string(),
+ qualifiedHostMin: z.union([z.string(), z.number()]),
+ ratioPercent: z.union([z.string(), z.number()]),
+});
+
+const bdLevelSchema = z.object({
+ commissionPercent: z.union([z.string(), z.number()]),
+ extra: z.record(z.string(), z.unknown()).optional(),
+ level: z.union([z.string(), z.number()]),
+ name: z.string(),
+ salaryUsd: z.union([z.string(), z.number()]),
+ thresholdUsd: z.union([z.string(), z.number()]),
+});
+
+const coinSellerLevelSchema = z.object({
+ coinPerUsd: z.union([z.string(), z.number()]),
+ extra: z.record(z.string(), z.unknown()).optional(),
+ name: z.string(),
+ singleRechargeThresholdUsd: z.union([z.string(), z.number()]),
+ thresholdUsd: z.union([z.string(), z.number()]),
+ withdrawOrderEnabled: z.boolean(),
+});
+
+export const policyRuleFormSchema = z
+ .object({
+ agent: z.object({
+ differential: z.object({
+ crossLevelFormula: z.string().trim().min(1, "请输入 Agent 差值公式"),
+ enabled: z.boolean(),
+ maxDepth: z.union([z.string(), z.number()]),
+ }),
+ levels: z.array(agentLevelSchema).min(1, "请至少配置一个 Agent 等级"),
+ period: z.string().trim().min(1, "请输入 Agent 周期"),
+ qualifiedHostMin: z.union([z.string(), z.number()]),
+ supportDays: z.union([z.string(), z.number()]),
+ supportRatioPercent: z.union([z.string(), z.number()]),
+ }),
+ allowSelfBrushing: z.boolean(),
+ bd: z.object({
+ base: z.string().trim().min(1, "请输入 BD 结算基准"),
+ levels: z.array(bdLevelSchema).min(1, "请至少配置一个 BD 等级"),
+ period: z.string().trim().min(1, "请输入 BD 周期"),
+ qualifiedAgencyMin: z.union([z.string(), z.number()]),
+ qualifiedHostPerAgencyMin: z.union([z.string(), z.number()]),
+ }),
+ coinSeller: z.object({
+ levels: z.array(coinSellerLevelSchema).min(1, "请至少配置一个币商等级"),
+ orderTimeoutSeconds: z.union([z.string(), z.number()]),
+ sellerPointRewardPercent: z.union([z.string(), z.number()]),
+ sellerPointSettlePercent: z.union([z.string(), z.number()]),
+ successRateCloseThresholdPercent: z.union([z.string(), z.number()]),
+ withdrawOrderEnabled: z.boolean(),
+ }),
+ gameInvite: z.object({
+ enabled: z.boolean(),
+ period: z.string().trim().min(1, "请输入游戏邀请周期"),
+ }),
+ googleCoinPerUsd: z.union([z.string(), z.number()]),
+ host: z.object({
+ affectsRoomHeat: z.boolean(),
+ minimumWithdrawPoints: z.union([z.string(), z.number()]),
+ pointRatioPercent: z.union([z.string(), z.number()]),
+ withdrawFeeBps: z.union([z.string(), z.number()]),
+ }),
+ manager: z.object({
+ coinSellerRechargeCommissionPercent: z.union([z.string(), z.number()]),
+ coinSellerRechargeThresholdUsd: z.union([z.string(), z.number()]),
+ hostPointCommissionPercent: z.union([z.string(), z.number()]),
+ }),
+ pointsPerUsd: z.union([z.string(), z.number()]),
+ rawJson: z.string(),
+ tasks: z.object({
+ newHost7dMaxPoints: z.union([z.string(), z.number()]),
+ rewardAssetType: z.enum(rewardAssetValues),
+ }),
+ })
+ .superRefine((value, context) => {
+ try {
+ parseRuleObject(value.rawJson);
+ } catch (error) {
+ context.addIssue({ code: "custom", message: errorMessage(error), path: ["rawJson"] });
+ }
+ requirePositiveInteger(context, ["pointsPerUsd"], value.pointsPerUsd, "POINT/USD 必须大于 0");
+ requirePositiveInteger(context, ["googleCoinPerUsd"], value.googleCoinPerUsd, "Google 金币单价必须大于 0");
+ requirePercent(context, ["host", "pointRatioPercent"], value.host.pointRatioPercent, "主播收益比例必须在 0-100 之间", false);
+ requireNonNegativeInteger(context, ["host", "minimumWithdrawPoints"], value.host.minimumWithdrawPoints, "最低提现积分不能小于 0");
+ requireIntegerRange(context, ["host", "withdrawFeeBps"], value.host.withdrawFeeBps, 0, 10000, "提现手续费 bps 必须在 0-10000 之间");
+ requirePercent(context, ["agent", "supportRatioPercent"], value.agent.supportRatioPercent, "Agent 扶持比例必须在 0-100 之间", false);
+ requireNonNegativeInteger(context, ["agent", "supportDays"], value.agent.supportDays, "Agent 扶持天数不能小于 0");
+ requirePositiveInteger(context, ["agent", "qualifiedHostMin"], value.agent.qualifiedHostMin, "Agent 合格主播数必须大于 0");
+ requireNonNegativeInteger(context, ["agent", "differential", "maxDepth"], value.agent.differential.maxDepth, "Agent 差值深度不能小于 0");
+ validateAgentLevels(context, value.agent.levels);
+ requirePositiveInteger(context, ["bd", "qualifiedAgencyMin"], value.bd.qualifiedAgencyMin, "BD 合格 Agency 数必须大于 0");
+ requirePositiveInteger(context, ["bd", "qualifiedHostPerAgencyMin"], value.bd.qualifiedHostPerAgencyMin, "BD 每 Agency 合格主播数必须大于 0");
+ validateBDLevels(context, value.bd.levels);
+ requirePositiveNumber(context, ["manager", "coinSellerRechargeThresholdUsd"], value.manager.coinSellerRechargeThresholdUsd, "经理币商充值门槛必须大于 0");
+ requirePercent(context, ["manager", "coinSellerRechargeCommissionPercent"], value.manager.coinSellerRechargeCommissionPercent, "经理币商提成比例必须在 0-100 之间", true);
+ requirePercent(context, ["manager", "hostPointCommissionPercent"], value.manager.hostPointCommissionPercent, "经理主播提成比例必须在 0-100 之间", true);
+ requirePositiveInteger(context, ["coinSeller", "orderTimeoutSeconds"], value.coinSeller.orderTimeoutSeconds, "币商订单超时秒数必须大于 0");
+ requirePercent(context, ["coinSeller", "sellerPointSettlePercent"], value.coinSeller.sellerPointSettlePercent, "币商结算比例必须在 0-100 之间", true);
+ requirePercent(context, ["coinSeller", "sellerPointRewardPercent"], value.coinSeller.sellerPointRewardPercent, "币商奖励比例必须在 0-100 之间", true);
+ if (numberValue(value.coinSeller.sellerPointSettlePercent) + numberValue(value.coinSeller.sellerPointRewardPercent) > 100) {
+ context.addIssue({ code: "custom", message: "币商结算比例和奖励比例合计不能超过 100", path: ["coinSeller", "sellerPointRewardPercent"] });
+ }
+ requirePercent(context, ["coinSeller", "successRateCloseThresholdPercent"], value.coinSeller.successRateCloseThresholdPercent, "成功率关闭门槛必须在 0-100 之间", true);
+ validateCoinSellerLevels(context, value.coinSeller.levels);
+ requireNonNegativeInteger(context, ["tasks", "newHost7dMaxPoints"], value.tasks.newHost7dMaxPoints, "新主播 7 日任务积分不能小于 0");
+ });
+
+export const policyTemplateFormSchema = z.object({
+ description: z.string().trim().max(512, "模板说明不能超过 512 个字符"),
+ name: z.string().trim().min(1, "请输入模板名称").max(160, "模板名称不能超过 160 个字符"),
+ rule: policyRuleFormSchema,
+ status: z.enum(statusValues),
+ templateCode: z.string().trim().min(1, "请输入模板编码").max(96, "模板编码不能超过 96 个字符"),
+ templateVersion: z.string().trim().min(1, "请输入模板版本").max(64, "模板版本不能超过 64 个字符"),
+});
+
+export const policyInstanceFormSchema = z
+ .object({
+ effectiveFrom: z.union([z.string(), z.number()]).optional(),
+ effectiveTo: z.union([z.string(), z.number()]).optional(),
+ instanceCode: z.string().trim().min(1, "请输入实例编码").max(96, "实例编码不能超过 96 个字符"),
+ regionId: z.union([z.string(), z.number()]).optional(),
+ regionScopeMode: z.enum(regionScopeModes),
+ status: z.enum(statusValues),
+ templateCode: z.string().trim().min(1, "请选择模板编码").max(96, "模板编码不能超过 96 个字符"),
+ templateVersion: z.string().trim().min(1, "请选择模板版本").max(64, "模板版本不能超过 64 个字符"),
+ })
+ .superRefine((value, context) => {
+ if (value.regionScopeMode === "region_id") {
+ requirePositiveInteger(context, ["regionId"], value.regionId || "", "请选择适用区域");
+ }
+ const fromMs = timeValueToMs(value.effectiveFrom);
+ const toMs = timeValueToMs(value.effectiveTo);
+ if (fromMs < 0 || toMs < 0 || (toMs > 0 && fromMs > 0 && toMs <= fromMs)) {
+ context.addIssue({ code: "custom", message: "生效时间范围不正确", path: ["effectiveTo"] });
+ }
+ });
+
+export function policyTemplateFormFromItem(item?: Partial & { ruleJson?: unknown; rule_json?: unknown; template_code?: string; template_version?: string } | null): PolicyTemplateForm {
+ const rule = ruleFormFromJson(item?.ruleJson ?? item?.rule_json ?? defaultPolicyRule());
+ return {
+ description: stringValue(item?.description, "新文档口径：允许自刷；BD 按 UTC 当月自然月；Huwaa 使用 POINT/COIN_SELLER_POINT。"),
+ name: stringValue(item?.name, "第一套政策：Google 70000 + 币商 92000-100000"),
+ rule,
+ status: normalizeStatus(item?.status),
+ templateCode: stringValue(item?.templateCode ?? item?.template_code, DEFAULT_POLICY_TEMPLATE_CODE),
+ templateVersion: stringValue(item?.templateVersion ?? item?.template_version, DEFAULT_POLICY_TEMPLATE_VERSION),
+ };
+}
+
+export function policyTemplatePayloadFromForm(form: PolicyTemplateForm) {
+ const parsed = policyTemplateFormSchema.parse(form);
+ return {
+ description: parsed.description.trim(),
+ name: parsed.name.trim(),
+ rule_json: ruleObjectFromForm(parsed.rule),
+ status: parsed.status,
+ template_code: parsed.templateCode.trim(),
+ template_version: parsed.templateVersion.trim(),
+ };
+}
+
+export function policyInstanceFormFromTemplate(template?: { templateCode?: string; templateVersion?: string; template_code?: string; template_version?: string } | null): PolicyInstanceForm {
+ const templateCode = stringValue(template?.templateCode ?? template?.template_code, DEFAULT_POLICY_TEMPLATE_CODE);
+ const templateVersion = stringValue(template?.templateVersion ?? template?.template_version, DEFAULT_POLICY_TEMPLATE_VERSION);
+ return {
+ effectiveFrom: "",
+ effectiveTo: "",
+ instanceCode: templateCode === DEFAULT_POLICY_TEMPLATE_CODE ? "huwaa_first_google70000_coin_seller_92000_100000" : "",
+ regionId: "",
+ regionScopeMode: "all_active_regions",
+ status: "active",
+ templateCode,
+ templateVersion,
+ };
+}
+
+export function policyInstancePayloadFromForm(form: PolicyInstanceForm) {
+ const parsed = policyInstanceFormSchema.parse(form);
+ return {
+ effective_from_ms: timeValueToMs(parsed.effectiveFrom),
+ effective_to_ms: timeValueToMs(parsed.effectiveTo),
+ instance_code: parsed.instanceCode.trim(),
+ region_scope: parsed.regionScopeMode === "region_id" ? `region_id:${integerValue(parsed.regionId || 0)}` : "all_active_regions",
+ status: parsed.status,
+ template_code: parsed.templateCode.trim(),
+ template_version: parsed.templateVersion.trim(),
+ };
+}
+
+export function ruleFormFromJson(raw: unknown): PolicyRuleForm {
+ const rule = parseRuleObject(raw);
+ const host = objectValue(rule.host);
+ const agent = objectValue(rule.agent);
+ const differential = objectValue(agent.differential);
+ const bd = objectValue(rule.bd);
+ const manager = objectValue(rule.manager);
+ const coinSeller = objectValue(rule.coin_seller);
+ const tasks = objectValue(rule.tasks);
+ const gameInvite = objectValue(rule.game_invite);
+ return {
+ agent: {
+ differential: {
+ crossLevelFormula: stringValue(differential.cross_level_formula, "parent_minus_direct_child"),
+ enabled: booleanValue(differential.enabled, true),
+ maxDepth: inputValue(differential.max_depth, 2),
+ },
+ levels: arrayValue(agent.levels).map(agentLevelFromRule),
+ period: stringValue(agent.period, "rolling_30d"),
+ qualifiedHostMin: inputValue(agent.qualified_host_min, 3),
+ supportDays: inputValue(agent.support_days, 30),
+ supportRatioPercent: inputValue(agent.support_ratio_percent, 8),
+ },
+ allowSelfBrushing: booleanValue(rule.allow_self_brushing, true),
+ bd: {
+ base: stringValue(bd.base, "host_effective_income"),
+ levels: arrayValue(bd.levels).map(bdLevelFromRule),
+ period: stringValue(bd.period, "utc_calendar_month"),
+ qualifiedAgencyMin: inputValue(bd.qualified_agency_min, 3),
+ qualifiedHostPerAgencyMin: inputValue(bd.qualified_host_per_agency_min, 3),
+ },
+ coinSeller: {
+ levels: arrayValue(coinSeller.levels).map(coinSellerLevelFromRule),
+ orderTimeoutSeconds: inputValue(coinSeller.order_timeout_seconds, 7200),
+ sellerPointRewardPercent: inputValue(coinSeller.seller_point_reward_percent, 5),
+ sellerPointSettlePercent: inputValue(coinSeller.seller_point_settle_percent, 95),
+ successRateCloseThresholdPercent: inputValue(coinSeller.success_rate_close_threshold_percent, 95),
+ withdrawOrderEnabled: booleanValue(coinSeller.withdraw_order_enabled, true),
+ },
+ gameInvite: {
+ enabled: booleanValue(gameInvite.enabled, true),
+ period: stringValue(gameInvite.period, "rolling_30d"),
+ },
+ googleCoinPerUsd: inputValue(rule.google_coin_per_usd, 70000),
+ host: {
+ affectsRoomHeat: booleanValue(host.affects_room_heat, false),
+ minimumWithdrawPoints: inputValue(host.minimum_withdraw_points, 1000000),
+ pointRatioPercent: inputValue(host.point_ratio_percent, 70),
+ withdrawFeeBps: inputValue(host.withdraw_fee_bps, 500),
+ },
+ manager: {
+ coinSellerRechargeCommissionPercent: inputValue(manager.coin_seller_recharge_commission_percent, 3),
+ coinSellerRechargeThresholdUsd: inputValue(manager.coin_seller_recharge_threshold_usd, 2000),
+ hostPointCommissionPercent: inputValue(manager.host_point_commission_percent, 2),
+ },
+ pointsPerUsd: inputValue(rule.points_per_usd, 100000),
+ rawJson: JSON.stringify(rule, null, 2),
+ tasks: {
+ newHost7dMaxPoints: inputValue(tasks.new_host_7d_max_points, 350000),
+ rewardAssetType: normalizeRewardAsset(tasks.reward_asset_type),
+ },
+ };
+}
+
+export function ruleJsonFromForm(form: PolicyRuleForm): string {
+ return JSON.stringify(ruleObjectFromForm(form));
+}
+
+export function ruleObjectFromForm(form: PolicyRuleForm): RuleObject {
+ const parsed = policyRuleFormSchema.parse(form);
+ const base = parseRuleObject(parsed.rawJson);
+ const baseAgent = objectValue(base.agent);
+ const baseBD = objectValue(base.bd);
+ const baseCoinSeller = objectValue(base.coin_seller);
+ const baseAgentLevelExtras = extraByKey(arrayValue(baseAgent.levels), "level", ["level", "manual_review", "max_usd", "min_usd", "name", "qualified_host_min", "ratio_percent"]);
+ const baseBDLevelExtras = extraByKey(arrayValue(baseBD.levels), "level", ["commission_percent", "level", "name", "salary_usd", "threshold_usd"]);
+ const baseCoinSellerLevelExtras = extraByKey(arrayValue(baseCoinSeller.levels), "name", ["coin_per_usd", "name", "single_recharge_threshold_usd", "threshold_usd", "withdraw_order_enabled"]);
+
+ return {
+ ...base,
+ allow_self_brushing: parsed.allowSelfBrushing,
+ google_coin_per_usd: integerValue(parsed.googleCoinPerUsd),
+ points_per_usd: integerValue(parsed.pointsPerUsd),
+ host: {
+ ...objectValue(base.host),
+ affects_room_heat: parsed.host.affectsRoomHeat,
+ minimum_withdraw_points: integerValue(parsed.host.minimumWithdrawPoints),
+ point_ratio_percent: numberValue(parsed.host.pointRatioPercent),
+ withdraw_fee_bps: integerValue(parsed.host.withdrawFeeBps),
+ },
+ agent: {
+ ...baseAgent,
+ differential: {
+ ...objectValue(baseAgent.differential),
+ cross_level_formula: parsed.agent.differential.crossLevelFormula.trim(),
+ enabled: parsed.agent.differential.enabled,
+ max_depth: integerValue(parsed.agent.differential.maxDepth),
+ },
+ levels: parsed.agent.levels.map((level) => agentLevelToRule(level, baseAgentLevelExtras.get(String(integerValue(level.level))) || {})),
+ period: parsed.agent.period.trim(),
+ qualified_host_min: integerValue(parsed.agent.qualifiedHostMin),
+ support_days: integerValue(parsed.agent.supportDays),
+ support_ratio_percent: numberValue(parsed.agent.supportRatioPercent),
+ },
+ bd: {
+ ...baseBD,
+ base: parsed.bd.base.trim(),
+ levels: parsed.bd.levels.map((level) => bdLevelToRule(level, baseBDLevelExtras.get(String(integerValue(level.level))) || {})),
+ period: parsed.bd.period.trim(),
+ qualified_agency_min: integerValue(parsed.bd.qualifiedAgencyMin),
+ qualified_host_per_agency_min: integerValue(parsed.bd.qualifiedHostPerAgencyMin),
+ },
+ manager: {
+ ...objectValue(base.manager),
+ coin_seller_recharge_commission_percent: numberValue(parsed.manager.coinSellerRechargeCommissionPercent),
+ coin_seller_recharge_threshold_usd: numberValue(parsed.manager.coinSellerRechargeThresholdUsd),
+ host_point_commission_percent: numberValue(parsed.manager.hostPointCommissionPercent),
+ },
+ coin_seller: {
+ ...baseCoinSeller,
+ levels: parsed.coinSeller.levels.map((level) => coinSellerLevelToRule(level, baseCoinSellerLevelExtras.get(String(level.name || "").trim()) || {})),
+ order_timeout_seconds: integerValue(parsed.coinSeller.orderTimeoutSeconds),
+ seller_point_reward_percent: numberValue(parsed.coinSeller.sellerPointRewardPercent),
+ seller_point_settle_percent: numberValue(parsed.coinSeller.sellerPointSettlePercent),
+ success_rate_close_threshold_percent: numberValue(parsed.coinSeller.successRateCloseThresholdPercent),
+ withdraw_order_enabled: parsed.coinSeller.withdrawOrderEnabled,
+ },
+ tasks: {
+ ...objectValue(base.tasks),
+ new_host_7d_max_points: integerValue(parsed.tasks.newHost7dMaxPoints),
+ reward_asset_type: parsed.tasks.rewardAssetType,
+ },
+ game_invite: {
+ ...objectValue(base.game_invite),
+ enabled: parsed.gameInvite.enabled,
+ period: parsed.gameInvite.period.trim(),
+ },
+ };
+}
+
+export function defaultPolicyRule(): RuleObject {
+ return {
+ points_per_usd: 100000,
+ allow_self_brushing: true,
+ google_coin_per_usd: 70000,
+ host: { point_ratio_percent: 70, affects_room_heat: false, minimum_withdraw_points: 1000000, withdraw_fee_bps: 500 },
+ agent: {
+ period: "rolling_30d",
+ support_ratio_percent: 8,
+ support_days: 30,
+ qualified_host_min: 3,
+ levels: [
+ { level: 1, name: "Lv1", min_usd: 0, max_usd: 200, ratio_percent: 4, qualified_host_min: 3 },
+ { level: 2, name: "Lv2", min_usd: 200, max_usd: 500, ratio_percent: 8, qualified_host_min: 5 },
+ { level: 3, name: "Lv3", min_usd: 500, max_usd: 2000, ratio_percent: 16, qualified_host_min: 10 },
+ { level: 4, name: "Lv4", min_usd: 2000, max_usd: 0, ratio_percent: 20, manual_review: true },
+ ],
+ differential: { enabled: true, max_depth: 2, cross_level_formula: "parent_minus_direct_child" },
+ },
+ bd: {
+ period: "utc_calendar_month",
+ qualified_agency_min: 3,
+ qualified_host_per_agency_min: 3,
+ base: "host_effective_income",
+ levels: [
+ { level: 1, name: "测试BD-1", threshold_usd: 100, salary_usd: 5, commission_percent: 1 },
+ { level: 2, name: "测试BD-2", threshold_usd: 300, salary_usd: 15, commission_percent: 1 },
+ { level: 3, name: "正式BD-1", threshold_usd: 700, salary_usd: 35, commission_percent: 1.5 },
+ { level: 4, name: "正式BD-2", threshold_usd: 1000, salary_usd: 50, commission_percent: 1.5 },
+ { level: 5, name: "高级BD-1", threshold_usd: 2000, salary_usd: 100, commission_percent: 2 },
+ { level: 6, name: "高级BD-2", threshold_usd: 3000, salary_usd: 150, commission_percent: 2 },
+ { level: 7, name: "普通BD-1", threshold_usd: 5000, salary_usd: 250, commission_percent: 2.5 },
+ { level: 8, name: "普通BD-2", threshold_usd: 7000, salary_usd: 350, commission_percent: 2.5 },
+ { level: 9, name: "普通Admin-1", threshold_usd: 10000, salary_usd: 500, commission_percent: 3 },
+ { level: 10, name: "普通Admin-2", threshold_usd: 20000, salary_usd: 1000, commission_percent: 3 },
+ { level: 11, name: "超级Admin-1", threshold_usd: 30000, salary_usd: 1500, commission_percent: 3 },
+ { level: 12, name: "超级Admin-2", threshold_usd: 40000, salary_usd: 2000, commission_percent: 3 },
+ ],
+ },
+ manager: { coin_seller_recharge_threshold_usd: 2000, coin_seller_recharge_commission_percent: 3, host_point_commission_percent: 2 },
+ coin_seller: {
+ withdraw_order_enabled: true,
+ levels: [
+ { name: "Beginner", threshold_usd: 100, coin_per_usd: 92000, withdraw_order_enabled: false },
+ { name: "Standard", threshold_usd: 500, coin_per_usd: 96000, withdraw_order_enabled: false },
+ { name: "Senior", single_recharge_threshold_usd: 1000, coin_per_usd: 100000, withdraw_order_enabled: true },
+ ],
+ order_timeout_seconds: 7200,
+ seller_point_settle_percent: 95,
+ seller_point_reward_percent: 5,
+ success_rate_close_threshold_percent: 95,
+ },
+ tasks: { reward_asset_type: "POINT", new_host_7d_max_points: 350000 },
+ game_invite: { enabled: true, period: "rolling_30d" },
+ };
+}
+
+function agentLevelFromRule(raw: unknown): AgentLevelForm {
+ const level = objectValue(raw);
+ return {
+ extra: omitKeys(level, ["level", "manual_review", "max_usd", "min_usd", "name", "qualified_host_min", "ratio_percent"]),
+ level: inputValue(level.level, ""),
+ manualReview: booleanValue(level.manual_review, false),
+ maxUsd: inputValue(level.max_usd, 0),
+ minUsd: inputValue(level.min_usd, 0),
+ name: stringValue(level.name, ""),
+ qualifiedHostMin: inputValue(level.qualified_host_min, 0),
+ ratioPercent: inputValue(level.ratio_percent, 0),
+ };
+}
+
+function bdLevelFromRule(raw: unknown): BDLevelForm {
+ const level = objectValue(raw);
+ return {
+ commissionPercent: inputValue(level.commission_percent, 0),
+ extra: omitKeys(level, ["commission_percent", "level", "name", "salary_usd", "threshold_usd"]),
+ level: inputValue(level.level, ""),
+ name: stringValue(level.name, ""),
+ salaryUsd: inputValue(level.salary_usd, 0),
+ thresholdUsd: inputValue(level.threshold_usd, 0),
+ };
+}
+
+function coinSellerLevelFromRule(raw: unknown): CoinSellerLevelForm {
+ const level = objectValue(raw);
+ return {
+ coinPerUsd: inputValue(level.coin_per_usd, 0),
+ extra: omitKeys(level, ["coin_per_usd", "name", "single_recharge_threshold_usd", "threshold_usd", "withdraw_order_enabled"]),
+ name: stringValue(level.name, ""),
+ singleRechargeThresholdUsd: inputValue(level.single_recharge_threshold_usd, ""),
+ thresholdUsd: inputValue(level.threshold_usd, ""),
+ withdrawOrderEnabled: booleanValue(level.withdraw_order_enabled, false),
+ };
+}
+
+function agentLevelToRule(level: AgentLevelForm, rawExtra: RuleObject): RuleObject {
+ return {
+ ...level.extra,
+ ...rawExtra,
+ level: integerValue(level.level),
+ name: String(level.name || "").trim(),
+ min_usd: numberValue(level.minUsd),
+ max_usd: numberValue(level.maxUsd),
+ ratio_percent: numberValue(level.ratioPercent),
+ qualified_host_min: integerValue(level.qualifiedHostMin),
+ ...(level.manualReview ? { manual_review: true } : {}),
+ };
+}
+
+function bdLevelToRule(level: BDLevelForm, rawExtra: RuleObject): RuleObject {
+ return {
+ ...level.extra,
+ ...rawExtra,
+ level: integerValue(level.level),
+ name: String(level.name || "").trim(),
+ threshold_usd: numberValue(level.thresholdUsd),
+ salary_usd: numberValue(level.salaryUsd),
+ commission_percent: numberValue(level.commissionPercent),
+ };
+}
+
+function coinSellerLevelToRule(level: CoinSellerLevelForm, rawExtra: RuleObject): RuleObject {
+ const result: RuleObject = {
+ ...level.extra,
+ ...rawExtra,
+ name: String(level.name || "").trim(),
+ coin_per_usd: integerValue(level.coinPerUsd),
+ withdraw_order_enabled: level.withdrawOrderEnabled,
+ };
+ if (String(level.singleRechargeThresholdUsd || "").trim()) {
+ result.single_recharge_threshold_usd = numberValue(level.singleRechargeThresholdUsd);
+ }
+ if (String(level.thresholdUsd || "").trim()) {
+ result.threshold_usd = numberValue(level.thresholdUsd);
+ }
+ return result;
+}
+
+function validateAgentLevels(context: z.RefinementCtx, levels: AgentLevelForm[]) {
+ const seen = new Set();
+ levels.forEach((level, index) => {
+ const levelNo = integerValue(level.level);
+ if (!Number.isInteger(levelNo) || levelNo <= 0 || seen.has(levelNo)) {
+ context.addIssue({ code: "custom", message: "Agent 等级必须为不重复的正整数", path: ["agent", "levels", index, "level"] });
+ }
+ seen.add(levelNo);
+ requireNonNegativeNumber(context, ["agent", "levels", index, "minUsd"], level.minUsd, "Agent 最小 USD 不能小于 0");
+ requireNonNegativeNumber(context, ["agent", "levels", index, "maxUsd"], level.maxUsd, "Agent 最大 USD 不能小于 0");
+ if (numberValue(level.maxUsd) > 0 && numberValue(level.maxUsd) <= numberValue(level.minUsd)) {
+ context.addIssue({ code: "custom", message: "Agent 最大 USD 必须大于最小 USD，0 表示无上限", path: ["agent", "levels", index, "maxUsd"] });
+ }
+ requirePercent(context, ["agent", "levels", index, "ratioPercent"], level.ratioPercent, "Agent 提成比例必须在 0-100 之间", false);
+ requireNonNegativeInteger(context, ["agent", "levels", index, "qualifiedHostMin"], level.qualifiedHostMin, "Agent 合格主播数不能小于 0");
+ });
+}
+
+function validateBDLevels(context: z.RefinementCtx, levels: BDLevelForm[]) {
+ const seen = new Set();
+ let previousThreshold = 0;
+ levels
+ .map((level, index) => ({ index, level, levelNo: integerValue(level.level), threshold: numberValue(level.thresholdUsd) }))
+ .sort((left, right) => left.levelNo - right.levelNo)
+ .forEach(({ index, level, levelNo, threshold }) => {
+ if (!Number.isInteger(levelNo) || levelNo <= 0 || seen.has(levelNo)) {
+ context.addIssue({ code: "custom", message: "BD 等级必须为不重复的正整数", path: ["bd", "levels", index, "level"] });
+ }
+ seen.add(levelNo);
+ if (threshold <= 0 || threshold <= previousThreshold) {
+ context.addIssue({ code: "custom", message: "BD 收入门槛必须逐级递增", path: ["bd", "levels", index, "thresholdUsd"] });
+ }
+ requireNonNegativeNumber(context, ["bd", "levels", index, "salaryUsd"], level.salaryUsd, "BD 固定工资不能小于 0");
+ requirePercent(context, ["bd", "levels", index, "commissionPercent"], level.commissionPercent, "BD 提成比例必须在 0-100 之间", false);
+ previousThreshold = threshold;
+ });
+}
+
+function validateCoinSellerLevels(context: z.RefinementCtx, levels: CoinSellerLevelForm[]) {
+ levels.forEach((level, index) => {
+ if (!String(level.name || "").trim()) {
+ context.addIssue({ code: "custom", message: "请输入币商等级名称", path: ["coinSeller", "levels", index, "name"] });
+ }
+ requirePositiveInteger(context, ["coinSeller", "levels", index, "coinPerUsd"], level.coinPerUsd, "币商金币单价必须大于 0");
+ if (!String(level.thresholdUsd || "").trim() && !String(level.singleRechargeThresholdUsd || "").trim()) {
+ context.addIssue({ code: "custom", message: "币商等级必须配置累计门槛或单次充值门槛", path: ["coinSeller", "levels", index, "thresholdUsd"] });
+ }
+ if (String(level.thresholdUsd || "").trim()) {
+ requirePositiveNumber(context, ["coinSeller", "levels", index, "thresholdUsd"], level.thresholdUsd, "币商累计门槛必须大于 0");
+ }
+ if (String(level.singleRechargeThresholdUsd || "").trim()) {
+ requirePositiveNumber(context, ["coinSeller", "levels", index, "singleRechargeThresholdUsd"], level.singleRechargeThresholdUsd, "币商单次充值门槛必须大于 0");
+ }
+ });
+}
+
+function parseRuleObject(raw: unknown): RuleObject {
+ if (typeof raw === "string") {
+ try {
+ return parseRuleObject(JSON.parse(raw || "{}"));
+ } catch (error) {
+ throw new Error(`JSON 格式错误：${errorMessage(error)}`);
+ }
+ }
+ if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+ throw new Error("规则 JSON 必须是对象");
+ }
+ return raw as RuleObject;
+}
+
+function objectValue(value: unknown): RuleObject {
+ return value && typeof value === "object" && !Array.isArray(value) ? (value as RuleObject) : {};
+}
+
+function arrayValue(value: unknown): unknown[] {
+ return Array.isArray(value) ? value : [];
+}
+
+function inputValue(value: unknown, fallback: NumericInput): NumericInput {
+ if (typeof value === "number" && Number.isFinite(value)) {
+ return String(value);
+ }
+ if (typeof value === "string" && value.trim()) {
+ return value.trim();
+ }
+ return String(fallback);
+}
+
+function stringValue(value: unknown, fallback = ""): string {
+ if (typeof value === "string") {
+ return value;
+ }
+ if (value === null || value === undefined) {
+ return fallback;
+ }
+ return String(value);
+}
+
+function booleanValue(value: unknown, fallback: boolean): boolean {
+ return typeof value === "boolean" ? value : fallback;
+}
+
+function normalizeStatus(value: unknown): (typeof statusValues)[number] {
+ return String(value || "active").toLowerCase() === "disabled" ? "disabled" : "active";
+}
+
+function normalizeRewardAsset(value: unknown): (typeof rewardAssetValues)[number] {
+ return String(value || "COIN").toUpperCase() === "POINT" ? "POINT" : "COIN";
+}
+
+function timeValueToMs(value: unknown): number {
+ if (value === "" || value === null || value === undefined) {
+ return 0;
+ }
+ const number = Number(value);
+ return Number.isFinite(number) && number >= 0 ? Math.trunc(number) : -1;
+}
+
+function numberValue(value: unknown): number {
+ const raw = String(value ?? "").trim();
+ if (!/^\d+(\.\d+)?$/.test(raw)) {
+ return Number.NaN;
+ }
+ return Number(raw);
+}
+
+function integerValue(value: unknown): number {
+ const number = numberValue(value);
+ return Number.isFinite(number) ? Math.trunc(number) : Number.NaN;
+}
+
+function requirePositiveInteger(context: z.RefinementCtx, path: (number | string)[], value: unknown, message: string) {
+ const number = integerValue(value);
+ if (!Number.isInteger(number) || number <= 0) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function requireNonNegativeInteger(context: z.RefinementCtx, path: (number | string)[], value: unknown, message: string) {
+ const number = integerValue(value);
+ if (!Number.isInteger(number) || number < 0) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function requirePositiveNumber(context: z.RefinementCtx, path: (number | string)[], value: unknown, message: string) {
+ const number = numberValue(value);
+ if (!Number.isFinite(number) || number <= 0) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function requireNonNegativeNumber(context: z.RefinementCtx, path: (number | string)[], value: unknown, message: string) {
+ const number = numberValue(value);
+ if (!Number.isFinite(number) || number < 0) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function requirePercent(context: z.RefinementCtx, path: (number | string)[], value: unknown, message: string, allowZero: boolean) {
+ const number = numberValue(value);
+ if (!Number.isFinite(number) || number > 100 || (allowZero ? number < 0 : number <= 0)) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function requireIntegerRange(context: z.RefinementCtx, path: (number | string)[], value: unknown, min: number, max: number, message: string) {
+ const number = integerValue(value);
+ if (!Number.isInteger(number) || number < min || number > max) {
+ context.addIssue({ code: "custom", message, path });
+ }
+}
+
+function extraByKey(items: unknown[], key: string, knownKeys: string[]): Map {
+ const result = new Map();
+ items.forEach((item) => {
+ const record = objectValue(item);
+ const rawKey = record[key];
+ if (rawKey !== undefined && rawKey !== null && String(rawKey).trim()) {
+ result.set(String(rawKey).trim(), omitKeys(record, knownKeys));
+ }
+ });
+ return result;
+}
+
+function omitKeys(source: RuleObject, keys: string[]): RuleObject {
+ const blocked = new Set(keys);
+ return Object.fromEntries(Object.entries(source).filter(([key]) => !blocked.has(key)));
+}
+
+function errorMessage(error: unknown): string {
+ return error instanceof Error ? error.message : String(error || "未知错误");
+}
diff --git a/src/shared/api/generated/endpoints.ts b/src/shared/api/generated/endpoints.ts
index 2f6da0a..f6e5f55 100644
--- a/src/shared/api/generated/endpoints.ts
+++ b/src/shared/api/generated/endpoints.ts
@@ -54,6 +54,7 @@ export const API_OPERATIONS = {
createMenu: "createMenu",
createPermission: "createPermission",
createPlatform: "createPlatform",
+ createPolicyInstance: "createPolicyInstance",
createPopup: "createPopup",
createPrettyIdPool: "createPrettyIdPool",
createRechargeProduct: "createRechargeProduct",
@@ -201,6 +202,8 @@ export const API_OPERATIONS = {
listPlatformGrantRecords: "listPlatformGrantRecords",
listPlatformGrantUsers: "listPlatformGrantUsers",
listPlatforms: "listPlatforms",
+ listPolicyInstances: "listPolicyInstances",
+ listPolicyTemplates: "listPolicyTemplates",
listPopups: "listPopups",
listPrettyIdPools: "listPrettyIdPools",
listPrettyIds: "listPrettyIds",
@@ -248,6 +251,7 @@ export const API_OPERATIONS = {
me: "me",
navigationMenus: "navigationMenus",
publishHostAgencyPolicy: "publishHostAgencyPolicy",
+ publishPolicyInstance: "publishPolicyInstance",
recyclePrettyId: "recyclePrettyId",
refresh: "refresh",
refreshGoogleRechargePaid: "refreshGoogleRechargePaid",
@@ -264,6 +268,7 @@ export const API_OPERATIONS = {
retryRoomRpsSettlement: "retryRoomRpsSettlement",
retryRoomTurnoverRewardSettlement: "retryRoomTurnoverRewardSettlement",
revokeResourceGrant: "revokeResourceGrant",
+ savePolicyTemplate: "savePolicyTemplate",
search: "search",
selfGameStatisticsOverview: "selfGameStatisticsOverview",
setAgencyJoinEnabled: "setAgencyJoinEnabled",
@@ -308,6 +313,7 @@ export const API_OPERATIONS = {
updateMenuVisible: "updateMenuVisible",
updatePermission: "updatePermission",
updatePlatform: "updatePlatform",
+ updatePolicyInstanceStatus: "updatePolicyInstanceStatus",
updatePopup: "updatePopup",
updatePrettyIdPool: "updatePrettyIdPool",
updateRechargeProduct: "updateRechargeProduct",
@@ -635,6 +641,13 @@ export const API_ENDPOINTS: Record = {
permission: "game:update",
permissions: ["game:update"]
},
+ createPolicyInstance: {
+ method: "POST",
+ operationId: API_OPERATIONS.createPolicyInstance,
+ path: "/v1/admin/policy-instances",
+ permission: "policy-instance:create",
+ permissions: ["policy-instance:create"]
+ },
createPopup: {
method: "POST",
operationId: API_OPERATIONS.createPopup,
@@ -1662,6 +1675,20 @@ export const API_ENDPOINTS: Record = {
permission: "game:view",
permissions: ["game:view"]
},
+ listPolicyInstances: {
+ method: "GET",
+ operationId: API_OPERATIONS.listPolicyInstances,
+ path: "/v1/admin/policy-instances",
+ permission: "policy-template:view",
+ permissions: ["policy-template:view"]
+ },
+ listPolicyTemplates: {
+ method: "GET",
+ operationId: API_OPERATIONS.listPolicyTemplates,
+ path: "/v1/admin/policy-templates",
+ permission: "policy-template:view",
+ permissions: ["policy-template:view"]
+ },
listPopups: {
method: "GET",
operationId: API_OPERATIONS.listPopups,
@@ -1983,6 +2010,13 @@ export const API_ENDPOINTS: Record = {
permission: "host-agency-policy:publish",
permissions: ["host-agency-policy:publish"]
},
+ publishPolicyInstance: {
+ method: "POST",
+ operationId: API_OPERATIONS.publishPolicyInstance,
+ path: "/v1/admin/policy-instances/{instance_id}/publish",
+ permission: "policy-instance:publish",
+ permissions: ["policy-instance:publish"]
+ },
recyclePrettyId: {
method: "POST",
operationId: API_OPERATIONS.recyclePrettyId,
@@ -2093,6 +2127,13 @@ export const API_ENDPOINTS: Record = {
permission: "resource-grant:revoke",
permissions: ["resource-grant:revoke"]
},
+ savePolicyTemplate: {
+ method: "POST",
+ operationId: API_OPERATIONS.savePolicyTemplate,
+ path: "/v1/admin/policy-templates",
+ permission: "policy-template:create",
+ permissions: ["policy-template:create"]
+ },
search: {
method: "GET",
operationId: API_OPERATIONS.search,
@@ -2399,6 +2440,13 @@ export const API_ENDPOINTS: Record = {
permission: "game:update",
permissions: ["game:update"]
},
+ updatePolicyInstanceStatus: {
+ method: "PUT",
+ operationId: API_OPERATIONS.updatePolicyInstanceStatus,
+ path: "/v1/admin/policy-instances/{instance_id}/status",
+ permission: "policy-instance:update",
+ permissions: ["policy-instance:update"]
+ },
updatePopup: {
method: "PUT",
operationId: API_OPERATIONS.updatePopup,
diff --git a/src/shared/api/generated/schema.d.ts b/src/shared/api/generated/schema.d.ts
index 5fcd923..fcb6520 100644
--- a/src/shared/api/generated/schema.d.ts
+++ b/src/shared/api/generated/schema.d.ts
@@ -1892,6 +1892,70 @@ export interface paths {
patch?: never;
trace?: never;
};
+ "/admin/policy-templates": {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ get: operations["listPolicyTemplates"];
+ put?: never;
+ post: operations["savePolicyTemplate"];
+ delete?: never;
+ options?: never;
+ head?: never;
+ patch?: never;
+ trace?: never;
+ };
+ "/admin/policy-instances": {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ get: operations["listPolicyInstances"];
+ put?: never;
+ post: operations["createPolicyInstance"];
+ delete?: never;
+ options?: never;
+ head?: never;
+ patch?: never;
+ trace?: never;
+ };
+ "/admin/policy-instances/{instance_id}/publish": {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ get?: never;
+ put?: never;
+ post: operations["publishPolicyInstance"];
+ delete?: never;
+ options?: never;
+ head?: never;
+ patch?: never;
+ trace?: never;
+ };
+ "/admin/policy-instances/{instance_id}/status": {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ get?: never;
+ put: operations["updatePolicyInstanceStatus"];
+ post?: never;
+ delete?: never;
+ options?: never;
+ head?: never;
+ patch?: never;
+ trace?: never;
+ };
"/admin/payment/recharge-bills": {
parameters: {
query?: never;
@@ -3978,6 +4042,87 @@ export interface components {
pageSize: number;
total: number;
};
+ PolicyTemplate: {
+ /** Format: int64 */
+ template_id?: number;
+ /** Format: int64 */
+ version_id?: number;
+ template_code?: string;
+ template_version?: string;
+ name?: string;
+ /** @enum {string} */
+ status?: "active" | "disabled";
+ rule_json?: {
+ [key: string]: unknown;
+ };
+ description?: string;
+ /** Format: int64 */
+ created_at_ms?: number;
+ /** Format: int64 */
+ updated_at_ms?: number;
+ };
+ PolicyTemplateInput: {
+ template_code: string;
+ template_version: string;
+ name: string;
+ /** @enum {string} */
+ status?: "active" | "disabled";
+ rule_json: {
+ [key: string]: unknown;
+ };
+ description?: string;
+ };
+ PolicyInstance: {
+ /** Format: int64 */
+ instance_id?: number;
+ app_code?: string;
+ instance_code?: string;
+ template_code?: string;
+ template_version?: string;
+ region_scope?: string;
+ /** @enum {string} */
+ status?: "active" | "disabled";
+ /** Format: int64 */
+ effective_from_ms?: number;
+ /** Format: int64 */
+ effective_to_ms?: number;
+ /** @enum {string} */
+ publish_status?: "draft" | "published" | "failed";
+ publish_error?: string;
+ /** Format: int64 */
+ last_published_at_ms?: number;
+ /** Format: int64 */
+ created_at_ms?: number;
+ /** Format: int64 */
+ updated_at_ms?: number;
+ };
+ PolicyInstanceInput: {
+ instance_code: string;
+ template_code: string;
+ template_version: string;
+ region_scope?: string;
+ /** @enum {string} */
+ status?: "active" | "disabled";
+ /** Format: int64 */
+ effective_from_ms?: number;
+ /** Format: int64 */
+ effective_to_ms?: number;
+ };
+ PolicyPublishResult: {
+ /** Format: int64 */
+ job_id?: number;
+ /** Format: int64 */
+ instance_id?: number;
+ app_code?: string;
+ instance_code?: string;
+ template_code?: string;
+ template_version?: string;
+ status?: string;
+ target_count?: number;
+ published_region_ids?: number[];
+ /** Format: int64 */
+ published_at_ms?: number;
+ };
ApiResponseCreateUserResult: components["schemas"]["Envelope"] & {
data?: components["schemas"]["CreateUserResult"];
};
@@ -7221,6 +7366,181 @@ export interface operations {
200: components["responses"]["EmptyResponse"];
};
};
+ listPolicyTemplates: {
+ parameters: {
+ query?: {
+ keyword?: string;
+ status?: "active" | "disabled";
+ page?: number;
+ page_size?: number;
+ };
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ requestBody?: never;
+ responses: {
+ /** @description 收益政策模板分页 */
+ 200: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: {
+ items?: components["schemas"]["PolicyTemplate"][];
+ page?: number;
+ pageSize?: number;
+ page_size?: number;
+ /** Format: int64 */
+ total?: number;
+ };
+ };
+ };
+ };
+ };
+ };
+ savePolicyTemplate: {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ requestBody: {
+ content: {
+ "application/json": components["schemas"]["PolicyTemplateInput"];
+ };
+ };
+ responses: {
+ /** @description 已保存的收益政策模板 */
+ 201: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: components["schemas"]["PolicyTemplate"];
+ };
+ };
+ };
+ };
+ };
+ listPolicyInstances: {
+ parameters: {
+ query?: {
+ keyword?: string;
+ status?: "active" | "disabled";
+ page?: number;
+ page_size?: number;
+ };
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ requestBody?: never;
+ responses: {
+ /** @description 收益政策实例分页 */
+ 200: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: {
+ items?: components["schemas"]["PolicyInstance"][];
+ page?: number;
+ pageSize?: number;
+ page_size?: number;
+ /** Format: int64 */
+ total?: number;
+ };
+ };
+ };
+ };
+ };
+ };
+ createPolicyInstance: {
+ parameters: {
+ query?: never;
+ header?: never;
+ path?: never;
+ cookie?: never;
+ };
+ requestBody: {
+ content: {
+ "application/json": components["schemas"]["PolicyInstanceInput"];
+ };
+ };
+ responses: {
+ /** @description 已创建的收益政策实例 */
+ 201: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: components["schemas"]["PolicyInstance"];
+ };
+ };
+ };
+ };
+ };
+ publishPolicyInstance: {
+ parameters: {
+ query?: never;
+ header?: never;
+ path: {
+ instance_id: number;
+ };
+ cookie?: never;
+ };
+ requestBody?: never;
+ responses: {
+ /** @description 收益政策发布结果 */
+ 200: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: components["schemas"]["PolicyPublishResult"];
+ };
+ };
+ };
+ };
+ };
+ updatePolicyInstanceStatus: {
+ parameters: {
+ query?: never;
+ header?: never;
+ path: {
+ instance_id: number;
+ };
+ cookie?: never;
+ };
+ requestBody: {
+ content: {
+ "application/json": {
+ /** @enum {string} */
+ status: "active" | "disabled";
+ };
+ };
+ };
+ responses: {
+ /** @description 已更新状态的收益政策实例 */
+ 200: {
+ headers: {
+ [name: string]: unknown;
+ };
+ content: {
+ "application/json": components["schemas"]["Envelope"] & {
+ data?: components["schemas"]["PolicyInstance"];
+ };
+ };
+ };
+ };
+ };
listRechargeBills: {
parameters: {
query?: {
diff --git a/vite.config.js b/vite.config.js
index 367b91a..77e7ea9 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -26,6 +26,13 @@ function redirectSubsystemEntry(req, res, next) {
return;
}
+ if (pathname === "/ops-center") {
+ res.statusCode = 301;
+ res.setHeader("Location", `/ops-center/${query ? `?${query}` : ""}`);
+ res.end();
+ return;
+ }
+
next();
}
@@ -61,7 +68,8 @@ export default defineConfig({
databi: new URL("./databi/index.html", import.meta.url).pathname,
databiSocial: new URL("./databi/social/index.html", import.meta.url).pathname,
finance: new URL("./finance/index.html", import.meta.url).pathname,
- moneyRedirect: new URL("./money/index.html", import.meta.url).pathname
+ moneyRedirect: new URL("./money/index.html", import.meta.url).pathname,
+ opsCenter: new URL("./ops-center/index.html", import.meta.url).pathname
}
}
},