496 lines
15 KiB
JavaScript
496 lines
15 KiB
JavaScript
/**
|
||
* 财务/通用商品配置适配与容量文案解析：将数字类型码转换为前端可编辑模型。
|
||
* 数据不完整时明确失败，不能用空选项、零库存或默认价格掩盖后端配置错误。
|
||
*/
|
||
import { n as product_fields_n } from "~/lib/product-fields.js";
|
||
import { t as bandwidth_display_t } from "~/lib/bandwidth-display.js";
|
||
// 类型码来自既有商品接口：n 为数量类，r 为离散选择类（含级联根）。
|
||
var n = new Set([4, 7, 9, 11, 14, 15, 16, 17, 18, 19]),
|
||
r = new Set([1, 2, 6, 8, 10, 13, 20]);
|
||
function i(e) {
|
||
return typeof e == `object` && e && !Array.isArray(e) ? e : null;
|
||
}
|
||
function a(e) {
|
||
return typeof e == `string` ? e : typeof e == `number` ? String(e) : ``;
|
||
}
|
||
function o(e) {
|
||
return e === !0 || e === 1 || e === `1`;
|
||
}
|
||
function s(e) {
|
||
throw Error(`${e}，请刷新重试或联系客服`);
|
||
}
|
||
// 数值不能靠 Number("") 得到伪造的 0；同时校验有限值和业务下界。
|
||
function c(e, t, n = 0) {
|
||
((typeof e != `number` && typeof e != `string`) || String(e).trim() === ``) &&
|
||
s(t);
|
||
let r = Number(e);
|
||
return ((!Number.isFinite(r) || r < n) && s(t), r);
|
||
}
|
||
function l(e) {
|
||
let t = c(e, `商品配置标识无效`, 1);
|
||
return (Number.isSafeInteger(t) || s(`商品配置标识无效`), t);
|
||
}
|
||
function u(e, t = `商品配置数据不完整`) {
|
||
return (Array.isArray(e) || s(t), e);
|
||
}
|
||
// 至少一个选项且 value 唯一，避免控件无法区分不同条目。
|
||
function d(e) {
|
||
return (
|
||
(!e.length || new Set(e.map((e) => e.value)).size !== e.length) &&
|
||
s(`商品配置选项不完整`),
|
||
e
|
||
);
|
||
}
|
||
// 清理区域文案中的“第一区/1区”等编号及冗余分隔，不改区域 id。
|
||
function f(e) {
|
||
let t = `(?:第\\s*)?(?:[一二三四五六七八九十百零〇两]+|[0-9０-９]+)\\s*区`;
|
||
return e
|
||
.replace(RegExp(`[（(]\\s*${t}\\s*[）)]`, `g`), ``)
|
||
.replace(RegExp(t, `g`), ``)
|
||
.replace(/\s{2,}/g, ` `)
|
||
.replace(/^[\s\-—_/·]+|[\s\-—_/·]+$/g, ``)
|
||
.trim();
|
||
}
|
||
/** 展平系统版本、区域嵌套或普通子选项；返回统一 value/label，系统额外保留 group。 */
|
||
function p(e, n) {
|
||
if (n === 5) {
|
||
let t = i(e.sub);
|
||
return (
|
||
t || s(`操作系统配置不完整`),
|
||
d(
|
||
Object.entries(t).flatMap(([e, t]) =>
|
||
u(i(t)?.child).map((t) => {
|
||
let n = i(t);
|
||
return (
|
||
n || s(`操作系统配置不完整`),
|
||
{
|
||
value: l(n.id),
|
||
label: a(n.version || n.option_name).trim() || e,
|
||
group: e,
|
||
}
|
||
);
|
||
}),
|
||
),
|
||
)
|
||
);
|
||
}
|
||
return d(
|
||
n === 12
|
||
? u(e.sub).flatMap((e) => {
|
||
let t = i(e);
|
||
return (
|
||
t || s(`区域配置不完整`),
|
||
u(t.area).map((e) => {
|
||
let n = i(e);
|
||
n || s(`区域配置不完整`);
|
||
let r = [f(a(t.option_name)), f(a(n.area_zh || n.area))].filter(
|
||
Boolean,
|
||
);
|
||
return {
|
||
value: l(n.id),
|
||
label: [...new Set(r)].join(` / `) || `默认区域`,
|
||
};
|
||
})
|
||
);
|
||
})
|
||
: u(e.sub).map((e) => {
|
||
let n = i(e);
|
||
n || s(`商品配置选项不完整`);
|
||
let r = l(n.id);
|
||
return {
|
||
value: r,
|
||
label: bandwidth_display_t(a(n.option_name).trim()) || String(r),
|
||
};
|
||
}),
|
||
);
|
||
}
|
||
/**
|
||
* 转换一个配置项：布尔、系统、选择、级联或数量。
|
||
* 数量上下界与各子区间求交，保留不连续 ranges；最大值为 0 的禁用数量项不展示。
|
||
*/
|
||
function m(e) {
|
||
let t = i(e);
|
||
t || s(`商品配置数据不完整`);
|
||
let o = c(t.option_type, `商品配置类型无效`);
|
||
!r.has(o) &&
|
||
!n.has(o) &&
|
||
![3, 5, 12].includes(o) &&
|
||
s(`该商品配置类型暂不支持`);
|
||
let d = {
|
||
id: String(l(t.id)),
|
||
label: a(t.option_name).trim() || `配置选项`,
|
||
kind:
|
||
o === 20
|
||
? `cascade`
|
||
: o === 3
|
||
? `boolean`
|
||
: o === 5
|
||
? `os`
|
||
: n.has(o)
|
||
? `quantity`
|
||
: `choice`,
|
||
choices: [],
|
||
min: 0,
|
||
max: 0,
|
||
step: 1,
|
||
unit: a(t.unit) || (o === 14 ? `GB` : ``),
|
||
description: a(t.notes),
|
||
};
|
||
if (d.kind === `boolean`)
|
||
return (
|
||
(d.max = 1),
|
||
(d.choices = [
|
||
{
|
||
value: 0,
|
||
label: `否`,
|
||
},
|
||
{
|
||
value: 1,
|
||
label: `是`,
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
if (d.kind !== `quantity`) return ((d.choices = p(t, o)), d);
|
||
if (
|
||
((d.min = c(t.qty_minimum, `商品数量配置无效`)),
|
||
(d.max = c(t.qty_maximum, `商品数量配置无效`, d.min)),
|
||
d.max === 0)
|
||
)
|
||
return null;
|
||
d.step =
|
||
t.qty_stage === void 0 || t.qty_stage === null || t.qty_stage === ``
|
||
? 1
|
||
: c(t.qty_stage, `商品数量步长配置无效`, Number.MIN_VALUE);
|
||
let f = u(t.sub)
|
||
.map((e) => {
|
||
let t = i(e);
|
||
t || s(`商品数量范围配置无效`);
|
||
let n = Math.max(d.min, c(t.qty_minimum, `商品数量范围配置无效`)),
|
||
r = Math.min(d.max, c(t.qty_maximum, `商品数量范围配置无效`));
|
||
return r < n
|
||
? null
|
||
: {
|
||
min: n,
|
||
max: r,
|
||
step: d.step,
|
||
};
|
||
})
|
||
.filter((e) => e !== null);
|
||
return (
|
||
(!f.length || !f.some((e) => e.min === d.min)) &&
|
||
s(`商品数量范围配置不完整`),
|
||
(d.ranges = f),
|
||
d
|
||
);
|
||
}
|
||
// 主机名/密码分别带 show 和 modify，展示与是否允许修改是两个独立开关。
|
||
function h(e, t) {
|
||
let n = i(e);
|
||
return {
|
||
show: o(n?.show),
|
||
editable: o(n?.modify),
|
||
value: a(n?.[t]),
|
||
};
|
||
}
|
||
/** 转换下单自定义字段，复用 PCRE 适配；不支持类型、空下拉选项或重复 id 均报错。 */
|
||
function g(t) {
|
||
if (t == null) return [];
|
||
let n = u(t, `自定义字段配置不完整`).map((t) => {
|
||
let n = i(t);
|
||
n || s(`自定义字段配置不完整`);
|
||
let r = {
|
||
text: `text`,
|
||
password: `password`,
|
||
textarea: `textarea`,
|
||
dropdown: `select`,
|
||
tickbox: `boolean`,
|
||
checkbox: `boolean`,
|
||
link: `link`,
|
||
explain: `explain`,
|
||
}[a(n.field_type)];
|
||
r || s(`该商品自定义字段类型暂不支持`);
|
||
let c = product_fields_n(n.regexpr),
|
||
u = [];
|
||
if (r === `select`) {
|
||
let e =
|
||
typeof n.field_option == `string`
|
||
? n.field_option.split(`,`)
|
||
: Array.isArray(n.field_option) &&
|
||
n.field_option.every((e) => typeof e == `string`)
|
||
? n.field_option
|
||
: [];
|
||
((u = [...new Set(e.map((e) => e.trim()).filter(Boolean))].map((e) => ({
|
||
value: e,
|
||
label: e,
|
||
}))),
|
||
u.length || s(`自定义字段选项不完整`));
|
||
}
|
||
return {
|
||
id: String(l(n.id)),
|
||
label: a(n.field_name).trim() || `自定义字段`,
|
||
kind: r,
|
||
required: o(n.is_required),
|
||
...c,
|
||
explain: a(n.explain_content),
|
||
options: u,
|
||
description: a(n.description),
|
||
};
|
||
});
|
||
return (
|
||
new Set(n.map((e) => e.id)).size !== n.length && s(`自定义字段标识重复`),
|
||
n
|
||
);
|
||
}
|
||
/**
|
||
* 商品配置的总入口：兼容业务数据和 data 包装，生成选项、周期、库存及联动定义。
|
||
* stock 为 null 表示未启用库存控制，不能与真实的 0 库存混淆。
|
||
*/
|
||
function _(e) {
|
||
let t = i(e),
|
||
n = i(t?.product) ? t : i(t?.data),
|
||
r = i(n?.product);
|
||
((!n || !r || (n.status !== void 0 && Number(n.status) !== 200)) &&
|
||
s(`商品配置数据不完整`),
|
||
n.links !== void 0 &&
|
||
n.links !== null &&
|
||
!Array.isArray(n.links) &&
|
||
s(`商品联动配置数据不完整`));
|
||
let l = u(n.option)
|
||
.map(m)
|
||
.filter((e) => e !== null);
|
||
new Set(l.map((e) => e.id)).size !== l.length && s(`商品配置标识重复`);
|
||
let d = u(r.cycle, `商品周期配置不完整`).map((e) => {
|
||
let t = i(e),
|
||
n = a(t?.billingcycle).trim();
|
||
return (
|
||
n || s(`商品周期配置不完整`),
|
||
{
|
||
value: n,
|
||
label: a(t?.billingcycle_zh).trim() || n,
|
||
}
|
||
);
|
||
});
|
||
(!d.length || new Set(d.map((e) => e.value)).size !== d.length) &&
|
||
s(`商品周期配置不完整`);
|
||
let f = o(r.stock_control) ? c(r.qty, `商品库存配置无效`) : null;
|
||
return (
|
||
f !== null && !Number.isSafeInteger(f) && s(`商品库存配置无效`),
|
||
{
|
||
options: l,
|
||
cycles: d,
|
||
allowQty: o(n.allow_qty ?? r.allow_qty),
|
||
stock: f,
|
||
hostname: h(r.host, `host`),
|
||
password: h(r.password, `password`),
|
||
customFields: g(n.custom_fields),
|
||
links: v(n.links ?? [], l),
|
||
linkDefinitions: JSON.parse(JSON.stringify(n.links ?? [])),
|
||
}
|
||
);
|
||
}
|
||
/** 将 seq/sneq 联动解析为本地模型；只保留当前配置项存在且选项有效的完整规则。 */
|
||
function v(e, t) {
|
||
let n = new Map(t.map((e) => [e.id, e]));
|
||
function r(e) {
|
||
let t = i(e),
|
||
r = String(l(t?.config_id)),
|
||
o = n.get(r);
|
||
(!o || ![`seq`, `sneq`].includes(a(t?.relation))) &&
|
||
s(`商品联动配置数据不完整`);
|
||
let u = i(t?.sub_id);
|
||
(!u || !Object.keys(u).length) && s(`商品联动选项不完整`);
|
||
let d =
|
||
o.kind === `quantity`
|
||
? Object.values(u).map((e) => {
|
||
let t = i(e),
|
||
n = c(t?.qty_minimum, `商品联动数量范围无效`);
|
||
return {
|
||
min: n,
|
||
max: c(t?.qty_maximum, `商品联动数量范围无效`, n),
|
||
};
|
||
})
|
||
: [],
|
||
f = [];
|
||
if (o.kind !== `quantity`)
|
||
for (let e of Object.keys(u)) {
|
||
if (!/^\d+$/.test(e)) return null;
|
||
let t = Number(e);
|
||
if (
|
||
!Number.isSafeInteger(t) ||
|
||
(o.kind === `cascade` && t <= 0) ||
|
||
!o.choices.some((e) => e.value === t)
|
||
)
|
||
return null;
|
||
f.push(t);
|
||
}
|
||
return {
|
||
optionId: r,
|
||
relation: t.relation,
|
||
values: f,
|
||
ranges: d,
|
||
};
|
||
}
|
||
return u(e).flatMap((e) => {
|
||
let t = i(e);
|
||
if ((t || s(`商品联动配置数据不完整`), !n.has(String(t.config_id))))
|
||
return [];
|
||
let a = r(t);
|
||
if (!a) return [];
|
||
let o = u(t.result, `商品联动结果不完整`);
|
||
o.length || s(`商品联动结果不完整`);
|
||
let c = o.filter((e) => n.has(String(i(e)?.config_id)));
|
||
if (!c.length) return [];
|
||
let l = c.map(r);
|
||
return l.some((e) => e === null)
|
||
? []
|
||
: [
|
||
{
|
||
...a,
|
||
results: l,
|
||
},
|
||
];
|
||
});
|
||
}
|
||
// seq 表示命中集合/闭区间，sneq 表示其补集；供条件判断和结果过滤共用。
|
||
function y(e, t) {
|
||
let n =
|
||
e.values.includes(t) ||
|
||
e.ranges.some((e) => t !== void 0 && t >= e.min && t <= e.max);
|
||
return e.relation === `seq` ? n : !n;
|
||
}
|
||
/** 当前表单 n 激活规则 t 后，求出选项 e 的可用交集；不会直接修改输入选项。 */
|
||
function b(e, t, n) {
|
||
let r = t.filter((e) => y(e, n[e.optionId])).flatMap((e) => e.results);
|
||
return e.map((e) => {
|
||
let t = r.filter((t) => t.optionId === e.id);
|
||
if (!t.length) return e;
|
||
if (e.kind !== `quantity`)
|
||
return {
|
||
...e,
|
||
choices: e.choices.filter((e) => t.every((t) => y(t, e.value))),
|
||
};
|
||
let n = e.ranges ?? [
|
||
{
|
||
min: e.min,
|
||
max: e.max,
|
||
step: e.step,
|
||
},
|
||
];
|
||
for (let e of t) {
|
||
let t = [];
|
||
// 在规则边界按原步长分段，而非逐容量枚举；多条结果规则顺序求交。
|
||
for (let r of n) {
|
||
let n = [
|
||
...new Set([
|
||
0,
|
||
Math.floor((r.max - r.min) / r.step + 1e-7) + 1,
|
||
...e.ranges.flatMap((e) => [
|
||
Math.max(0, Math.ceil((e.min - r.min) / r.step - 1e-7)),
|
||
Math.floor((e.max - r.min) / r.step + 1e-7) + 1,
|
||
]),
|
||
]),
|
||
]
|
||
.filter(
|
||
(e) =>
|
||
e >= 0 && e <= Math.floor((r.max - r.min) / r.step + 1e-7) + 1,
|
||
)
|
||
.sort((e, t) => e - t);
|
||
for (let i = 0; i < n.length - 1; i++) {
|
||
let a = Number((r.min + n[i] * r.step).toFixed(8)),
|
||
o = Number((r.min + (n[i + 1] - 1) * r.step).toFixed(8));
|
||
o >= a &&
|
||
y(e, a) &&
|
||
t.push({
|
||
min: a,
|
||
max: o,
|
||
step: r.step,
|
||
});
|
||
}
|
||
}
|
||
n = t;
|
||
}
|
||
return {
|
||
...e,
|
||
ranges: n,
|
||
min: n[0]?.min ?? 0,
|
||
max: n.at(-1)?.max ?? -1,
|
||
};
|
||
});
|
||
}
|
||
/** 解析级联接口的子配置与默认选择，校验 id 不与根/其他子项重复，默认值必须可选。 */
|
||
function x(e, t) {
|
||
let n = u(
|
||
i(u(e, `商品级联配置数据不完整`)[0])?.son,
|
||
`商品级联配置数据不完整`,
|
||
),
|
||
r = {};
|
||
return {
|
||
options: n.map((e) => {
|
||
let n = i(e);
|
||
n || s(`商品级联配置数据不完整`);
|
||
let a = m({
|
||
...n,
|
||
option_type: 20,
|
||
});
|
||
(a.id === t || r[a.id] !== void 0) && s(`商品级联配置标识重复`);
|
||
let o = l(n.checkSubId);
|
||
return (
|
||
a.choices.some((e) => e.value === o) || s(`商品级联默认配置无效`),
|
||
(r[a.id] = o),
|
||
{
|
||
...a,
|
||
cascadeRoot: t,
|
||
}
|
||
);
|
||
}),
|
||
values: r,
|
||
};
|
||
}
|
||
// 容量单位保留 B 与 iB 的文案区别，不在此处擅自做十进制/二进制容量换算。
|
||
function S(e) {
|
||
let t = /^([kmgtpe])(?:i?b)?$|^(b)$/i.exec(e.trim());
|
||
return t
|
||
? t[2]
|
||
? `B`
|
||
: `${t[1].toUpperCase()}${/ib$/i.test(e.trim()) ? `iB` : `B`}`
|
||
: ``;
|
||
}
|
||
/**
|
||
* 从单一磁盘规格文案提取 size/unit/type；多容量、乘数、价格或未知残留词均返回 null。
|
||
* t 仅在原文缺单位时作后备，NFKC 先统一全角字符，避免宽松匹配造成错误容量展示。
|
||
*/
|
||
function C(e, t = ``) {
|
||
let n = e.normalize(`NFKC`).trim();
|
||
if (!n || /[×*¥￥$€]|(?:^|[\s([{])[-+]\s*\d/.test(n)) return null;
|
||
let r = [...n.matchAll(/\d+(?:\.\d+)?\s*(?:[kmgtpe](?:i?b)?|b)(?![a-z])/gi)],
|
||
i = r[0],
|
||
a;
|
||
if (r.length === 1) a = S(/[a-z]+$/i.exec(i[0])?.[0] ?? ``);
|
||
else if (r.length === 0 && S(t)) {
|
||
let e = [...n.matchAll(/\d+(?:\.\d+)?/g)];
|
||
if (e.length !== 1) return null;
|
||
((i = e[0]), (a = S(t)));
|
||
} else return null;
|
||
if (!i || !a) return null;
|
||
let o = Number(/^\d+(?:\.\d+)?/.exec(i[0])?.[0]);
|
||
if (!Number.isFinite(o)) return null;
|
||
let s = n.slice(0, i.index) + n.slice(i.index + i[0].length),
|
||
c = [...s.matchAll(/NVMe|SSD|HDD|SAS|SATA/gi)].map((e) =>
|
||
e[0].toUpperCase() === `NVME` ? `NVMe` : e[0].toUpperCase(),
|
||
);
|
||
return s
|
||
.replace(
|
||
/NVMe|SSD|HDD|SAS|SATA|免费赠送|免费|赠送|系统盘|数据盘|云硬盘|云磁盘|云盘|硬盘|磁盘|存储|容量|高性能|高效|普通|标准|通用型|性能型|弹性|本地/gi,
|
||
``,
|
||
)
|
||
.replace(/[\s()[\]{}:：·]/g, ``)
|
||
? null
|
||
: {
|
||
size: o,
|
||
unit: a,
|
||
type: [...new Set(c)].join(` `),
|
||
};
|
||
}
|
||
export { _ as a, v as i, b as n, x as r, C as t };
|