WMS_MAIN/app/service/systems/order_b2b.js
liufumingren 0a6e82e00a feat(order): B2B 订单作业链路(列表/转换/取消/波次排除/作业明细表重构)
- 新增 order.pendingOrder2b.list / order.deliveryOrder2b.list:复用待处理与配送列表条件,
  强制 is_b2b='Y'(fixedWhere 以 AND 追加,请求 where 无法覆盖),并带出 wms_order_b2b
  作业明细字段(total_box_count/pickup_plate_number/prep_remark/prep_duration_seconds/
  prep_at/is_picked_up/picked_up_at/created_at),无明细行时输出空值占位
- B2B 列表 where 支持按作业明细字段筛选:先按 warehouse_id + order_id 查副表取 order_id,
  再以 id IN (...) 回填;该筛选仅这两个接口开放,不影响普通订单列表
- 其余订单列表(order/reviewOrder/pendingOrder/outboundOrder/expectionOrder/entrustOrder/
  deliveryOrder/deliveryExpectionOrder/archiveOrder 及 waveStrategyFallbackOrderList)
  统一追加 (is_b2b IS NULL OR is_b2b = 'N'),B2B 订单不再混入普通列表
- order.convertToB2b 收紧准入:status!=cancel、step in [1,2,3]、未拣货、未复核、未锁定、
  未拦截、未 B2B(打印状态不限制);已在波次中的订单转换后在同一事务内从波次摘除
  (含库内抓取订单),波次存在进行中拣货任务则跳过
- order.cancelB2b 放开打印限制,作业明细由软删除改为物理删除
- 波次抓取全链路排除 B2B:补上自动加团 appendOrderToWave / countCandidateGroupOrders
  两处遗漏;抽出 detachOrdersFromWavesInTransaction 供 batchRemoveOrders 与转 B2B 复用
- wms_order_delivery 分表新增 is_b2b 列表索引(current/dispatch,等值列前置 + 排序列),
  由订单工厂结构漂移同步自动补建
- 迁移 20261115180000-refactor-wms-order-b2b:新增 prep_at;移除 is_print/updated_at/
  deleted_at/delivery_order_code/store_id;唯一键改 uk_warehouse_order(warehouse_id, order_id);
  迁移前清理历史软删除行与重复行(开发库与生产库均已执行)
- operation_log 兜底用 changeSummary 写入 message,修复转/取消 B2B 日志操作说明为空
- 同步 methods/system.json 与变更记录 0.3.351~0.3.360

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-17 01:30:08 +08:00

