- 新增 app/service/systems/receiving_pending_notice.js:扫描「创建时间超过 min_hours 且不足 max_hours 仍未完成入库」的收货单(wms_receiving 未作废、is_deleted=0,且 status=receiving 或 storage_status<>all),
按货主聚合成一条消息;未绑定货主的单独一批
- 新增 app/schedule/notice_receiving_pending_inbound.js:每 5 分钟单 worker 检查,按各仓库配置的提醒时间(默认 08:30,宽限 10 分钟覆盖调度抖动)执行,
进程内防重入 + Redis 当日锁 receiving_pending_notice🔒{warehouseId}:{YYYYMMDD}(NX/EX 24h,执行异常释放锁允许窗口内重试),保证每仓库每天只提醒一次
- 仓库设置新增字段 wms_store.subject_config.receiving_pending_inbound_notice:
enabled(是否通知收货未入库,flag,默认 0 关闭)/ notice_time(提醒时间 HH:mm,默认 08:30)/ min_hours(超时下限,默认 24)/ max_hours(超时上限,默认 48,须大于 min_hours)
/ notice_template(仓库客服群通知短语)/ store_notice_template(货主群通知短语)
- 通知短语可配置并支持变量替换:{warehouse} {warehouse_id} {store} {store_id} {count} {min_hours} {max_hours} {date} {numbers};
未识别占位符原样保留,留空回退默认短语,最长 500 字符(超长 400)
- 消息结构统一为「短语 + 换行 + 明细(一行一条,最多 20 行,超出提示剩余单数)+ 快速查看/详情查看链接」,不再在结尾追加句号
- 新增通知事件 receiving_pending_inbound(notification_webhook 事件注册 + notice DEFAULT_REGISTERED_EVENT_CODES)与固定群订阅:
store:receiving,fallbackTargets=warehouse:customer_service —— 有货主推货主收货群,无货主或货主未配收货群时推仓库客服群(出站仍走 notify.reply,落 wms_inbox_message)
- 文档:methods/system.json 的 setting.warehouse.getSettings/saveSettings 补充该配置字段(版本 0.3.129 -> 0.3.131),
变更记录新增 2026.09.15-warehouse-pending-receiving-notice / -notice-template(system)、2026-09-15-warehouse-01 / -02(warehouse,事件注册与文案结构);
AI_METHOD_ROUTING.md 同步刷新(新服务 14 个方法)
- 单测 test/app/service/systems/receiving_pending_notice.test.js(11 用例:开关关闭/未命中提醒时间不执行、超时窗口查询条件、货主群通知、无货主回退客服群、
当日只提醒一次、推送失败不重复、扫描异常释放锁重试、行数截断、非法配置回退默认、短语变量替换与明细逐行、未识别占位符保留)全部通过;npx eslint 无告警
同时提交上一轮未提交的 camera/PTZ 改动(app/lib/ptz_client.js 新增、systems/camera.js 与 systemMethods/camera.js:PTZ 下发给打印服务时请求体统一携带 cameraId),
其文档与路由清单改动与本提交共用 methods/system.json 等文件,无法按行安全拆分,故合并为一次提交。
794 lines
28 KiB
JavaScript
794 lines
28 KiB
JavaScript
'use strict';
|
||
|
||
module.exports = app => {
|
||
const { BIGINT, STRING, DATE, TINYINT, JSON: JSON_TYPE } = app.Sequelize;
|
||
const DEFAULT_MAX_NOTICE_WEBHOOK_COUNT = 5;
|
||
const DEFAULT_MAX_WAVE_QUANTITY = 500;
|
||
const INVENTORY_WARNING_RULE_COLOR_MAP = Object.freeze({
|
||
1: '#ff4d4f',
|
||
2: '#ff7a45',
|
||
3: '#faad14',
|
||
4: '#fadb14',
|
||
5: '#95de64',
|
||
6: '#52c41a',
|
||
});
|
||
const DEFAULT_INVENTORY_WARNING_RULES = Object.freeze([
|
||
Object.freeze({ name: '01级', key: INVENTORY_WARNING_RULE_COLOR_MAP[1], expire_days: 0, tip_text: '立即报废' }),
|
||
Object.freeze({ name: '02级', key: INVENTORY_WARNING_RULE_COLOR_MAP[2], expire_days: 30, tip_text: '优先处理' }),
|
||
Object.freeze({ name: '03级', key: INVENTORY_WARNING_RULE_COLOR_MAP[3], expire_days: 90, tip_text: '尽快处理' }),
|
||
Object.freeze({ name: '04级', key: INVENTORY_WARNING_RULE_COLOR_MAP[4], expire_days: 180, tip_text: '建议处理' }),
|
||
Object.freeze({ name: '05级', key: INVENTORY_WARNING_RULE_COLOR_MAP[5], expire_days: 365, tip_text: '库存关注' }),
|
||
Object.freeze({ name: '06级', key: INVENTORY_WARNING_RULE_COLOR_MAP[6], expire_days: 999999, tip_text: '常规监控' }),
|
||
]);
|
||
|
||
/**
|
||
* 获取库存预警默认规则(深拷贝)。
|
||
*
|
||
* @return {Array<Object>} 默认库存预警规则。
|
||
*/
|
||
const getDefaultInventoryWarningRules = () => DEFAULT_INVENTORY_WARNING_RULES.map(rule => ({ ...rule }));
|
||
|
||
const DEFAULT_AUTO_OUTBOUND_RULES = Object.freeze({
|
||
enabled: false,
|
||
require_recheck: true,
|
||
require_pack: true,
|
||
require_weigh: true,
|
||
require_sync: true,
|
||
require_print: true,
|
||
require_pick: true,
|
||
});
|
||
|
||
const DEFAULT_CUTOFF_ORDER_TIME = '18:00';
|
||
const CUTOFF_ORDER_TIME_MIN = '00:00';
|
||
const CUTOFF_ORDER_TIME_MAX = '23:59';
|
||
const DEFAULT_ALLOCATE_START_TIME = '08:00';
|
||
const ALLOCATE_START_TIME_MIN = '00:00';
|
||
const ALLOCATE_START_TIME_MAX = '23:59';
|
||
|
||
// 收货未入库提醒:默认关闭,开启后每天按 notice_time 扫描超时未入库的收货单
|
||
const DEFAULT_PENDING_RECEIVING_NOTICE_TIME = '08:30';
|
||
const DEFAULT_PENDING_RECEIVING_MIN_HOURS = 24;
|
||
const DEFAULT_PENDING_RECEIVING_MAX_HOURS = 48;
|
||
const PENDING_RECEIVING_NOTICE_TEMPLATE_MAX_LENGTH = 500;
|
||
const DEFAULT_PENDING_RECEIVING_NOTICE_TEMPLATE = '【收货未入库提醒】以下 {count} 个收货单已超过 {min_hours} 小时且不足 {max_hours} 小时,仍未完成入库,请及时跟进:';
|
||
const DEFAULT_PENDING_RECEIVING_STORE_NOTICE_TEMPLATE = '【收货未入库提醒】以下 {count} 个收货单已超过 {min_hours} 小时仍未完成入库,请尽快完成收货入库:';
|
||
const DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE = Object.freeze({
|
||
enabled: false,
|
||
notice_time: DEFAULT_PENDING_RECEIVING_NOTICE_TIME,
|
||
min_hours: DEFAULT_PENDING_RECEIVING_MIN_HOURS,
|
||
max_hours: DEFAULT_PENDING_RECEIVING_MAX_HOURS,
|
||
notice_template: DEFAULT_PENDING_RECEIVING_NOTICE_TEMPLATE,
|
||
store_notice_template: DEFAULT_PENDING_RECEIVING_STORE_NOTICE_TEMPLATE,
|
||
});
|
||
|
||
const DEFAULT_SUBJECT_CONFIG = Object.freeze({
|
||
max_notice_webhook_count: DEFAULT_MAX_NOTICE_WEBHOOK_COUNT,
|
||
max_wave_quantity: DEFAULT_MAX_WAVE_QUANTITY,
|
||
min_group_order_fetch_quantity: 13,
|
||
auto_allocate_express_exclude_remarks: [],
|
||
default_express_code: 'STO',
|
||
default_platform_code: 'TB',
|
||
sender_name: '',
|
||
sender_tel: '',
|
||
province_name: '',
|
||
city_name: '',
|
||
district_name: '',
|
||
town_name: '',
|
||
address: '',
|
||
receiver_address: '',
|
||
group_wave_prefix: 'B',
|
||
delete_order_wave_prefix: 'A',
|
||
default_location_id: null,
|
||
single_order_pack_max_minutes: 3,
|
||
group_order_pack_max_minutes: 40,
|
||
return_unpack_max_record_minutes: 5,
|
||
inventory_warning_rules: DEFAULT_INVENTORY_WARNING_RULES,
|
||
auto_outbound_rules: DEFAULT_AUTO_OUTBOUND_RULES,
|
||
cutoff_order_enabled: 1,
|
||
cutoff_order_time: DEFAULT_CUTOFF_ORDER_TIME,
|
||
allocate_start_time: DEFAULT_ALLOCATE_START_TIME,
|
||
receiving_pending_inbound_notice: DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE,
|
||
});
|
||
|
||
const normalizeSubjectConfigText = (value, defaultValue) => {
|
||
if (value === undefined || value === null) {
|
||
return defaultValue;
|
||
}
|
||
|
||
const normalized = String(value).trim();
|
||
return normalized === '' ? defaultValue : normalized;
|
||
};
|
||
|
||
const normalizeBooleanFlag = (value, fieldName) => {
|
||
if (value === undefined || value === null || value === '') {
|
||
return undefined;
|
||
}
|
||
|
||
if ([ true, 1, '1', 'true' ].includes(value)) {
|
||
return true;
|
||
}
|
||
|
||
if ([ false, 0, '0', 'false' ].includes(value)) {
|
||
return false;
|
||
}
|
||
|
||
throw new Error(`${fieldName} 必须是布尔值`);
|
||
};
|
||
|
||
/**
|
||
* 规范化库存预警规则配置。
|
||
*
|
||
* @param {Array|null|undefined|string} rawRules 原始库存预警规则。
|
||
* @return {Array<Object>} 规范化后的库存预警规则数组。
|
||
*/
|
||
const normalizeInventoryWarningRules = rawRules => {
|
||
if (rawRules === undefined || rawRules === null || rawRules === '') {
|
||
return getDefaultInventoryWarningRules();
|
||
}
|
||
|
||
if (!Array.isArray(rawRules)) {
|
||
throw new Error('subject_config.inventory_warning_rules 必须是数组');
|
||
}
|
||
|
||
return rawRules.map((rule, index) => {
|
||
const basePath = `subject_config.inventory_warning_rules[${index}]`;
|
||
if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
|
||
throw new Error(`${basePath} 必须是对象`);
|
||
}
|
||
|
||
const name = String(rule.name === undefined || rule.name === null ? '' : rule.name).trim();
|
||
if (!name) {
|
||
throw new Error(`${basePath}.name 不能为空`);
|
||
}
|
||
|
||
const key = String(rule.key === undefined || rule.key === null ? '' : rule.key).trim();
|
||
if (!key) {
|
||
throw new Error(`${basePath}.key 不能为空`);
|
||
}
|
||
|
||
const rawExpireDays = rule.expire_days;
|
||
if (rawExpireDays === undefined || rawExpireDays === null || rawExpireDays === '') {
|
||
throw new Error(`${basePath}.expire_days 必须是非负整数`);
|
||
}
|
||
const expireDays = Number(rawExpireDays);
|
||
if (!Number.isInteger(expireDays) || expireDays < 0) {
|
||
throw new Error(`${basePath}.expire_days 必须是非负整数`);
|
||
}
|
||
|
||
const tipText = rule.tip_text === undefined || rule.tip_text === null ? '' : String(rule.tip_text);
|
||
|
||
return {
|
||
name,
|
||
key,
|
||
expire_days: expireDays,
|
||
tip_text: tipText,
|
||
};
|
||
});
|
||
};
|
||
|
||
/**
|
||
* 规范化自动化出库规则配置。
|
||
* 确保 enabled/require_recheck/require_pack/require_weigh/require_sync/require_print/require_pick 等字段存在且类型正确。
|
||
*
|
||
* @param {Object|undefined|null} rawRules 原始自动化出库规则。
|
||
* @return {Object} 规范化后的自动化出库规则对象。
|
||
*/
|
||
const normalizeAutoOutboundRules = rawRules => {
|
||
if (rawRules === undefined || rawRules === null || rawRules === '') {
|
||
return { ...DEFAULT_AUTO_OUTBOUND_RULES };
|
||
}
|
||
|
||
let parsed = rawRules;
|
||
if (typeof parsed === 'string') {
|
||
try {
|
||
parsed = JSON.parse(parsed);
|
||
} catch (error) {
|
||
return { ...DEFAULT_AUTO_OUTBOUND_RULES };
|
||
}
|
||
}
|
||
|
||
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||
return { ...DEFAULT_AUTO_OUTBOUND_RULES };
|
||
}
|
||
|
||
return {
|
||
enabled: normalizeBooleanFlag(parsed.enabled, 'auto_outbound_rules.enabled') === true,
|
||
require_recheck: parsed.require_recheck !== false,
|
||
require_pack: parsed.require_pack !== false,
|
||
require_weigh: parsed.require_weigh !== false,
|
||
require_sync: parsed.require_sync !== false,
|
||
require_print: parsed.require_print !== false,
|
||
require_pick: parsed.require_pick !== false,
|
||
};
|
||
};
|
||
|
||
/**
|
||
* 规范化正整数字段(小于等于 0 或非整数时抛错)。
|
||
*
|
||
* @param {*} value 原始值,空值返回默认值。
|
||
* @param {number} defaultValue 默认值。
|
||
* @param {string} fieldName 字段全名(用于报错)。
|
||
* @return {number} 规范化后的正整数。
|
||
*/
|
||
const normalizePositiveInteger = (value, defaultValue, fieldName) => {
|
||
if (value === undefined || value === null || value === '') {
|
||
return defaultValue;
|
||
}
|
||
|
||
const normalized = Number(value);
|
||
if (!Number.isInteger(normalized) || normalized <= 0) {
|
||
throw new Error(`${fieldName} 必须是大于 0 的整数`);
|
||
}
|
||
|
||
return normalized;
|
||
};
|
||
|
||
/**
|
||
* 规范化通知短语:空值回退默认短语,非字符串转字符串,超长报错。
|
||
*
|
||
* @param {*} value 原始短语。
|
||
* @param {string} defaultValue 默认短语。
|
||
* @param {string} fieldName 字段全名(用于报错)。
|
||
* @return {string} 规范化后的短语。
|
||
*/
|
||
const normalizeNoticeTemplateText = (value, defaultValue, fieldName) => {
|
||
if (value === undefined || value === null) {
|
||
return defaultValue;
|
||
}
|
||
|
||
const normalized = String(value).trim();
|
||
if (!normalized) {
|
||
return defaultValue;
|
||
}
|
||
|
||
if (normalized.length > PENDING_RECEIVING_NOTICE_TEMPLATE_MAX_LENGTH) {
|
||
throw new Error(`${fieldName} 长度不能超过 ${PENDING_RECEIVING_NOTICE_TEMPLATE_MAX_LENGTH} 字符`);
|
||
}
|
||
|
||
return normalized;
|
||
};
|
||
|
||
/**
|
||
* 规范化「收货未入库提醒」配置。
|
||
* 字段:enabled(是否启用,默认否) / notice_time(提醒时间 HH:mm,默认 08:30)
|
||
* / min_hours(超时下限小时,默认 24) / max_hours(超时上限小时,默认 48)
|
||
* / notice_template(仓库客服群通知短语) / store_notice_template(货主群通知短语)。
|
||
* 非法结构(非对象/非法 JSON)回退默认值;时间格式、小时数越界、短语超长抛错。
|
||
*
|
||
* @param {Object|string|null|undefined} rawValue 原始配置。
|
||
* @return {Object} 规范化后的配置对象。
|
||
*/
|
||
const normalizeReceivingPendingInboundNotice = rawValue => {
|
||
if (rawValue === undefined || rawValue === null || rawValue === '') {
|
||
return { ...DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE };
|
||
}
|
||
|
||
let parsed = rawValue;
|
||
if (typeof parsed === 'string') {
|
||
try {
|
||
parsed = JSON.parse(parsed);
|
||
} catch (error) {
|
||
return { ...DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE };
|
||
}
|
||
}
|
||
|
||
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||
return { ...DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE };
|
||
}
|
||
|
||
const noticeTime = normalizeSubjectConfigText(parsed.notice_time, DEFAULT_PENDING_RECEIVING_NOTICE_TIME);
|
||
if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(noticeTime)) {
|
||
throw new Error('subject_config.receiving_pending_inbound_notice.notice_time 格式必须为 HH:mm(如 08:30)');
|
||
}
|
||
|
||
const minHours = normalizePositiveInteger(
|
||
parsed.min_hours,
|
||
DEFAULT_PENDING_RECEIVING_MIN_HOURS,
|
||
'subject_config.receiving_pending_inbound_notice.min_hours'
|
||
);
|
||
const maxHours = normalizePositiveInteger(
|
||
parsed.max_hours,
|
||
DEFAULT_PENDING_RECEIVING_MAX_HOURS,
|
||
'subject_config.receiving_pending_inbound_notice.max_hours'
|
||
);
|
||
if (minHours >= maxHours) {
|
||
throw new Error('subject_config.receiving_pending_inbound_notice.min_hours 必须小于 max_hours');
|
||
}
|
||
|
||
return {
|
||
enabled: normalizeBooleanFlag(parsed.enabled, 'subject_config.receiving_pending_inbound_notice.enabled') === true,
|
||
notice_time: noticeTime,
|
||
min_hours: minHours,
|
||
max_hours: maxHours,
|
||
notice_template: normalizeNoticeTemplateText(
|
||
parsed.notice_template,
|
||
DEFAULT_PENDING_RECEIVING_NOTICE_TEMPLATE,
|
||
'subject_config.receiving_pending_inbound_notice.notice_template'
|
||
),
|
||
store_notice_template: normalizeNoticeTemplateText(
|
||
parsed.store_notice_template,
|
||
DEFAULT_PENDING_RECEIVING_STORE_NOTICE_TEMPLATE,
|
||
'subject_config.receiving_pending_inbound_notice.store_notice_template'
|
||
),
|
||
};
|
||
};
|
||
|
||
/**
|
||
* 规范化主体配置,确保默认值与字段约束一致。
|
||
*
|
||
* @param {Object|string|null|undefined} rawValue 主体配置原始值。
|
||
* @return {Object} 规范化后的主体配置对象。
|
||
*/
|
||
|
||
const normalizeSubjectConfig = rawValue => {
|
||
if (rawValue === undefined || rawValue === null || rawValue === '') {
|
||
return {
|
||
...DEFAULT_SUBJECT_CONFIG,
|
||
inventory_warning_rules: getDefaultInventoryWarningRules(),
|
||
};
|
||
}
|
||
|
||
let parsed = rawValue;
|
||
if (typeof parsed === 'string') {
|
||
try {
|
||
parsed = JSON.parse(parsed);
|
||
} catch (error) {
|
||
throw new Error('subject_config 必须是合法 JSON 对象');
|
||
}
|
||
}
|
||
|
||
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||
throw new Error('subject_config 必须是对象');
|
||
}
|
||
|
||
const normalized = {
|
||
...parsed,
|
||
};
|
||
|
||
const rawLimit = parsed.max_notice_webhook_count;
|
||
if (rawLimit === undefined || rawLimit === null || rawLimit === '') {
|
||
normalized.max_notice_webhook_count = DEFAULT_MAX_NOTICE_WEBHOOK_COUNT;
|
||
} else {
|
||
const limit = Number(rawLimit);
|
||
if (!Number.isInteger(limit) || limit < 0 || limit > DEFAULT_MAX_NOTICE_WEBHOOK_COUNT) {
|
||
throw new Error(`subject_config.max_notice_webhook_count 必须是 0-${DEFAULT_MAX_NOTICE_WEBHOOK_COUNT} 的整数`);
|
||
}
|
||
normalized.max_notice_webhook_count = limit;
|
||
}
|
||
|
||
const rawMaxWaveQuantity = parsed.max_wave_quantity;
|
||
if (rawMaxWaveQuantity === undefined || rawMaxWaveQuantity === null || rawMaxWaveQuantity === '') {
|
||
normalized.max_wave_quantity = DEFAULT_MAX_WAVE_QUANTITY;
|
||
} else {
|
||
const maxWaveQuantity = Number(rawMaxWaveQuantity);
|
||
if (!Number.isInteger(maxWaveQuantity) || maxWaveQuantity <= 0) {
|
||
throw new Error('subject_config.max_wave_quantity 必须是大于 0 的整数');
|
||
}
|
||
normalized.max_wave_quantity = maxWaveQuantity;
|
||
}
|
||
|
||
const rawMinGroupOrderFetchQuantity = parsed.min_group_order_fetch_quantity;
|
||
if (rawMinGroupOrderFetchQuantity === undefined || rawMinGroupOrderFetchQuantity === null || rawMinGroupOrderFetchQuantity === '') {
|
||
normalized.min_group_order_fetch_quantity = DEFAULT_SUBJECT_CONFIG.min_group_order_fetch_quantity;
|
||
} else {
|
||
const minGroupOrderFetchQuantity = Number(rawMinGroupOrderFetchQuantity);
|
||
if (!Number.isInteger(minGroupOrderFetchQuantity) || minGroupOrderFetchQuantity <= 0) {
|
||
throw new Error('subject_config.min_group_order_fetch_quantity 必须是大于 0 的整数');
|
||
}
|
||
normalized.min_group_order_fetch_quantity = minGroupOrderFetchQuantity;
|
||
}
|
||
|
||
const rawSingleOrderPackMaxMinutes = parsed.single_order_pack_max_minutes;
|
||
if (rawSingleOrderPackMaxMinutes === undefined || rawSingleOrderPackMaxMinutes === null || rawSingleOrderPackMaxMinutes === '') {
|
||
normalized.single_order_pack_max_minutes = DEFAULT_SUBJECT_CONFIG.single_order_pack_max_minutes;
|
||
} else {
|
||
const singleOrderPackMaxMinutes = Number(rawSingleOrderPackMaxMinutes);
|
||
if (!Number.isInteger(singleOrderPackMaxMinutes) || singleOrderPackMaxMinutes <= 0) {
|
||
throw new Error('subject_config.single_order_pack_max_minutes 必须是大于 0 的整数');
|
||
}
|
||
normalized.single_order_pack_max_minutes = singleOrderPackMaxMinutes;
|
||
}
|
||
|
||
const rawGroupOrderPackMaxMinutes = parsed.group_order_pack_max_minutes;
|
||
if (rawGroupOrderPackMaxMinutes === undefined || rawGroupOrderPackMaxMinutes === null || rawGroupOrderPackMaxMinutes === '') {
|
||
normalized.group_order_pack_max_minutes = DEFAULT_SUBJECT_CONFIG.group_order_pack_max_minutes;
|
||
} else {
|
||
const groupOrderPackMaxMinutes = Number(rawGroupOrderPackMaxMinutes);
|
||
if (!Number.isInteger(groupOrderPackMaxMinutes) || groupOrderPackMaxMinutes <= 0) {
|
||
throw new Error('subject_config.group_order_pack_max_minutes 必须是大于 0 的整数');
|
||
}
|
||
normalized.group_order_pack_max_minutes = groupOrderPackMaxMinutes;
|
||
}
|
||
|
||
const rawReturnUnpackMaxRecordMinutes = parsed.return_unpack_max_record_minutes;
|
||
if (rawReturnUnpackMaxRecordMinutes === undefined || rawReturnUnpackMaxRecordMinutes === null || rawReturnUnpackMaxRecordMinutes === '') {
|
||
normalized.return_unpack_max_record_minutes = DEFAULT_SUBJECT_CONFIG.return_unpack_max_record_minutes;
|
||
} else {
|
||
const returnUnpackMaxRecordMinutes = Number(rawReturnUnpackMaxRecordMinutes);
|
||
if (!Number.isInteger(returnUnpackMaxRecordMinutes) || returnUnpackMaxRecordMinutes <= 0) {
|
||
throw new Error('subject_config.return_unpack_max_record_minutes 必须是大于 0 的整数');
|
||
}
|
||
normalized.return_unpack_max_record_minutes = returnUnpackMaxRecordMinutes;
|
||
}
|
||
|
||
const rawExcludeRemarks = parsed.auto_allocate_express_exclude_remarks;
|
||
if (rawExcludeRemarks === undefined || rawExcludeRemarks === null || rawExcludeRemarks === '') {
|
||
normalized.auto_allocate_express_exclude_remarks = [];
|
||
} else {
|
||
if (!Array.isArray(rawExcludeRemarks)) {
|
||
throw new Error('subject_config.auto_allocate_express_exclude_remarks 必须是字符串数组');
|
||
}
|
||
normalized.auto_allocate_express_exclude_remarks = rawExcludeRemarks
|
||
.map((item, index) => {
|
||
if (item === undefined || item === null || item === '') {
|
||
return null;
|
||
}
|
||
const trimmed = String(item).trim();
|
||
if (trimmed === '') {
|
||
throw new Error(`subject_config.auto_allocate_express_exclude_remarks[${index}] 不能为空字符串`);
|
||
}
|
||
return trimmed;
|
||
})
|
||
.filter(Boolean);
|
||
}
|
||
|
||
normalized.default_express_code = normalizeSubjectConfigText(
|
||
parsed.default_express_code,
|
||
DEFAULT_SUBJECT_CONFIG.default_express_code
|
||
);
|
||
normalized.default_platform_code = normalizeSubjectConfigText(
|
||
parsed.default_platform_code,
|
||
DEFAULT_SUBJECT_CONFIG.default_platform_code
|
||
);
|
||
|
||
const rawGroupWavePrefix = parsed.group_wave_prefix;
|
||
if (rawGroupWavePrefix === undefined || rawGroupWavePrefix === null || rawGroupWavePrefix === '') {
|
||
normalized.group_wave_prefix = DEFAULT_SUBJECT_CONFIG.group_wave_prefix;
|
||
} else {
|
||
const groupWavePrefix = String(rawGroupWavePrefix).trim();
|
||
if (groupWavePrefix === '') {
|
||
normalized.group_wave_prefix = DEFAULT_SUBJECT_CONFIG.group_wave_prefix;
|
||
} else {
|
||
if (groupWavePrefix.length > 5) {
|
||
throw new Error('subject_config.group_wave_prefix 最多 5 个字符');
|
||
}
|
||
normalized.group_wave_prefix = groupWavePrefix;
|
||
}
|
||
}
|
||
|
||
const rawDeleteOrderWavePrefix = parsed.delete_order_wave_prefix;
|
||
if (rawDeleteOrderWavePrefix === undefined || rawDeleteOrderWavePrefix === null || rawDeleteOrderWavePrefix === '') {
|
||
normalized.delete_order_wave_prefix = DEFAULT_SUBJECT_CONFIG.delete_order_wave_prefix;
|
||
} else {
|
||
const deleteOrderWavePrefix = String(rawDeleteOrderWavePrefix).trim();
|
||
if (deleteOrderWavePrefix === '') {
|
||
normalized.delete_order_wave_prefix = DEFAULT_SUBJECT_CONFIG.delete_order_wave_prefix;
|
||
} else {
|
||
if (deleteOrderWavePrefix.length > 5) {
|
||
throw new Error('subject_config.delete_order_wave_prefix 最多 5 个字符');
|
||
}
|
||
normalized.delete_order_wave_prefix = deleteOrderWavePrefix;
|
||
}
|
||
}
|
||
|
||
normalized.inventory_warning_rules = normalizeInventoryWarningRules(parsed.inventory_warning_rules);
|
||
normalized.auto_outbound_rules = normalizeAutoOutboundRules(parsed.auto_outbound_rules);
|
||
normalized.receiving_pending_inbound_notice = normalizeReceivingPendingInboundNotice(
|
||
parsed.receiving_pending_inbound_notice
|
||
);
|
||
|
||
const rawDefaultLocationId = parsed.default_location_id;
|
||
if (rawDefaultLocationId === undefined || rawDefaultLocationId === null || rawDefaultLocationId === '') {
|
||
normalized.default_location_id = null;
|
||
} else {
|
||
const defaultLocationId = Number(rawDefaultLocationId);
|
||
if (!Number.isInteger(defaultLocationId) || defaultLocationId <= 0) {
|
||
throw new Error('subject_config.default_location_id 必须是正整数库位ID');
|
||
}
|
||
normalized.default_location_id = defaultLocationId;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(parsed, 'cutoff_order_enabled')) {
|
||
normalized.cutoff_order_enabled = normalizeBooleanFlag(parsed.cutoff_order_enabled, 'subject_config.cutoff_order_enabled');
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(parsed, 'cutoff_order_time')) {
|
||
const cutoffTime = normalizeSubjectConfigText(parsed.cutoff_order_time, DEFAULT_CUTOFF_ORDER_TIME);
|
||
if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(cutoffTime)) {
|
||
throw new Error('subject_config.cutoff_order_time 格式必须为 HH:mm(如 18:00)');
|
||
}
|
||
if (cutoffTime < CUTOFF_ORDER_TIME_MIN || cutoffTime > CUTOFF_ORDER_TIME_MAX) {
|
||
normalized.cutoff_order_time = DEFAULT_CUTOFF_ORDER_TIME;
|
||
} else {
|
||
normalized.cutoff_order_time = cutoffTime;
|
||
}
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(parsed, 'allocate_start_time')) {
|
||
const allocateStartTime = normalizeSubjectConfigText(parsed.allocate_start_time, DEFAULT_ALLOCATE_START_TIME);
|
||
if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(allocateStartTime)) {
|
||
throw new Error('subject_config.allocate_start_time 格式必须为 HH:mm(如 08:00)');
|
||
}
|
||
if (allocateStartTime < ALLOCATE_START_TIME_MIN || allocateStartTime > ALLOCATE_START_TIME_MAX) {
|
||
normalized.allocate_start_time = DEFAULT_ALLOCATE_START_TIME;
|
||
} else {
|
||
normalized.allocate_start_time = allocateStartTime;
|
||
}
|
||
} else {
|
||
// 旧数据补齐默认开始自动分配时间
|
||
normalized.allocate_start_time = DEFAULT_ALLOCATE_START_TIME;
|
||
}
|
||
|
||
// 跨字段校验:仅当显式同时提交两个时间字段且相等时拒绝(自动分配窗口为空)
|
||
if (Object.prototype.hasOwnProperty.call(parsed, 'allocate_start_time')
|
||
&& Object.prototype.hasOwnProperty.call(parsed, 'cutoff_order_time')
|
||
&& normalized.allocate_start_time === normalized.cutoff_order_time) {
|
||
throw new Error('subject_config.allocate_start_time 不能等于 subject_config.cutoff_order_time(自动分配窗口为空)');
|
||
}
|
||
|
||
return normalized;
|
||
};
|
||
|
||
const Store = app.model.define('store', {
|
||
id: {
|
||
type: BIGINT.UNSIGNED,
|
||
primaryKey: true,
|
||
autoIncrement: true,
|
||
allowNull: false,
|
||
comment: '商家ID',
|
||
},
|
||
company_name: {
|
||
type: STRING(200),
|
||
allowNull: false,
|
||
unique: true,
|
||
validate: {
|
||
notEmpty: {
|
||
msg: '公司全称不能为空',
|
||
},
|
||
len: {
|
||
args: [ 1, 200 ],
|
||
msg: '公司全称长度应在1-200个字符之间',
|
||
},
|
||
},
|
||
comment: '公司全称',
|
||
},
|
||
business_license: {
|
||
type: STRING(100),
|
||
allowNull: true,
|
||
unique: true,
|
||
comment: '营业执照号',
|
||
},
|
||
legal_person: {
|
||
type: STRING(50),
|
||
allowNull: true,
|
||
comment: '法人代表',
|
||
},
|
||
contact_phone: {
|
||
type: STRING(20),
|
||
allowNull: false,
|
||
validate: {
|
||
notEmpty: {
|
||
msg: '联系电话不能为空',
|
||
},
|
||
is: {
|
||
args: /^[0-9+\-()\s]+$/,
|
||
msg: '请输入有效的联系电话',
|
||
},
|
||
},
|
||
comment: '联系电话',
|
||
},
|
||
contact_email: {
|
||
type: STRING(100),
|
||
allowNull: true,
|
||
comment: '联系邮箱',
|
||
},
|
||
contact_person: {
|
||
type: STRING(50),
|
||
allowNull: false,
|
||
validate: {
|
||
notEmpty: {
|
||
msg: '联系人不能为空',
|
||
},
|
||
len: {
|
||
args: [ 1, 50 ],
|
||
msg: '联系人姓名长度应在1-50个字符之间',
|
||
},
|
||
},
|
||
comment: '联系人',
|
||
},
|
||
address: {
|
||
type: STRING(500),
|
||
allowNull: true,
|
||
comment: '公司地址',
|
||
},
|
||
industry: {
|
||
type: STRING(100),
|
||
allowNull: true,
|
||
comment: '所属行业',
|
||
},
|
||
account_id: {
|
||
type: BIGINT.UNSIGNED,
|
||
allowNull: false,
|
||
comment: '关联账号ID(商家管理员)',
|
||
},
|
||
status: {
|
||
type: TINYINT(4),
|
||
allowNull: false,
|
||
defaultValue: 1,
|
||
validate: {
|
||
isIn: {
|
||
args: [[ 0, 1, 2 ]],
|
||
msg: '状态值不合法,0-禁用,1-启用,2-审核中',
|
||
},
|
||
},
|
||
comment: '状态:0-禁用,1-启用,2-审核中',
|
||
},
|
||
created_by: {
|
||
type: BIGINT.UNSIGNED,
|
||
allowNull: false,
|
||
comment: '创建人',
|
||
},
|
||
created_at: {
|
||
type: DATE,
|
||
allowNull: false,
|
||
defaultValue: app.Sequelize.literal('CURRENT_TIMESTAMP'),
|
||
comment: '创建时间',
|
||
},
|
||
updated_at: {
|
||
type: DATE,
|
||
allowNull: false,
|
||
defaultValue: app.Sequelize.literal('CURRENT_TIMESTAMP'),
|
||
comment: '更新时间',
|
||
},
|
||
project: {
|
||
type: STRING(20),
|
||
allowNull: true,
|
||
comment: '应用',
|
||
},
|
||
auth_end: {
|
||
type: DATE,
|
||
allowNull: true,
|
||
comment: '授权结束时间',
|
||
},
|
||
deleted_at: {
|
||
type: DATE,
|
||
allowNull: true,
|
||
comment: '删除时间',
|
||
},
|
||
quota_bytes: {
|
||
type: BIGINT.UNSIGNED,
|
||
allowNull: false,
|
||
defaultValue: 107374182400,
|
||
comment: '仓库文件存储配额',
|
||
},
|
||
subject_config: {
|
||
type: JSON_TYPE,
|
||
allowNull: true,
|
||
defaultValue: { ...DEFAULT_SUBJECT_CONFIG },
|
||
comment: '主体配置JSON',
|
||
get() {
|
||
return normalizeSubjectConfig(this.getDataValue('subject_config'));
|
||
},
|
||
set(value) {
|
||
this.setDataValue('subject_config', normalizeSubjectConfig(value));
|
||
},
|
||
validate: {
|
||
isValidSubjectConfig(value) {
|
||
normalizeSubjectConfig(value);
|
||
},
|
||
},
|
||
},
|
||
}, {
|
||
tableName: 'wms_store',
|
||
freezeTableName: true,
|
||
underscored: true,
|
||
timestamps: true,
|
||
createdAt: 'created_at',
|
||
updatedAt: 'updated_at',
|
||
paranoid: true,
|
||
deletedAt: 'deleted_at',
|
||
comment: '商家表',
|
||
indexes: [
|
||
{
|
||
name: 'uk_company_name',
|
||
fields: [ 'company_name' ],
|
||
unique: true,
|
||
},
|
||
{
|
||
name: 'uk_business_license',
|
||
fields: [ 'business_license' ],
|
||
unique: true,
|
||
},
|
||
{
|
||
name: 'idx_status',
|
||
fields: [ 'status' ],
|
||
},
|
||
{
|
||
name: 'idx_account_id',
|
||
fields: [ 'account_id' ],
|
||
},
|
||
],
|
||
});
|
||
|
||
// 关联关系 - 使用您推荐的方式
|
||
Store.associate = function() {
|
||
const { Account, Role, AccountStoreEmployee, ProhibitedType, NotificationWebhook } = app.model;
|
||
|
||
// 关联创建人
|
||
Store.belongsTo(Account, {
|
||
foreignKey: 'created_by',
|
||
as: 'creator',
|
||
});
|
||
|
||
// 关联商家管理员账号
|
||
Store.belongsTo(Account, {
|
||
foreignKey: 'account_id',
|
||
as: 'adminAccount',
|
||
});
|
||
|
||
// 关联商家拥有的角色
|
||
Store.hasMany(Role, {
|
||
foreignKey: 'store_id',
|
||
as: 'roles',
|
||
});
|
||
|
||
// 关联商家拥有的账号员工关联
|
||
Store.hasMany(AccountStoreEmployee, {
|
||
foreignKey: 'store_id',
|
||
as: 'accountStoreEmployees',
|
||
});
|
||
|
||
Store.hasMany(ProhibitedType, {
|
||
foreignKey: 'warehouse_id',
|
||
as: 'prohibitedTypes',
|
||
});
|
||
|
||
Store.hasMany(NotificationWebhook, {
|
||
foreignKey: 'store_id',
|
||
as: 'notificationWebhooks',
|
||
});
|
||
};
|
||
|
||
Store.DEFAULT_MAX_NOTICE_WEBHOOK_COUNT = DEFAULT_MAX_NOTICE_WEBHOOK_COUNT;
|
||
Store.DEFAULT_INVENTORY_WARNING_RULES = DEFAULT_INVENTORY_WARNING_RULES;
|
||
Store.DEFAULT_SUBJECT_CONFIG = DEFAULT_SUBJECT_CONFIG;
|
||
Store.normalizeSubjectConfig = normalizeSubjectConfig;
|
||
|
||
// 实例方法:检查商家是否启用
|
||
Store.prototype.isEnabled = function() {
|
||
return this.status === 1;
|
||
};
|
||
|
||
// 实例方法:检查商家是否审核中
|
||
Store.prototype.isReviewing = function() {
|
||
return this.status === 2;
|
||
};
|
||
|
||
// 实例方法:检查是否是仓库
|
||
Store.prototype.isWarehouse = function() {
|
||
return this.project === 'warehouse';
|
||
};
|
||
|
||
// 实例方法:检查授权是否有效
|
||
Store.prototype.isAuthValid = function() {
|
||
if (!this.auth_start || !this.auth_end) {
|
||
return true; // 如果没有设置授权时间,默认有效
|
||
}
|
||
|
||
const now = new Date();
|
||
return now >= new Date(this.auth_start) && now <= new Date(this.auth_end);
|
||
};
|
||
|
||
// 实例方法:检查邮箱是否有效
|
||
Store.prototype.hasValidEmail = function() {
|
||
if (!this.contact_email) {
|
||
return false;
|
||
}
|
||
|
||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
||
return emailRegex.test(this.contact_email);
|
||
};
|
||
|
||
return Store;
|
||
};
|