WMS_MAIN/app/service/systems/order_b2b.js
liufumingren 29b39a7add fix(order): 二次转 B2B 恢复软删除明细行并重置作业字段
- 场景:转 B2B → 取消(明细软删除)→ 再转 B2B。原 findOrCreate 命中
  软删除行后直接返回,明细行保持 deleted_at 非空(B2B 明细查询不到),
  二次转后订单是 B2B 但无有效作业明细
- 修复:convertOrdersToB2b 明细写入改为 findOne(paranoid:false) + 显式分支——
  存在历史行(含软删)时恢复同一行并重置作业字段(deleted_at=null、
  total_box_count=0、pickup_plate_number=null、prep_remark=null、
  prep_duration_seconds=0、is_picked_up=N、picked_up_at=null、is_print=N、
  更新仓库/货主/发货单号快照,update 带 paranoid:false);不存在才 create
- 验证:临时集成测试转→取消→再转 1/1 PASS(二次转成功、恢复同一行、
  deleted_at 清空、作业字段重置、订单 is_b2b=Y,测后还原);ESLint 0 error
2026-10-09 00:39:03 +08:00

430 lines
15 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 订单业务服务。
*
* 负责订单转 B2B(wms_order_delivery.is_b2b 置 Y + wms_order_b2b 作业明细落表)。
*/
class OrderB2bService extends Service {
/**
* 将待处理订单批量转为 B2B 订单。
*
* 仅限待处理表(current 分表)中未打印、未锁定、未拦截的订单;
* 不符合条件的订单跳过(计入 skipped),不报错。事务内完成
* 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 }
*/
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 = [];
let notFoundOrderIds = [];
try {
const lockRows = await orderModel.findAll({
attributes: [
'id', 'delivery_order_code', 'store_id', '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.resolveConvertSkipReason(row);
if (skipReason) {
skippedReasons.push({
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || '').trim(),
reason: skipReason,
});
continue;
}
convertedRows.push(row);
}
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_order_id 唯一):
// 首次转换创建新行;二次转换(存在历史软删除行)恢复同一行并重置作业字段
const b2bModel = ctx.model.OrderB2b;
for (const row of convertedRows) {
const orderId = Number(row.id);
const baseFields = {
warehouse_id: normalizedWarehouseId,
store_id: Number(row.store_id || 0) > 0 ? Number(row.store_id) : null,
delivery_order_code: String(row.delivery_order_code || '').trim(),
updated_at: now,
};
const existing = await b2bModel.findOne({
where: { order_id: orderId },
paranoid: false,
transaction,
});
if (existing) {
// 恢复历史行并重置作业字段(取消 B2B 后的旧作业数据不再有效)
await existing.update({
deleted_at: null,
total_box_count: 0,
pickup_plate_number: null,
prep_remark: null,
prep_duration_seconds: 0,
is_picked_up: 'N',
picked_up_at: null,
is_print: 'N',
...baseFields,
}, { transaction, paranoid: false });
} else {
await b2bModel.create({
order_id: orderId,
...baseFields,
created_at: now,
}, { transaction });
}
}
}
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(),
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.convertOrdersToB2b] 写入操作日志失败,不影响业务, orderId=${row.id}, 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,
};
}
/**
* 判断订单是否满足转 B2B 条件,返回跳过原因;可转换时返回空串。
*
* 条件:待处理(step != 0)、未打印(print_status != fin)、
* 未锁定(lock_status = none)、未拦截(intercept_status = none)、未转 B2B(is_b2b != Y)。
*
* @param {Object} row 订单行。
* @return {string} 跳过原因,可转换返回空字符串。
*/
resolveConvertSkipReason(row = {}) {
if (Number(row && row.step || 0) === 0) {
return '订单待审核,不允许转B2B';
}
if (String(row && row.print_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 且未打印、未锁定、未拦截、
* B2B 面单未打印(wms_order_b2b.is_print=N)的订单;不符合条件的订单跳过,
* 不报错。事务内完成 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', 'store_id', '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));
// B2B 作业明细打印状态(is_print):已打印 B2B 面单的订单不允许取消
const b2bRows = await ctx.model.OrderB2b.findAll({
where: {
order_id: { [Op.in]: normalizedOrderIds },
deleted_at: null,
},
attributes: [ 'order_id', 'is_print' ],
raw: true,
transaction,
});
const b2bPrintMap = new Map((Array.isArray(b2bRows) ? b2bRows : [])
.map(row => [ Number(row && row.order_id || 0), String(row && row.is_print || 'N').trim() ]));
for (const orderId of normalizedOrderIds) {
const row = rowMap.get(orderId);
if (!row) {
continue;
}
const skipReason = this.resolveCancelSkipReason(row, b2bPrintMap.get(orderId));
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 作业明细软删除(保留历史)
await ctx.model.OrderB2b.update(
{ deleted_at: now, updated_at: now },
{
where: {
order_id: { [Op.in]: canceledOrderIds },
deleted_at: null,
},
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(),
},
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)、未打印(print_status != fin)、
* 未锁定(lock_status = none)、未拦截(intercept_status = none)、
* B2B 面单未打印(is_print != Y)。
*
* @param {Object} row 订单行。
* @param {string} b2bIsPrint B2B 作业明细打印状态(无明细行时为空串,视为未打印)。
* @return {string} 跳过原因,可取消返回空字符串。
*/
resolveCancelSkipReason(row = {}, b2bIsPrint = '') {
if (Number(row && row.step || 0) === 0) {
return '订单待审核,不允许取消B2B';
}
if (String(row && row.is_b2b || '').trim() !== 'Y') {
return '订单不是B2B订单';
}
if (String(row && row.print_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(b2bIsPrint || '').trim() === 'Y') {
return 'B2B面单已打印,不允许取消B2B';
}
return '';
}
}
module.exports = OrderB2bService;