diff --git a/app/model/after_sale.js b/app/model/after_sale.js index 8615ca1..bfb1930 100644 --- a/app/model/after_sale.js +++ b/app/model/after_sale.js @@ -30,6 +30,7 @@ module.exports = app => { { name: '物流异常', value: 'logistics_issue' }, { name: '客户拒收', value: 'rejected' }, { name: '拦截', value: 'intercept' }, + { name: '取消拦截', value: 'cancel_intercept' }, { name: '核实签收', value: 'verify_delivery' }, { name: '催件', value: 'urge' }, { name: '多发', value: 'extra_item' }, diff --git a/database/migrations/20260921110000-add-waybill-rule-to-intercept-pickup.js b/database/migrations/20260921110000-add-waybill-rule-to-intercept-pickup.js new file mode 100644 index 0000000..a54cfad --- /dev/null +++ b/database/migrations/20260921110000-add-waybill-rule-to-intercept-pickup.js @@ -0,0 +1,111 @@ +'use strict'; + +/** + * 修复拦截/揽收子类型缺少「运单号提取」取号规则关联的问题。 + * + * 背景: + * - 20260917130000 为 intercept(拦截)/ pickup(揽收)补充了关键词,使其能被 v2 引擎命中; + * - 但未关联取号规则。v2 规则引擎 _extractNumbers 在该子类型无规则时返回 [](非 null), + * 不会进入「取号失败」分支,而是直接执行 interceptWaybill / requestPickup, + * 函数因缺运单号返回硬编码错误「请提供运单号」,绕过了回复表配置的取号失败引导语; + * - 20260918150000 又因这两个子类型无取号规则而清空了其系统级 no_number_hint。 + * + * 本次修复(幂等): + * 1. 为系统级 intercept / pickup 子类型关联「运单号提取」取号规则(依赖唯一索引 + * uk_sub_type_rule 做 INSERT IGNORE); + * 2. 将系统级回复行空的 no_number_hint 补为默认运单号引导语(只填空值行)。 + * + * 修复后链路:消息「拦截」→ 命中关键词 → 关联规则存在但未提取到运单号 → extracted=null + * → 返回取号失败引导语(回复表 no_number_hint → 代码默认值兜底)。 + */ + +const REL_TABLE = 'wms_after_sale_sub_type_rule'; +const SUB_TYPE_TABLE = 'wms_after_sale_sub_type'; +const RULE_TABLE = 'wms_inbox_number_rule'; +const REPLY_TABLE = 'wms_after_sale_reply'; + +const HINT_DEFAULT = '请提供运单号(发送:指令+运单号,多个单号用逗号或空格分隔)'; +const RULE_NAME = '运单号提取'; +const SUB_TYPES = [ 'intercept', 'pickup' ]; + +module.exports = { + up: async queryInterface => { + const { sequelize } = queryInterface; + const tables = await queryInterface.showAllTables(); + const exists = t => tables.some(x => (typeof x === 'string' ? x : x.tableName) === t); + if (!exists(REL_TABLE) || !exists(SUB_TYPE_TABLE) || !exists(RULE_TABLE)) return; + + const [ ruleRows ] = await sequelize.query( + 'SELECT id FROM `' + RULE_TABLE + '` WHERE name = :name LIMIT 1', + { replacements: { name: RULE_NAME } } + ); + if (ruleRows.length === 0) { + console.warn(`[MIGRATION] 跳过:未找到取号规则 ${RULE_NAME}`); + return; + } + const ruleId = ruleRows[0].id; + + let inserted = 0; + for (const subType of SUB_TYPES) { + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL AND is_system = 1 LIMIT 1', + { replacements: { type: 'order', subType } } + ); + if (subRows.length === 0) { + console.warn(`[MIGRATION] 跳过:未找到系统级子类型 order.${subType}`); + continue; + } + await sequelize.query( + 'INSERT IGNORE INTO `' + REL_TABLE + '` ' + + '(sub_type_id, number_rule_id, sort_order, created_at, updated_at) ' + + 'VALUES (:sid, :rid, 1, NOW(), NOW())', + { replacements: { sid: subRows[0].id, rid: ruleId } } + ); + inserted += 1; + } + console.log(`[MIGRATION] 取号规则关联插入 ${inserted} 条`); + + // 补充系统级回复行的取号失败引导语(只填空值行) + if (exists(REPLY_TABLE)) { + const [ replyRows ] = await sequelize.query( + 'SELECT r.id FROM `' + REPLY_TABLE + '` r ' + + 'JOIN `' + SUB_TYPE_TABLE + '` st ON st.id = r.sub_type_id ' + + 'WHERE r.warehouse_id IS NULL AND st.type = :type AND st.sub_type IN (:subTypes) ' + + 'AND (r.no_number_hint IS NULL OR r.no_number_hint = :empty)', + { replacements: { type: 'order', subTypes: SUB_TYPES, empty: '' } } + ); + for (const row of replyRows) { + await sequelize.query( + 'UPDATE `' + REPLY_TABLE + '` SET no_number_hint = :hint WHERE id = :id', + { replacements: { hint: HINT_DEFAULT, id: row.id } } + ); + } + console.log(`[MIGRATION] 补充取号失败引导语 ${replyRows.length} 行`); + } + }, + + down: async queryInterface => { + const { sequelize } = queryInterface; + + const [ ruleRows ] = await sequelize.query( + 'SELECT id FROM `' + RULE_TABLE + '` WHERE name = :name LIMIT 1', + { replacements: { name: RULE_NAME } } + ); + if (ruleRows.length === 0) return; + + for (const subType of SUB_TYPES) { + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL AND is_system = 1 LIMIT 1', + { replacements: { type: 'order', subType } } + ); + if (subRows.length === 0) continue; + await sequelize.query( + 'DELETE FROM `' + REL_TABLE + '` WHERE sub_type_id = :sid AND number_rule_id = :rid', + { replacements: { sid: subRows[0].id, rid: ruleRows[0].id } } + ); + } + // 引导语不回退(数据修正,与既有种子迁移 down 语义一致) + }, +}; diff --git a/database/migrations/20260921120000-add-keywords-and-waybill-rule-mis-shipment-extra-item.js b/database/migrations/20260921120000-add-keywords-and-waybill-rule-mis-shipment-extra-item.js new file mode 100644 index 0000000..71006ac --- /dev/null +++ b/database/migrations/20260921120000-add-keywords-and-waybill-rule-mis-shipment-extra-item.js @@ -0,0 +1,147 @@ +'use strict'; + +/** + * 错发(mis_shipment)/ 多发(extra_item)子类型配置补齐:关键词 + 运单号取号规则 + 引导语。 + * + * 背景: + * - v1 引擎(inbox/rules.js STORE_RULES)中错发/多发分别有关键词且 waybill:true: + * 错发:错发、发错(fn=handleStoreFeedback, issueType=wrong) + * 多发:多发、发多(fn=handleStoreFeedback, issueType=multiple) + * - v2 关键词表 wms_after_sale_keyword 中这两个子类型无任何关键词,无法命中; + * 且无「运单号提取」取号规则关联 → v2 引擎 _extractNumbers 返回 [], + * 直接执行 handleStoreFeedback,缺单号时返回函数硬编码错误「请提供运单号」, + * 取号失败引导语分支不可达(与拦截/揽收同款问题)。 + * + * 本次修复(幂等): + * 1. 将 v1 既有关键词作为系统级默认关键词写入(先查后插,NULL 仓库不参与唯一约束); + * 2. 为系统级错发/多发子类型关联「运单号提取」取号规则(INSERT IGNORE 依赖唯一索引 uk_sub_type_rule); + * 3. 将系统级回复行空的 no_number_hint 补为默认运单号引导语(只填空值行,仓库级行不动)。 + */ + +const SUB_TYPE_TABLE = 'wms_after_sale_sub_type'; +const KEYWORD_TABLE = 'wms_after_sale_keyword'; +const REL_TABLE = 'wms_after_sale_sub_type_rule'; +const RULE_TABLE = 'wms_inbox_number_rule'; +const REPLY_TABLE = 'wms_after_sale_reply'; + +const RULE_NAME = '运单号提取'; +const HINT_DEFAULT = '请提供运单号(发送:指令+运单号,多个单号用逗号或空格分隔)'; + +/** 子类型编码 → 默认关键词(与 v1 STORE_RULES 一致) */ +const SUB_TYPE_KEYWORDS = [ + { sub_type: 'mis_shipment', keywords: [ '错发', '发错' ] }, + { sub_type: 'extra_item', keywords: [ '多发', '发多' ] }, +]; + +module.exports = { + up: async queryInterface => { + const { sequelize } = queryInterface; + const tables = await queryInterface.showAllTables(); + const exists = t => tables.some(x => (typeof x === 'string' ? x : x.tableName) === t); + if (!exists(SUB_TYPE_TABLE) || !exists(KEYWORD_TABLE)) return; + + // ─── 1. 默认关键词(先查后插,NULL 仓库不参与唯一约束) ───────── + let inserted = 0; + for (const rule of SUB_TYPE_KEYWORDS) { + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL AND is_system = 1 LIMIT 1', + { replacements: { type: 'order', subType: rule.sub_type } } + ); + if (subRows.length === 0) { + console.warn(`[MIGRATION] 跳过:未找到系统级子类型 order.${rule.sub_type}`); + continue; + } + const subTypeId = subRows[0].id; + let sortOrder = 0; + for (const kw of rule.keywords) { + const [ kwRows ] = await sequelize.query( + 'SELECT id FROM `' + KEYWORD_TABLE + '` WHERE keyword = :kw AND warehouse_id IS NULL LIMIT 1', + { replacements: { kw } } + ); + if (kwRows.length === 0) { + await sequelize.query( + 'INSERT INTO `' + KEYWORD_TABLE + '` ' + + '(warehouse_id, sub_type_id, keyword, is_system, is_enabled, sort_order, created_at, updated_at) ' + + 'VALUES (NULL, :sid, :kw, 1, 1, :so, NOW(), NOW())', + { replacements: { sid: subTypeId, kw, so: sortOrder } } + ); + inserted += 1; + } + sortOrder += 1; + } + } + console.log(`[MIGRATION] 默认关键词插入 ${inserted} 条`); + + // ─── 2. 运单号取号规则关联(INSERT IGNORE,依赖 uk_sub_type_rule) ── + if (exists(REL_TABLE) && exists(RULE_TABLE)) { + const [ ruleRows ] = await sequelize.query( + 'SELECT id FROM `' + RULE_TABLE + '` WHERE name = :name LIMIT 1', + { replacements: { name: RULE_NAME } } + ); + if (ruleRows.length > 0) { + const ruleId = ruleRows[0].id; + let relInserted = 0; + for (const rule of SUB_TYPE_KEYWORDS) { + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL AND is_system = 1 LIMIT 1', + { replacements: { type: 'order', subType: rule.sub_type } } + ); + if (subRows.length === 0) continue; + await sequelize.query( + 'INSERT IGNORE INTO `' + REL_TABLE + '` ' + + '(sub_type_id, number_rule_id, sort_order, created_at, updated_at) ' + + 'VALUES (:sid, :rid, 1, NOW(), NOW())', + { replacements: { sid: subRows[0].id, rid: ruleId } } + ); + relInserted += 1; + } + console.log(`[MIGRATION] 取号规则关联插入 ${relInserted} 条`); + } else { + console.warn(`[MIGRATION] 跳过:未找到取号规则 ${RULE_NAME}`); + } + } + + // ─── 3. 系统级空引导语回填(只填空值行) ───────────────────── + if (exists(REPLY_TABLE)) { + const [ replyRows ] = await sequelize.query( + 'SELECT r.id FROM `' + REPLY_TABLE + '` r ' + + 'JOIN `' + SUB_TYPE_TABLE + '` st ON st.id = r.sub_type_id ' + + 'WHERE r.warehouse_id IS NULL AND st.type = :type AND st.sub_type IN (:subTypes) ' + + 'AND (r.no_number_hint IS NULL OR r.no_number_hint = :empty)', + { replacements: { type: 'order', subTypes: SUB_TYPE_KEYWORDS.map(x => x.sub_type), empty: '' } } + ); + for (const row of replyRows) { + await sequelize.query( + 'UPDATE `' + REPLY_TABLE + '` SET no_number_hint = :hint WHERE id = :id', + { replacements: { hint: HINT_DEFAULT, id: row.id } } + ); + } + console.log(`[MIGRATION] 补充取号失败引导语 ${replyRows.length} 行`); + } + }, + + down: async queryInterface => { + const { sequelize } = queryInterface; + + // 回滚取号规则关联;关键词与引导语不回退(种子类数据,与既有迁移 down 语义一致) + const [ ruleRows ] = await sequelize.query( + 'SELECT id FROM `' + RULE_TABLE + '` WHERE name = :name LIMIT 1', + { replacements: { name: RULE_NAME } } + ); + if (ruleRows.length === 0) return; + for (const rule of SUB_TYPE_KEYWORDS) { + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL AND is_system = 1 LIMIT 1', + { replacements: { type: 'order', subType: rule.sub_type } } + ); + if (subRows.length === 0) continue; + await sequelize.query( + 'DELETE FROM `' + REL_TABLE + '` WHERE sub_type_id = :sid AND number_rule_id = :rid', + { replacements: { sid: subRows[0].id, rid: ruleRows[0].id } } + ); + } + }, +}; diff --git a/database/migrations/20260921130000-add-cancel-intercept-sub-type.js b/database/migrations/20260921130000-add-cancel-intercept-sub-type.js new file mode 100644 index 0000000..18a14d6 --- /dev/null +++ b/database/migrations/20260921130000-add-cancel-intercept-sub-type.js @@ -0,0 +1,203 @@ +'use strict'; + +/** + * 订单类型新增系统级子类型「取消拦截」(cancel_intercept),并补齐 v2 配置链。 + * + * 背景: + * - v1 引擎(inbox/rules.js STORE_RULES)与代码函数表均有 cancelIntercept + * (关键词:取消拦截/撤销拦截/解除拦截/不拦截/不用拦截,waybill:true); + * - v2 的售后子类型表 wms_after_sale_sub_type 中没有该子类型,导致 v2 引擎 + * 无法把「取消拦截」类消息路由到 cancelIntercept 函数(帮助清单缺项)。 + * + * 本次修复(幂等,先查后插;INSERT IGNORE 依赖既有唯一索引): + * 1. 插入系统级子类型 cancel_intercept(sort_order=10,紧跟拦截之后), + * 并将原 sort_order>=10 的系统级 order 子类型顺延 +1; + * 2. 关键词 5 条:取消拦截/撤销拦截/解除拦截/不拦截/不用拦截; + * 3. 群类型白名单:store:after_sales + warehouse:customer_service(与函数 groups 一致); + * 4. 子类型-函数关系:cancelIntercept; + * 5. 取号规则关联:运单号提取(waybill); + * 6. 系统级回复行:reply={back_text}、is_reply=1、create_work_order=1、 + * no_number_hint=默认运单号引导语、is_enabled=1。 + */ + +const SUB_TYPE_TABLE = 'wms_after_sale_sub_type'; +const KEYWORD_TABLE = 'wms_after_sale_keyword'; +const GROUP_REL_TABLE = 'wms_after_sale_sub_type_group'; +const FUNCTION_TABLE = 'wms_after_sale_function'; +const FUNC_REL_TABLE = 'wms_after_sale_sub_type_function'; +const RULE_TABLE = 'wms_inbox_number_rule'; +const RULE_REL_TABLE = 'wms_after_sale_sub_type_rule'; +const REPLY_TABLE = 'wms_after_sale_reply'; + +const SUB_TYPE_CODE = 'cancel_intercept'; +const SUB_TYPE_NAME = '取消拦截'; +const SUB_TYPE_SORT = 10; // 紧跟拦截(9)之后 +const KEYWORDS = [ '取消拦截', '撤销拦截', '解除拦截', '不拦截', '不用拦截' ]; +const GROUP_WHITELIST = [ + { group_type: 'store', sub_group: 'after_sales' }, + { group_type: 'warehouse', sub_group: 'customer_service' }, +]; +const FUNCTION_CODE = 'cancelIntercept'; +const RULE_NAME = '运单号提取'; +const HINT_DEFAULT = '请提供运单号(发送:指令+运单号,多个单号用逗号或空格分隔)'; + +module.exports = { + up: async queryInterface => { + const { sequelize } = queryInterface; + const tables = await queryInterface.showAllTables(); + const exists = t => tables.some(x => (typeof x === 'string' ? x : x.tableName) === t); + if (!exists(SUB_TYPE_TABLE)) return; + + // ─── 1. 子类型(先查;不存在则顺延 sort_order 并插入) ───────── + let [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL LIMIT 1', + { replacements: { type: 'order', subType: SUB_TYPE_CODE } } + ); + if (subRows.length === 0) { + await sequelize.query( + 'UPDATE `' + SUB_TYPE_TABLE + '` SET sort_order = sort_order + 1 ' + + 'WHERE type = :type AND warehouse_id IS NULL AND sort_order >= :sort', + { replacements: { type: 'order', sort: SUB_TYPE_SORT } } + ); + await sequelize.query( + 'INSERT INTO `' + SUB_TYPE_TABLE + '` ' + + '(warehouse_id, type, sub_type, name, is_system, is_enabled, sort_order, created_at, updated_at) ' + + 'VALUES (NULL, :type, :subType, :name, 1, 1, :sort, NOW(), NOW())', + { replacements: { type: 'order', subType: SUB_TYPE_CODE, name: SUB_TYPE_NAME, sort: SUB_TYPE_SORT } } + ); + [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL LIMIT 1', + { replacements: { type: 'order', subType: SUB_TYPE_CODE } } + ); + console.log(`[MIGRATION] 子类型插入 order.${SUB_TYPE_CODE},原 sort_order>=${SUB_TYPE_SORT} 已顺延`); + } + if (subRows.length === 0) { + console.warn(`[MIGRATION] 跳过:子类型 order.${SUB_TYPE_CODE} 缺失且插入失败`); + return; + } + const subTypeId = subRows[0].id; + + // ─── 2. 关键词(先查后插,NULL 仓库不参与唯一约束) ───────── + if (exists(KEYWORD_TABLE)) { + let kwInserted = 0; + for (const [ idx, kw ] of KEYWORDS.entries()) { + const [ kwRows ] = await sequelize.query( + 'SELECT id FROM `' + KEYWORD_TABLE + '` WHERE keyword = :kw AND warehouse_id IS NULL LIMIT 1', + { replacements: { kw } } + ); + if (kwRows.length === 0) { + await sequelize.query( + 'INSERT INTO `' + KEYWORD_TABLE + '` ' + + '(warehouse_id, sub_type_id, keyword, is_system, is_enabled, sort_order, created_at, updated_at) ' + + 'VALUES (NULL, :sid, :kw, 1, 1, :so, NOW(), NOW())', + { replacements: { sid: subTypeId, kw, so: idx } } + ); + kwInserted += 1; + } + } + console.log(`[MIGRATION] 关键词插入 ${kwInserted} 条`); + } + + // ─── 3. 群类型白名单(INSERT IGNORE,依赖 uk_sub_type_group) ── + if (exists(GROUP_REL_TABLE)) { + let grpInserted = 0; + for (const [ idx, g ] of GROUP_WHITELIST.entries()) { + await sequelize.query( + 'INSERT IGNORE INTO `' + GROUP_REL_TABLE + '` ' + + '(sub_type_id, group_type, sub_group, is_system, sort_order, created_at, updated_at) ' + + 'VALUES (:sid, :groupType, :subGroup, 1, :so, NOW(), NOW())', + { replacements: { sid: subTypeId, groupType: g.group_type, subGroup: g.sub_group, so: idx + 1 } } + ); + grpInserted += 1; + } + console.log(`[MIGRATION] 群白名单插入 ${grpInserted} 条`); + } + + // ─── 4. 子类型-函数关系(INSERT IGNORE,依赖 uk_sub_type_function) ── + if (exists(FUNC_REL_TABLE) && exists(FUNCTION_TABLE)) { + const [ fnRows ] = await sequelize.query( + 'SELECT id FROM `' + FUNCTION_TABLE + '` WHERE function_code = :code LIMIT 1', + { replacements: { code: FUNCTION_CODE } } + ); + if (fnRows.length > 0) { + await sequelize.query( + 'INSERT IGNORE INTO `' + FUNC_REL_TABLE + '` ' + + '(sub_type_id, function_id, sort_order, created_at, updated_at) ' + + 'VALUES (:sid, :fid, 1, NOW(), NOW())', + { replacements: { sid: subTypeId, fid: fnRows[0].id } } + ); + console.log(`[MIGRATION] 函数关系插入 ${FUNCTION_CODE}`); + } else { + console.warn(`[MIGRATION] 跳过:未找到处理函数 ${FUNCTION_CODE}`); + } + } + + // ─── 5. 运单号取号规则关联(INSERT IGNORE,依赖 uk_sub_type_rule) ── + if (exists(RULE_REL_TABLE) && exists(RULE_TABLE)) { + const [ ruleRows ] = await sequelize.query( + 'SELECT id FROM `' + RULE_TABLE + '` WHERE name = :name LIMIT 1', + { replacements: { name: RULE_NAME } } + ); + if (ruleRows.length > 0) { + await sequelize.query( + 'INSERT IGNORE INTO `' + RULE_REL_TABLE + '` ' + + '(sub_type_id, number_rule_id, sort_order, created_at, updated_at) ' + + 'VALUES (:sid, :rid, 1, NOW(), NOW())', + { replacements: { sid: subTypeId, rid: ruleRows[0].id } } + ); + console.log(`[MIGRATION] 取号规则关联插入 ${RULE_NAME}`); + } else { + console.warn(`[MIGRATION] 跳过:未找到取号规则 ${RULE_NAME}`); + } + } + + // ─── 6. 系统级回复行(先查后插) ───────────────────────────── + if (exists(REPLY_TABLE)) { + const [ replyRows ] = await sequelize.query( + 'SELECT id FROM `' + REPLY_TABLE + '` WHERE sub_type_id = :sid AND warehouse_id IS NULL LIMIT 1', + { replacements: { sid: subTypeId } } + ); + if (replyRows.length === 0) { + await sequelize.query( + 'INSERT INTO `' + REPLY_TABLE + '` ' + + '(warehouse_id, sub_type_id, reply, is_reply, create_work_order, no_number_hint, is_enabled, created_at, updated_at) ' + + 'VALUES (NULL, :sid, :reply, 1, 1, :hint, 1, NOW(), NOW())', + { replacements: { sid: subTypeId, reply: '{back_text}', hint: HINT_DEFAULT } } + ); + console.log('[MIGRATION] 系统级回复行插入 1 行'); + } + } + }, + + down: async queryInterface => { + const { sequelize } = queryInterface; + + const [ subRows ] = await sequelize.query( + 'SELECT id FROM `' + SUB_TYPE_TABLE + '` ' + + 'WHERE type = :type AND sub_type = :subType AND warehouse_id IS NULL LIMIT 1', + { replacements: { type: 'order', subType: SUB_TYPE_CODE } } + ); + if (subRows.length === 0) return; + const subTypeId = subRows[0].id; + + // 回滚关联与配置(关键词/回复行/白名单/函数/取号规则) + await sequelize.query('DELETE FROM `' + REPLY_TABLE + '` WHERE sub_type_id = :sid AND warehouse_id IS NULL', { replacements: { sid: subTypeId } }); + await sequelize.query('DELETE FROM `' + KEYWORD_TABLE + '` WHERE sub_type_id = :sid AND warehouse_id IS NULL', { replacements: { sid: subTypeId } }); + await sequelize.query('DELETE FROM `' + GROUP_REL_TABLE + '` WHERE sub_type_id = :sid', { replacements: { sid: subTypeId } }); + await sequelize.query('DELETE FROM `' + FUNC_REL_TABLE + '` WHERE sub_type_id = :sid', { replacements: { sid: subTypeId } }); + await sequelize.query('DELETE FROM `' + RULE_REL_TABLE + '` WHERE sub_type_id = :sid', { replacements: { sid: subTypeId } }); + + // 删除子类型并恢复 sort_order 顺延 + await sequelize.query( + 'DELETE FROM `' + SUB_TYPE_TABLE + '` WHERE id = :sid', + { replacements: { sid: subTypeId } } + ); + await sequelize.query( + 'UPDATE `' + SUB_TYPE_TABLE + '` SET sort_order = sort_order - 1 ' + + 'WHERE type = :type AND warehouse_id IS NULL AND sort_order > :sort', + { replacements: { type: 'order', sort: SUB_TYPE_SORT } } + ); + }, +};