WMS_MAIN/app/model/store.js
liufumingren 1571de341c feat(storage): 新增收货未入库提醒定时任务(货主/客服群通知,短语可配置)
- 新增 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 等文件,无法按行安全拆分,故合并为一次提交。
2026-09-15 23:49:34 +08:00

794 lines
28 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'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;
};