526 lines
20 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';
const Service = require('egg').Service;
/** 订单转 B2B 操作码 */
const ORDER_B2B_CONVERT_OPERATION_CODE = 'ORDER_B2B_CONVERT';
/** 取消 B2B(流转回正常订单)操作码 */
const ORDER_B2B_CANCEL_OPERATION_CODE = 'ORDER_B2B_CANCEL';
/** 单次转换订单数上限 */
const ORDER_B2B_CONVERT_BATCH_LIMIT = 200;
/**
* 允许转 B2B 的订单步骤白名单。
*
* 仅待处理阶段(1 已审核 / 2 处理中 / 3 驳回异常)可转;4 配送中(含已提交出库)、
* 5 已完成、9 已关闭等已离开待处理阶段的订单一律拒绝,避免误转已配送/已关闭订单。
*/
const ORDER_B2B_CONVERT_ALLOWED_STEPS = new Set([ 1, 2, 3 ]);
/** 非白名单步骤的拒绝文案 */
const ORDER_B2B_CONVERT_STEP_SKIP_REASONS = Object.freeze({
0: '订单待审核,不允许转B2B',
4: '订单已提交出库,不允许转B2B',
5: '订单已完成,不允许转B2B',
9: '订单已关闭,不允许转B2B',
});
/**
* B2B 订单业务服务。
*
* 负责订单转 B2B(wms_order_delivery.is_b2b 置 Y + wms_order_b2b 作业明细落表)。
*/
class OrderB2bService extends Service {
/**
* 将待处理订单批量转为 B2B 订单。
*
* 仅限待处理表(current 分表)中处于待处理阶段(step in [1,2,3])、未取消、
* 未拣货、未复核、未锁定、未拦截的订单(打印状态不限制);不符合条件的订单跳过(计入 skipped),不报错。
* 已在波次中的订单(含库内抓取进波次的订单)转换成功后会在同一事务内从波次摘除
* (清空波次字段、重排 wave_index、回写波次统计);若波次存在进行中的拣货任务则跳过转换。
* 事务内完成 is_b2b 置 Y 与 wms_order_b2b 明细写入;操作日志在事务提交后写入。
*
* @param {Object} params 转换参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { converted_order_ids, converted_count, skipped_order_ids,
* skipped_count, skipped_reasons, not_found_order_ids, removed_from_wave_order_ids,
* affected_wave_ids, emptied_wave_ids, active_pick_task_wave_ids }
*/
async convertOrdersToB2b(params = {}) {
const { ctx, app } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const rawIds = params && params.orderIds;
const normalizedOrderIds = [ ...new Set(
(Array.isArray(rawIds) ? rawIds : [ rawIds ])
.map(item => Number(item))
.filter(item => Number.isInteger(item) && item > 0)
) ];
if (normalizedOrderIds.length === 0) {
throw new Error('订单ID不能为空');
}
if (normalizedOrderIds.length > ORDER_B2B_CONVERT_BATCH_LIMIT) {
throw new Error(`单次最多转换 ${ORDER_B2B_CONVERT_BATCH_LIMIT} 个订单`);
}
const operator = params && params.operator && typeof params.operator === 'object'
? params.operator
: null;
const { Op } = app.Sequelize;
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(normalizedWarehouseId);
const transaction = await ctx.model.transaction();
const convertedRows = [];
const skippedReasons = [];
const waveRemovalLogItems = [];
let waveDetachResult = null;
let notFoundOrderIds = [];
let notConvertedWaveIds = [];
try {
const lockRows = await orderModel.findAll({
attributes: [
'id', 'delivery_order_code', 'step', 'status',
'pick_status', 'recheck_status',
'print_status', 'lock_status', 'intercept_status', 'is_b2b',
'wave_id', 'wave_no',
],
where: {
id: { [Op.in]: normalizedOrderIds },
warehouse_id: normalizedWarehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const rowMap = new Map((Array.isArray(lockRows) ? lockRows : []).map(row => [ Number(row && row.id || 0), row ]));
notFoundOrderIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId));
for (const orderId of normalizedOrderIds) {
const row = rowMap.get(orderId);
if (!row) {
continue;
}
const skipReason = this.resolveConvertSkipReason(row);
if (skipReason) {
skippedReasons.push({
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || '').trim(),
reason: skipReason,
});
continue;
}
convertedRows.push(row);
}
// 已在波次中的订单:波次存在进行中的拣货任务时无法安全摘除,跳过转换
const waveBoundRows = convertedRows.filter(row => Number(row && row.wave_id || 0) > 0);
if (waveBoundRows.length > 0) {
const waveIds = [ ...new Set(waveBoundRows.map(row => Number(row.wave_id))) ];
const activeWaveRows = await ctx.model.query(`
SELECT DISTINCT ptw.wave_id
FROM wms_wave_pick_task_wave ptw
INNER JOIN wms_wave_pick_task pt ON pt.id = ptw.task_id
WHERE ptw.wave_id IN (:waveIds)
AND pt.status IN (0, 1)
`, {
replacements: { waveIds },
type: ctx.model.QueryTypes.SELECT,
transaction,
});
const activeWaveIdSet = new Set((Array.isArray(activeWaveRows) ? activeWaveRows : [])
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0));
if (activeWaveIdSet.size > 0) {
notConvertedWaveIds = [ ...activeWaveIdSet ].sort((a, b) => a - b);
const retainedRows = [];
for (const row of convertedRows) {
const waveId = Number(row && row.wave_id || 0);
if (waveId > 0 && activeWaveIdSet.has(waveId)) {
skippedReasons.push({
order_id: Number(row.id),
delivery_order_code: String(row.delivery_order_code || '').trim(),
reason: '订单所在波次存在进行中的拣货任务,不允许转B2B',
});
continue;
}
retainedRows.push(row);
}
convertedRows.length = 0;
convertedRows.push(...retainedRows);
}
}
if (convertedRows.length > 0) {
const convertedOrderIds = convertedRows.map(row => Number(row.id));
const now = new Date();
await orderModel.update(
{ is_b2b: 'Y', updated_at: now },
{
where: {
id: { [Op.in]: convertedOrderIds },
warehouse_id: normalizedWarehouseId,
},
transaction,
}
);
// 写入 B2B 作业明细(uk_warehouse_order 唯一):
// 正常流程为创建新行;并发/重复转换命中同一行时重置作业字段(取消 B2B 为物理删除,无历史行恢复)
const b2bModel = ctx.model.OrderB2b;
for (const row of convertedRows) {
const orderId = Number(row.id);
const baseFields = {
warehouse_id: normalizedWarehouseId,
order_id: orderId,
};
const existing = await b2bModel.findOne({
where: {
warehouse_id: normalizedWarehouseId,
order_id: orderId,
},
transaction,
});
if (existing) {
await existing.update({
total_box_count: 0,
pickup_plate_number: null,
prep_remark: null,
prep_duration_seconds: 0,
prep_at: null,
is_picked_up: 'N',
picked_up_at: null,
...baseFields,
}, { transaction });
} else {
await b2bModel.create({
...baseFields,
created_at: now,
}, { transaction });
}
}
// 已在波次中的订单(含库内抓取进波次的订单):转 B2B 后必须从波次摘除,
// 清空波次字段、重排 wave_index、回写波次统计(空波次置 wave_status=-1)
const waveBoundConvertedRows = convertedRows.filter(row => Number(row && row.wave_id || 0) > 0);
if (waveBoundConvertedRows.length > 0) {
waveDetachResult = await ctx.service.systemMethods.order.wave.detachOrdersFromWavesInTransaction({
warehouseId: normalizedWarehouseId,
orderIds: waveBoundConvertedRows.map(row => Number(row.id)),
orderModel,
transaction,
});
for (const orderId of waveDetachResult.removed_order_ids) {
waveRemovalLogItems.push({
orderId,
waveNo: String(waveDetachResult.wave_no_map.get(orderId) || '').trim(),
});
}
}
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
// 操作日志在事务提交后写入,失败不影响主流程
for (const row of convertedRows) {
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: Number(row.id),
operationCode: ORDER_B2B_CONVERT_OPERATION_CODE,
operationAction: 'UPDATE',
changeSummary: '订单转为B2B订单',
operator,
extras: {
warehouseId: normalizedWarehouseId,
orderId: Number(row.id),
orderNo: String(row.delivery_order_code || '').trim(),
message: '订单转为B2B订单',
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.convertOrdersToB2b] 写入操作日志失败,不影响业务, orderId=${row.id}, error=${error.message}`);
}
}
// 波次摘除日志在事务提交后写入,失败不影响主流程
for (const item of waveRemovalLogItems) {
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: Number(item.orderId),
operationCode: 'ORDER_WAVE_REMOVE',
operationAction: 'UPDATE',
changeSummary: `订单从波次 ${item.waveNo || '未知波次'} 中移除(转B2B)`,
operator,
extras: {
warehouseId: normalizedWarehouseId,
orderId: Number(item.orderId),
waveNo: item.waveNo,
reason: 'convertToB2b',
message: `订单从波次 ${item.waveNo || '未知波次'} 中移除(转B2B)`,
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.convertOrdersToB2b] 写入波次移除日志失败,不影响业务, orderId=${item.orderId}, error=${error.message}`);
}
}
const skippedOrderIds = [ ...new Set(skippedReasons.map(item => item.order_id)) ];
return {
converted_order_ids: [ ...new Set(convertedRows.map(row => Number(row.id))) ],
converted_count: convertedRows.length,
skipped_order_ids: skippedOrderIds,
skipped_count: skippedOrderIds.length,
skipped_reasons: skippedReasons,
not_found_order_ids: notFoundOrderIds,
removed_from_wave_order_ids: waveDetachResult ? waveDetachResult.removed_order_ids : [],
affected_wave_ids: waveDetachResult ? waveDetachResult.affected_wave_ids : [],
emptied_wave_ids: waveDetachResult ? waveDetachResult.emptied_wave_ids : [],
active_pick_task_wave_ids: notConvertedWaveIds,
};
}
/**
* 判断订单是否满足转 B2B 条件,返回跳过原因;可转换时返回空串。
*
* 条件:非已取消(status != cancel)、处于待处理阶段(step in [1,2,3])、
* 未拣货(pick_status != fin)、未复核(recheck_status != fin)、
* 未锁定(lock_status = none)、未拦截(intercept_status = none)、未转 B2B(is_b2b != Y)。
* 打印状态不参与校验:已打印(print_status = fin)的订单同样允许转 B2B。
*
* @param {Object} row 订单行。
* @return {string} 跳过原因,可转换返回空字符串。
*/
resolveConvertSkipReason(row = {}) {
// 已取消订单即使仍停留在待处理步骤也不允许转 B2B
if (String(row && row.status || '').trim() === 'cancel') {
return '订单已取消,不允许转B2B';
}
// 仅待处理阶段可转:4 配送中/已提交出库、5 已完成、9 已关闭一律拒绝
const step = Number(row && row.step || 0);
if (!ORDER_B2B_CONVERT_ALLOWED_STEPS.has(step)) {
return ORDER_B2B_CONVERT_STEP_SKIP_REASONS[step] || `订单当前步骤(${step})不允许转B2B`;
}
// 已进入作业流程的订单不允许转 B2B:拣货/复核完成后订单实物已分拣、单据已核对
if (String(row && row.pick_status || '').trim() === 'fin') {
return '订单已拣货,不允许转B2B';
}
if (String(row && row.recheck_status || '').trim() === 'fin') {
return '订单已复核,不允许转B2B';
}
if (String(row && row.lock_status || 'none').trim() !== 'none') {
return '订单已锁定,不允许转B2B';
}
if (String(row && row.intercept_status || 'none').trim() !== 'none') {
return '订单已拦截,不允许转B2B';
}
if (String(row && row.is_b2b || '').trim() === 'Y') {
return '订单已是B2B订单';
}
return '';
}
/**
* 取消 B2B 出库:将 B2B 订单流转回正常订单。
*
* 仅限待处理表(current 分表)中 is_b2b=Y 且未锁定、未拦截的订单(打印状态不限制);
* 不符合条件的订单跳过,不报错。事务内完成 is_b2b 置回 N 与 B2B 作业明细物理删除;
* 操作日志在事务提交后写入。
*
* @param {Object} params 取消参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { canceled_order_ids, canceled_count, skipped_order_ids,
* skipped_count, skipped_reasons, not_found_order_ids }
*/
async cancelOrdersB2b(params = {}) {
const { ctx, app } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const rawIds = params && params.orderIds;
const normalizedOrderIds = [ ...new Set(
(Array.isArray(rawIds) ? rawIds : [ rawIds ])
.map(item => Number(item))
.filter(item => Number.isInteger(item) && item > 0)
) ];
if (normalizedOrderIds.length === 0) {
throw new Error('订单ID不能为空');
}
if (normalizedOrderIds.length > ORDER_B2B_CONVERT_BATCH_LIMIT) {
throw new Error(`单次最多取消 ${ORDER_B2B_CONVERT_BATCH_LIMIT} 个订单`);
}
const operator = params && params.operator && typeof params.operator === 'object'
? params.operator
: null;
const { Op } = app.Sequelize;
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(normalizedWarehouseId);
const transaction = await ctx.model.transaction();
const canceledRows = [];
const skippedReasons = [];
let notFoundOrderIds = [];
try {
const lockRows = await orderModel.findAll({
attributes: [
'id', 'delivery_order_code', 'step',
'print_status', 'lock_status', 'intercept_status', 'is_b2b',
],
where: {
id: { [Op.in]: normalizedOrderIds },
warehouse_id: normalizedWarehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const rowMap = new Map((Array.isArray(lockRows) ? lockRows : []).map(row => [ Number(row && row.id || 0), row ]));
notFoundOrderIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId));
for (const orderId of normalizedOrderIds) {
const row = rowMap.get(orderId);
if (!row) {
continue;
}
const skipReason = this.resolveCancelSkipReason(row);
if (skipReason) {
skippedReasons.push({
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || '').trim(),
reason: skipReason,
});
continue;
}
canceledRows.push(row);
}
if (canceledRows.length > 0) {
const canceledOrderIds = canceledRows.map(row => Number(row.id));
const now = new Date();
await orderModel.update(
{ is_b2b: 'N', updated_at: now },
{
where: {
id: { [Op.in]: canceledOrderIds },
warehouse_id: normalizedWarehouseId,
},
transaction,
}
);
// B2B 作业明细物理删除(不保留历史),关联条件固定为 warehouse_id + order_id
await ctx.model.OrderB2b.destroy({
where: {
warehouse_id: normalizedWarehouseId,
order_id: { [Op.in]: canceledOrderIds },
},
transaction,
});
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
// 操作日志在事务提交后写入,失败不影响主流程
for (const row of canceledRows) {
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: Number(row.id),
operationCode: ORDER_B2B_CANCEL_OPERATION_CODE,
operationAction: 'UPDATE',
changeSummary: '取消B2B出库,订单流转回正常订单',
operator,
extras: {
warehouseId: normalizedWarehouseId,
orderId: Number(row.id),
orderNo: String(row.delivery_order_code || '').trim(),
message: '取消B2B出库,订单流转回正常订单',
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.cancelOrdersB2b] 写入操作日志失败,不影响业务, orderId=${row.id}, error=${error.message}`);
}
}
const skippedOrderIds = [ ...new Set(skippedReasons.map(item => item.order_id)) ];
return {
canceled_order_ids: [ ...new Set(canceledRows.map(row => Number(row.id))) ],
canceled_count: canceledRows.length,
skipped_order_ids: skippedOrderIds,
skipped_count: skippedOrderIds.length,
skipped_reasons: skippedReasons,
not_found_order_ids: notFoundOrderIds,
};
}
/**
* 判断 B2B 订单是否满足取消条件,返回跳过原因;可取消时返回空串。
*
* 条件:待处理(step != 0)、是 B2B(is_b2b = Y)、未锁定(lock_status = none)、
* 未拦截(intercept_status = none)。打印状态不参与校验。
*
* @param {Object} row 订单行。
* @return {string} 跳过原因,可取消返回空字符串。
*/
resolveCancelSkipReason(row = {}) {
if (Number(row && row.step || 0) === 0) {
return '订单待审核,不允许取消B2B';
}
if (String(row && row.is_b2b || '').trim() !== 'Y') {
return '订单不是B2B订单';
}
if (String(row && row.lock_status || 'none').trim() !== 'none') {
return '订单已锁定,不允许取消B2B';
}
if (String(row && row.intercept_status || 'none').trim() !== 'none') {
return '订单已拦截,不允许取消B2B';
}
return '';
}
}
module.exports = OrderB2bService;