liufumingren 59bc65b443 feat(order): B2B 加急优先、分箱明细与取货储位,作业链路收口
- 列表:B2B 待处理/配送列表固定加急优先排序(wms_order_b2b.is_urgent='Y' 置顶),
  作业明细筛选口径不变
- 备货/提货:新增 setB2bUrgent/cancelB2bUrgent、startB2bPrep/cancelB2bPrep/finishB2bPrep、
  setB2bPickupPlate、pickupB2b、updateB2bOrderImages;提货即出库完成
  (写 outbound_status=fin / step=4 / delivery_time 并迁移到配送表),车牌与提货照片
  随单落库
- 分箱:新增 wms_order_b2b_items 与 order.updateB2bPackingItems、order.getB2bPackingSnapshot;
  快照按商品行返回 wms_picking 取货储位(items[].pick_locations / pick_location_count),
  列表不再携带储位明细
- 齐套校验:仓库 subject_config 新增 b2b_packing_quantity_check,备货完成时逐商品校验
  分箱数量合计等于 plan_qty 且总箱数与箱号数一致
- 拦截:B2B 订单不参与波次抓取、快捷复核批量发货、反审回待审核与克隆,命中即整批驳回
- 明细:order.pendingOrder.detail / order.deliveryOrder.detail 为 B2B 订单附加副表作业明细
  b2b、备货照片 images 与提货照片 pickup_images
- 迁移:wms_order_b2b 新增 is_urgent 与备货作业字段,新建 wms_order_b2b_items
- 文档:methods/system.json 与 methods/changes/system.json 同步至 0.3.375

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

2930 lines
110 KiB
JavaScript
Raw Permalink 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;
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
const { FILE_BUSINESS_TYPE } = require('../../lib/file_business_types');
/** 订单转 B2B 操作码 */
const ORDER_B2B_CONVERT_OPERATION_CODE = 'ORDER_B2B_CONVERT';
/** 取消 B2B(流转回正常订单)操作码 */
const ORDER_B2B_CANCEL_OPERATION_CODE = 'ORDER_B2B_CANCEL';
/** 设置 B2B 加急操作码 */
const ORDER_B2B_SET_URGENT_OPERATION_CODE = 'ORDER_B2B_SET_URGENT';
/** 备货开始 / 取消备货 / 备货完成操作码 */
const ORDER_B2B_PREP_START_OPERATION_CODE = 'ORDER_B2B_PREP_START';
const ORDER_B2B_PREP_CANCEL_OPERATION_CODE = 'ORDER_B2B_PREP_CANCEL';
const ORDER_B2B_PREP_FINISH_OPERATION_CODE = 'ORDER_B2B_PREP_FINISH';
const ORDER_B2B_PACKING_ITEMS_OPERATION_CODE = 'ORDER_B2B_PACKING_ITEMS';
/** B2B 提货操作码 */
const ORDER_B2B_PICKUP_OPERATION_CODE = 'ORDER_B2B_PICKUP';
/** B2B 提货车牌录入/修改操作码 */
const ORDER_B2B_PICKUP_PLATE_OPERATION_CODE = 'ORDER_B2B_PICKUP_PLATE';
/** B2B 订单图片更新操作码 */
const ORDER_B2B_IMAGES_OPERATION_CODE = 'ORDER_B2B_IMAGES';
/** 单次转换订单数上限 */
const ORDER_B2B_CONVERT_BATCH_LIMIT = 200;
/** 备货状态 */
const B2B_PREP_STATUS = Object.freeze({
NONE: 'none',
PADDING: 'padding',
FIN: 'fin',
});
/** 备货作业校验错误码(方法层据此返回 failure 400) */
const B2B_PREP_ERROR_CODE = Object.freeze({
INPUT_INVALID: 'B2B_PREP_INPUT_INVALID',
OPERATOR_REQUIRED: 'B2B_PREP_OPERATOR_REQUIRED',
NOT_B2B: 'B2B_PREP_NOT_B2B',
OPERATOR_MISMATCH: 'B2B_PREP_OPERATOR_MISMATCH',
STATUS_INVALID: 'B2B_PREP_STATUS_INVALID',
NOT_STARTED: 'B2B_PREP_NOT_STARTED',
NOT_FOUND: 'B2B_PREP_ORDER_NOT_FOUND',
NOT_READY: 'B2B_PREP_NOT_READY',
PACKING_INCOMPLETE: 'B2B_PREP_PACKING_INCOMPLETE',
});
/** B2B 分箱明细接口校验错误码。 */
const B2B_PACKING_ERROR_CODE = Object.freeze({
INPUT_INVALID: 'B2B_PACKING_INPUT_INVALID',
NOT_B2B: 'B2B_PACKING_NOT_B2B',
NOT_FOUND: 'B2B_PACKING_ORDER_NOT_FOUND',
STATUS_INVALID: 'B2B_PACKING_STATUS_INVALID',
});
/** 提货校验错误码(方法层据此返回 failure 400) */
const B2B_PICKUP_ERROR_CODE = Object.freeze({
INPUT_INVALID: 'B2B_PICKUP_INPUT_INVALID',
NOT_B2B: 'B2B_PICKUP_NOT_B2B',
STATUS_INVALID: 'B2B_PICKUP_STATUS_INVALID',
NOT_FOUND: 'B2B_PICKUP_ORDER_NOT_FOUND',
});
/** 提货车牌校验错误码(方法层据此返回 failure 400) */
const B2B_PLATE_ERROR_CODE = Object.freeze({
INPUT_INVALID: 'B2B_PLATE_INPUT_INVALID',
NOT_B2B: 'B2B_PLATE_NOT_B2B',
STATUS_INVALID: 'B2B_PLATE_STATUS_INVALID',
NOT_FOUND: 'B2B_PLATE_ORDER_NOT_FOUND',
});
/** 提货车牌最大长度(与 wms_order_b2b.pickup_plate_number 字段长度一致) */
const B2B_PICKUP_PLATE_MAX_LENGTH = 20;
/**
* 提货车牌基础格式:首字符为汉字省份简称或字母(军/使/领/港澳等特殊牌照),
* 其余为汉字、字母或数字,整体 5~10 位;仅拦截明显无效输入(如纯数字、过短、超长)。
*/
const B2B_PICKUP_PLATE_PATTERN = /^[\u4e00-\u9fa5A-Z][\u4e00-\u9fa5A-Z0-9]{4,9}$/;
/** 订单图片校验错误码(方法层据此返回 failure 400) */
const B2B_IMAGE_ERROR_CODE = Object.freeze({
INPUT_INVALID: 'B2B_IMAGE_INPUT_INVALID',
NOT_B2B: 'B2B_IMAGE_NOT_B2B',
STATUS_INVALID: 'B2B_IMAGE_STATUS_INVALID',
NOT_FOUND: 'B2B_IMAGE_ORDER_NOT_FOUND',
FILE_INVALID: 'B2B_IMAGE_FILE_INVALID',
});
/** 单订单图片数量上限 */
const B2B_ORDER_IMAGE_MAX = 20;
/** B2B 订单图片业务类型:备货留证照片 */
const B2B_PREP_IMAGE_BUSINESS_TYPE = FILE_BUSINESS_TYPE.B2B_ORDER;
/** B2B 订单图片业务类型:提货留证照片(与备货照片分开存放) */
const B2B_PICKUP_IMAGE_BUSINESS_TYPE = FILE_BUSINESS_TYPE.B2B_PICKUP;
/** 提货即出库完成:主表写入的出库状态与步骤(与 order.markOutboundOrder 口径一致) */
const B2B_OUTBOUND_STATUS_FIN = 'fin';
const B2B_OUTBOUND_STEP = 4;
/**
* 构造带错误码与明细的 B2B 作业错误(备货/提货/图片等共用)。
* @param {string} code 错误码。
* @param {string} message 错误信息。
* @param {Object} [data={}] 附加数据。
* @return {Error} 错误对象。
*/
function buildB2bError(code, message, data = {}) {
const error = new Error(message);
error.code = code;
error.data = data;
return error;
}
/**
* 构造带错误码与明细的备货作业错误。
* @param {string} code 错误码。
* @param {string} message 错误信息。
* @param {Object} [data={}] 附加数据。
* @return {Error} 错误对象。
*/
function buildPrepError(code, message, data = {}) {
return buildB2bError(code, message, data);
}
/**
* 归一化操作人工号ID(工号,非用户主键)。
* @param {Object|null} operator 操作人 { id, name }。
* @param {string} actionText 动作文案(用于报错)。
* @return {{ id: number, name: string|null }} 归一化后的操作人。
*/
function resolvePrepOperator(operator, actionText) {
const rawId = operator && operator.id;
const operatorId = Number(rawId);
if (!Number.isInteger(operatorId) || operatorId <= 0) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.OPERATOR_REQUIRED,
`未识别到操作人工号,无法${actionText}`
);
}
return {
id: operatorId,
name: String(operator && operator.name || '').trim() || null,
};
}
/**
* 归一化"是否加急"入参,兼容 Y/N、true/false、1/0、是/否。
* @param {*} value 原始取值。
* @param {string} [defaultValue='Y'] 缺省值。
* @return {string} 'Y' 或 'N'。
*/
function normalizeUrgentFlag(value, defaultValue = 'Y') {
if (value === undefined || value === null || value === '') {
return defaultValue;
}
if (value === true || value === 1) {
return 'Y';
}
if (value === false || value === 0) {
return 'N';
}
const normalized = String(value).trim().toUpperCase();
if ([ 'Y', 'YES', 'TRUE', '1', '是' ].includes(normalized)) {
return 'Y';
}
if ([ 'N', 'NO', 'FALSE', '0', '否' ].includes(normalized)) {
return 'N';
}
throw new Error('is_urgent 参数不合法,仅支持 Y/N(或 true/false、1/0)');
}
/**
* 允许转 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',
'is_urgency', '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,
};
// 加急标记以订单表 is_urgency 作为初始值(Y 才视为加急,其余按普通)
const urgentFlag = String(row.is_urgency || '').trim().toUpperCase() === 'Y' ? 'Y' : 'N';
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_urgent: urgentFlag,
is_picked_up: 'N',
picked_up_at: null,
...baseFields,
}, { transaction });
} else {
await b2bModel.create({
...baseFields,
is_urgent: urgentFlag,
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 '';
}
/**
* 批量设置 B2B 订单是否加急。
*
* 仅对 B2B 订单(is_b2b='Y')生效:非 B2B 订单跳过并返回原因。
* 订单先在 current 分表查找,未命中的再到 dispatch 分表兜底(配送域 B2B 订单);
* 两表都查不到计入 not_found。事务内按 warehouse_id + order_id 更新
* wms_order_b2b.is_urgent(作业明细行缺失时补建),提交后写操作日志。
*
* @param {Object} params 设置参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组。
* @param {string|boolean|number} [params.isUrgent='Y'] 是否加急,兼容 Y/N、true/false、1/0。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { is_urgent, updated_order_ids, updated_count,
* skipped_order_ids, skipped_count, skipped_reasons, not_found_order_ids }
*/
async setOrdersB2bUrgent(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 isUrgent = normalizeUrgentFlag(params && params.isUrgent);
const operator = params && params.operator && typeof params.operator === 'object'
? params.operator
: null;
const { Op } = app.Sequelize;
const factory = ctx.model.OrderDeliveryFactory;
const currentModel = await factory.getCurrentModel(normalizedWarehouseId);
const ATTRIBUTES = [ 'id', 'delivery_order_code', 'step', 'status', 'is_b2b' ];
const transaction = await ctx.model.transaction();
const updatedRows = [];
const skippedReasons = [];
let notFoundOrderIds = [];
try {
const currentRows = await currentModel.findAll({
attributes: ATTRIBUTES,
where: {
id: { [Op.in]: normalizedOrderIds },
warehouse_id: normalizedWarehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const rowMap = new Map((Array.isArray(currentRows) ? currentRows : [])
.map(row => [ Number(row && row.id || 0), row ]));
// 未在待处理表命中的订单,兜底到配送域分表(配送域 B2B 订单)
const missingIds = normalizedOrderIds.filter(orderId => !rowMap.has(orderId));
if (missingIds.length > 0) {
const dispatchModel = await factory.getDispatchModel(normalizedWarehouseId);
const dispatchRows = await dispatchModel.findAll({
attributes: ATTRIBUTES,
where: {
id: { [Op.in]: missingIds },
warehouse_id: normalizedWarehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
for (const row of (Array.isArray(dispatchRows) ? dispatchRows : [])) {
rowMap.set(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.resolveSetUrgentSkipReason(row);
if (skipReason) {
skippedReasons.push({
order_id: orderId,
delivery_order_code: String(row.delivery_order_code || '').trim(),
reason: skipReason,
});
continue;
}
updatedRows.push(row);
}
if (updatedRows.length > 0) {
const now = new Date();
const b2bModel = ctx.model.OrderB2b;
for (const row of updatedRows) {
const orderId = Number(row.id);
const existing = await b2bModel.findOne({
where: {
warehouse_id: normalizedWarehouseId,
order_id: orderId,
},
transaction,
});
if (existing) {
await existing.update({ is_urgent: isUrgent }, { transaction });
} else {
// 兜底:B2B 订单缺少作业明细行时补建,其余作业字段取默认值
await b2bModel.create({
warehouse_id: normalizedWarehouseId,
order_id: orderId,
is_urgent: isUrgent,
created_at: now,
}, { transaction });
}
}
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
// 操作日志在事务提交后写入,失败不影响主流程
const changeSummary = isUrgent === 'Y' ? '设置B2B订单加急' : '取消B2B订单加急';
for (const row of updatedRows) {
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: Number(row.id),
operationCode: ORDER_B2B_SET_URGENT_OPERATION_CODE,
operationAction: 'UPDATE',
changeSummary,
operator,
extras: {
warehouseId: normalizedWarehouseId,
orderId: Number(row.id),
orderNo: String(row.delivery_order_code || '').trim(),
isUrgent,
message: changeSummary,
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.setOrdersB2bUrgent] 写入操作日志失败,不影响业务, orderId=${row.id}, error=${error.message}`);
}
}
const skippedOrderIds = [ ...new Set(skippedReasons.map(item => item.order_id)) ];
return {
is_urgent: isUrgent,
updated_order_ids: [ ...new Set(updatedRows.map(row => Number(row.id))) ],
updated_count: updatedRows.length,
skipped_order_ids: skippedOrderIds,
skipped_count: skippedOrderIds.length,
skipped_reasons: skippedReasons,
not_found_order_ids: notFoundOrderIds,
};
}
/**
* 判断订单是否允许设置/取消 B2B 加急,返回跳过原因;可设置时返回空串。
*
* 条件:是 B2B 订单(is_b2b = Y)、非已取消(status != cancel)。
* 待处理表与配送域分表口径一致,拣货/复核/打印/锁定/拦截不影响加急标记。
*
* @param {Object} row 订单行。
* @return {string} 跳过原因,可设置返回空字符串。
*/
resolveSetUrgentSkipReason(row = {}) {
if (String(row && row.is_b2b || '').trim() !== 'Y') {
return '订单不是B2B订单';
}
if (String(row && row.status || '').trim() === 'cancel') {
return '订单已取消,不允许设置加急';
}
return '';
}
/**
* 载入备货作业目标订单与对应作业明细行。
*
* 订单先在 current 分表加锁查询,未命中的兜底到 dispatch 分表;
* 作业明细按 warehouse_id + order_id 读取(同样加锁)。
*
* 同时返回 modelMap(订单ID → 该订单所在的物理模型),供提货时回写出库状态时
* 精确更新订单所在表(current 或 dispatch),避免只更新 current 导致配送域订单漏写。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number[]} params.orderIds 订单ID数组(单订单)。
* @param {Object} params.transaction 事务对象。
* @return {Promise<{ rowMap: Map, b2bMap: Map, modelMap: Map, sourceTypeMap: Map }>} 订单行、作业明细行与分表映射。
*/
async loadPrepTargets({ warehouseId, orderIds, transaction }) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const factory = ctx.model.OrderDeliveryFactory;
const ATTRIBUTES = [
'id', 'delivery_order_code', 'status', 'is_b2b',
'print_status', 'storage_status', 'intercept_status',
'outbound_status', 'step', 'delivery_time',
];
const rowMap = new Map();
const modelMap = new Map();
const sourceTypeMap = new Map();
const currentModel = await factory.getCurrentModel(warehouseId);
const currentRows = await currentModel.findAll({
attributes: ATTRIBUTES,
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
for (const row of (Array.isArray(currentRows) ? currentRows : [])) {
const orderId = Number(row && row.id || 0);
rowMap.set(orderId, row);
modelMap.set(orderId, currentModel);
sourceTypeMap.set(orderId, 'current');
}
const missingIds = orderIds.filter(orderId => !rowMap.has(orderId));
if (missingIds.length > 0) {
const dispatchModel = await factory.getDispatchModel(warehouseId);
const dispatchRows = await dispatchModel.findAll({
attributes: ATTRIBUTES,
where: {
id: { [Op.in]: missingIds },
warehouse_id: warehouseId,
},
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
for (const row of (Array.isArray(dispatchRows) ? dispatchRows : [])) {
const orderId = Number(row && row.id || 0);
rowMap.set(orderId, row);
modelMap.set(orderId, dispatchModel);
sourceTypeMap.set(orderId, 'dispatch');
}
}
const b2bRows = await ctx.model.OrderB2b.findAll({
where: {
warehouse_id: warehouseId,
order_id: { [Op.in]: orderIds },
},
attributes: [
'id', 'order_id', 'prep_status', 'prep_operator_id', 'prep_operator_name',
'prep_start_at', 'prep_at', 'prep_duration_seconds', 'is_picked_up', 'picked_up_at',
'pickup_plate_number', 'created_at',
],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const b2bMap = new Map((Array.isArray(b2bRows) ? b2bRows : [])
.map(row => [ Number(row && row.order_id || 0), row ]));
return { rowMap, b2bMap, modelMap, sourceTypeMap };
}
/**
* 读取订单所在分表的商品明细。
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {string} params.sourceType 分表类型。
* @param {Object} params.transaction 事务对象。
* @param {boolean} [params.lock=false] 是否加行锁。
* @return {Promise<Array<Object>>} 订单商品明细行。
*/
async loadB2bOrderItems({ warehouseId, orderId, sourceType, transaction, lock = false }) {
const { ctx } = this;
const factory = ctx.model && ctx.model.OrderItemsFactory;
if (!factory) {
throw new Error('订单商品明细模型不可用');
}
const model = sourceType === 'dispatch'
? await factory.getDispatchModel(warehouseId)
: await factory.getCurrentModel(warehouseId);
const options = {
where: { order_id: orderId },
attributes: [ 'id', 'order_id', 'item_id', 'item_code', 'item_name', 'plan_qty', 'stock_id', 'item_snapshot' ],
order: [[ 'id', 'ASC' ]],
raw: true,
transaction,
};
if (lock && transaction && transaction.LOCK) {
options.lock = transaction.LOCK.UPDATE;
}
return await model.findAll(options);
}
/**
* 查询订单的取货储位(数据源 wms_picking,订单储位分配结果)。
*
* 备货时按商品明细逐行告知去哪个库位取货;同一商品在同一储位的多条分配记录
* 合并为一条(数量相加),按库位名称升序输出。排除 status=cancel(已取消的分配)。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {Object} [params.transaction] 事务对象。
* @return {Promise<Map<number, Array<Object>>>} order_item_id → [{ space_id, space_name, quantity }]。
*/
async loadB2bPickLocationsByItem({ warehouseId, orderId, transaction }) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const result = new Map();
if (!ctx.model.Picking) {
return result;
}
const pickingRows = await ctx.model.Picking.findAll({
where: {
warehouse_id: warehouseId,
order_id: orderId,
status: { [Op.ne]: 'cancel' },
},
attributes: [ 'order_item_id', 'space_id', 'space_name', 'quantity' ],
raw: true,
transaction,
});
const itemSpaces = new Map();
for (const row of (Array.isArray(pickingRows) ? pickingRows : [])) {
const orderItemId = Number(row.order_item_id);
if (!Number.isInteger(orderItemId) || orderItemId <= 0) {
continue;
}
const spaceId = Number(row.space_id) || 0;
const spaceName = String(row.space_name || '').trim();
const spaceKey = spaceId > 0 ? `id:${spaceId}` : `name:${spaceName}`;
if (!itemSpaces.has(orderItemId)) {
itemSpaces.set(orderItemId, new Map());
}
const spaces = itemSpaces.get(orderItemId);
if (!spaces.has(spaceKey)) {
spaces.set(spaceKey, {
space_id: spaceId > 0 ? spaceId : null,
space_name: spaceName || null,
quantity: 0,
});
}
spaces.get(spaceKey).quantity += Number(row.quantity || 0);
}
for (const [ orderItemId, spaces ] of itemSpaces.entries()) {
result.set(orderItemId, [ ...spaces.values() ]
.sort((left, right) => String(left.space_name || '')
.localeCompare(String(right.space_name || ''))));
}
return result;
}
/**
* 查询仓库是否开启 B2B 分箱齐套校验。
* @param {number} warehouseId 仓库ID。
* @return {Promise<boolean>} 是否开启。
*/
async isB2bPackingQuantityCheckEnabled(warehouseId) {
const service = this.ctx.service && this.ctx.service.systems
&& this.ctx.service.systems.deliveryOrder;
if (!service || typeof service.getStoreSubjectConfig !== 'function') {
return false;
}
const config = await service.getStoreSubjectConfig(warehouseId);
return !!(config && config.b2b_packing_quantity_check === true);
}
/**
* 校验分箱数量逐订单商品齐套。
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {string} params.sourceType 分表类型。
* @param {number} params.totalBoxCount 总箱数。
* @param {Object} params.transaction 事务对象。
* @return {Promise<{ boxCount: number }>} 箱数。
*/
async assertB2bPackingQuantityComplete({ warehouseId, orderId, sourceType, totalBoxCount, transaction }) {
const { ctx } = this;
const orderItems = await this.loadB2bOrderItems({
warehouseId,
orderId,
sourceType,
transaction,
lock: true,
});
const packedItems = await ctx.model.OrderB2bItem.findAll({
where: { warehouse_id: warehouseId, order_id: orderId },
attributes: [ 'order_item_id', 'box_no', 'quantity' ],
order: [[ 'id', 'ASC' ]],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const packedByItemId = new Map();
const boxNumbers = new Set();
for (const packedItem of packedItems) {
const itemId = Number(packedItem.order_item_id);
const quantity = Number(packedItem.quantity);
packedByItemId.set(itemId, (packedByItemId.get(itemId) || 0) + quantity);
boxNumbers.add(String(packedItem.box_no));
}
const mismatches = [];
if (orderItems.length === 0) {
mismatches.push({
order_item_id: null,
item_code: '',
item_name: '订单商品明细不存在',
expected_quantity: null,
packed_quantity: [ ...packedByItemId.values() ].reduce((sum, quantity) => sum + quantity, 0),
});
}
const orderItemIds = new Set();
for (const item of orderItems) {
const itemId = Number(item.id);
const expectedQuantity = Number(item.plan_qty);
const packedQuantity = Number(packedByItemId.get(itemId) || 0);
orderItemIds.add(itemId);
if (!Number.isInteger(expectedQuantity) || expectedQuantity < 0 || packedQuantity !== expectedQuantity) {
mismatches.push({
order_item_id: itemId,
item_code: item.item_code || '',
item_name: item.item_name || '',
expected_quantity: Number.isInteger(expectedQuantity) ? expectedQuantity : null,
packed_quantity: packedQuantity,
});
}
}
for (const [ itemId, packedQuantity ] of packedByItemId) {
if (!orderItemIds.has(itemId)) {
mismatches.push({
order_item_id: itemId,
item_code: '',
item_name: '订单商品明细不存在',
expected_quantity: 0,
packed_quantity: packedQuantity,
});
}
}
const boxCount = boxNumbers.size;
if (mismatches.length > 0 || boxCount !== Number(totalBoxCount)) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.PACKING_INCOMPLETE,
mismatches.length > 0
? '分箱数量与订单商品应拣数量不一致,不能完成备货'
: `总箱数(${totalBoxCount})与分箱箱号数(${boxCount})不一致,不能完成备货`,
{
order_id: orderId,
item_mismatches: mismatches,
total_box_count: Number(totalBoxCount),
packed_box_count: boxCount,
}
);
}
return { boxCount };
}
/**
* 更新单个 B2B 订单的完整分箱明细(全量替换)。
* @param {Object} params 参数。
* @return {Promise<Object>} 更新结果。
*/
async updateB2bPackingItems(params = {}) {
const { ctx } = this;
const warehouseId = Number(params.warehouseId || 0);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const [ orderId ] = this.normalizeB2bOrderIds(params.orderIds, {
inputCode: B2B_PACKING_ERROR_CODE.INPUT_INVALID,
actionText: '更新分箱明细',
});
const inputItems = params.items;
if (!Array.isArray(inputItems) || inputItems.length > 10000) {
throw buildB2bError(B2B_PACKING_ERROR_CODE.INPUT_INVALID, 'items 必须是最多 10000 条的数组');
}
const normalizedItems = [];
const uniqueItemBoxKeys = new Set();
for (const item of inputItems) {
const orderItemId = Number(item && (item.order_item_id !== undefined ? item.order_item_id : item.orderItemId));
const boxNo = String(item && (item.box_no !== undefined ? item.box_no : item.boxNo) || '').trim();
const quantity = Number(item && item.quantity);
if (!Number.isSafeInteger(orderItemId) || orderItemId <= 0
|| !boxNo || boxNo.length > 50
|| !Number.isSafeInteger(quantity) || quantity <= 0) {
throw buildB2bError(
B2B_PACKING_ERROR_CODE.INPUT_INVALID,
'每条分箱明细必须包含有效 order_item_id、长度不超过 50 的箱号和正整数 quantity'
);
}
const key = `${orderItemId}\u0000${boxNo.toUpperCase()}`;
if (uniqueItemBoxKeys.has(key)) {
throw buildB2bError(B2B_PACKING_ERROR_CODE.INPUT_INVALID, '同一商品明细与箱号不能重复');
}
uniqueItemBoxKeys.add(key);
normalizedItems.push({ order_item_id: orderItemId, box_no: boxNo, quantity });
}
const transaction = await ctx.model.transaction();
let boxCount = 0;
try {
const { rowMap, b2bMap, sourceTypeMap } = await this.loadPrepTargets({
warehouseId,
orderIds: [ orderId ],
transaction,
});
this.assertPrepOrders({ orderIds: [ orderId ], rowMap, actionText: '更新分箱明细' });
const order = rowMap.get(orderId);
if (String(order.status || '').trim() === 'cancel') {
throw buildB2bError(B2B_PACKING_ERROR_CODE.STATUS_INVALID, '已取消订单不能更新分箱明细');
}
const b2bDetail = b2bMap.get(orderId);
if (!b2bDetail || String(b2bDetail.prep_status || '').trim() !== B2B_PREP_STATUS.PADDING) {
throw buildB2bError(B2B_PACKING_ERROR_CODE.STATUS_INVALID, '订单未处于备货中,不能更新分箱明细');
}
const orderItems = await this.loadB2bOrderItems({
warehouseId,
orderId,
sourceType: sourceTypeMap.get(orderId),
transaction,
lock: true,
});
const validItemIds = new Set(orderItems.map(item => Number(item.id)));
const invalidItemIds = [ ...new Set(normalizedItems
.map(item => item.order_item_id)
.filter(itemId => !validItemIds.has(itemId))) ];
if (invalidItemIds.length > 0) {
throw buildB2bError(
B2B_PACKING_ERROR_CODE.INPUT_INVALID,
'分箱明细包含不属于当前订单的商品行',
{ invalid_order_item_ids: invalidItemIds }
);
}
const packingModel = ctx.model.OrderB2bItem;
await packingModel.destroy({
where: { warehouse_id: warehouseId, order_id: orderId },
transaction,
});
if (normalizedItems.length > 0) {
const now = new Date();
await packingModel.bulkCreate(normalizedItems.map(item => ({
...item,
warehouse_id: warehouseId,
order_id: orderId,
created_at: now,
updated_at: now,
})), { transaction });
}
boxCount = new Set(normalizedItems.map(item => item.box_no)).size;
await ctx.model.OrderB2b.update({
total_box_count: boxCount,
}, {
where: { warehouse_id: warehouseId, order_id: orderId },
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
await this.writePrepOperationLogs([ orderId ], {
warehouseId,
operator: params.operator,
operationCode: ORDER_B2B_PACKING_ITEMS_OPERATION_CODE,
message: `更新分箱明细(${normalizedItems.length} 条,${boxCount} 箱)`,
extras: { order_id: orderId, item_count: normalizedItems.length, box_count: boxCount },
scene: 'updateB2bPackingItems',
});
return {
order_id: orderId,
item_count: normalizedItems.length,
box_count: boxCount,
};
}
/**
* 获取 B2B 订单头、商品应拣数量、分箱明细与取货储位快照。
* @param {Object} params 参数。
* @return {Promise<Object>} 订单快照。
*/
async getB2bPackingSnapshot(params = {}) {
const { ctx } = this;
const warehouseId = Number(params.warehouseId || 0);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const [ orderId ] = this.normalizeB2bOrderIds(params.orderIds, {
inputCode: B2B_PACKING_ERROR_CODE.INPUT_INVALID,
actionText: '查询分箱快照',
});
const requirePackingQuantityMatch = await this.isB2bPackingQuantityCheckEnabled(warehouseId);
const transaction = await ctx.model.transaction();
try {
const factory = ctx.model.OrderDeliveryFactory;
const currentModel = await factory.getCurrentModel(warehouseId);
let order = await currentModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
raw: true,
transaction,
});
let sourceType = 'current';
if (!order) {
const dispatchModel = await factory.getDispatchModel(warehouseId);
order = await dispatchModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
raw: true,
transaction,
});
sourceType = 'dispatch';
}
if (!order) {
throw buildB2bError(B2B_PACKING_ERROR_CODE.NOT_FOUND, '订单不存在或不属于当前仓库', {
not_found_order_ids: [ orderId ],
});
}
if (String(order.is_b2b || '').trim() !== 'Y') {
throw buildB2bError(B2B_PACKING_ERROR_CODE.NOT_B2B, '仅 B2B 订单支持查询分箱快照');
}
const orderItems = await this.loadB2bOrderItems({
warehouseId,
orderId,
sourceType,
transaction,
});
const packedItems = await ctx.model.OrderB2bItem.findAll({
where: { warehouse_id: warehouseId, order_id: orderId },
attributes: [ 'order_item_id', 'box_no', 'quantity' ],
order: [[ 'box_no', 'ASC' ], [ 'order_item_id', 'ASC' ]],
raw: true,
transaction,
});
const b2b = await ctx.model.OrderB2b.findOne({
where: { warehouse_id: warehouseId, order_id: orderId },
raw: true,
transaction,
});
const pickLocationMap = await this.loadB2bPickLocationsByItem({
warehouseId,
orderId,
transaction,
});
const pickLocationSpaceKeys = new Set();
for (const locations of pickLocationMap.values()) {
for (const location of locations) {
pickLocationSpaceKeys.add(location.space_id ? `id:${location.space_id}` : `name:${location.space_name}`);
}
}
const packedByItemId = new Map();
for (const packedItem of packedItems) {
const itemId = Number(packedItem.order_item_id);
if (!packedByItemId.has(itemId)) packedByItemId.set(itemId, []);
packedByItemId.get(itemId).push({
box_no: packedItem.box_no,
quantity: Number(packedItem.quantity),
});
}
const items = orderItems.map(item => {
const boxes = packedByItemId.get(Number(item.id)) || [];
return {
order_item_id: Number(item.id),
item_id: item.item_id,
stock_id: item.stock_id,
item_code: item.item_code,
item_name: item.item_name,
item_snapshot: item.item_snapshot,
plan_qty: item.plan_qty === null || item.plan_qty === undefined ? null : Number(item.plan_qty),
packed_quantity: boxes.reduce((sum, box) => sum + box.quantity, 0),
boxes,
pick_locations: pickLocationMap.get(Number(item.id)) || [],
};
});
await transaction.commit();
return {
order_id: orderId,
delivery_order_code: order.delivery_order_code || '',
status: order.status,
prep_status: b2b && b2b.prep_status || B2B_PREP_STATUS.NONE,
total_box_count: Number(b2b && b2b.total_box_count || 0),
require_packing_quantity_match: requirePackingQuantityMatch,
pick_location_count: pickLocationSpaceKeys.size,
items,
};
} catch (error) {
await transaction.rollback();
throw error;
}
}
/**
* 断言目标订单存在且为 B2B 订单(不满足即整体失败)。
*
* @param {Object} params 参数。
* @param {number[]} params.orderIds 订单ID数组。
* @param {Map} params.rowMap 订单行映射。
* @param {string} params.actionText 动作文案。
* @return {void} 无返回值。
*/
assertPrepOrders({ orderIds, rowMap, actionText }) {
const notFoundOrderIds = orderIds.filter(orderId => !rowMap.has(orderId));
if (notFoundOrderIds.length > 0) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.NOT_FOUND,
`订单不存在或不属于当前仓库,无法${actionText}:${notFoundOrderIds.join(',')}`,
{ not_found_order_ids: notFoundOrderIds }
);
}
const notB2bOrderIds = orderIds.filter(orderId => {
const row = rowMap.get(orderId);
return String(row && row.is_b2b || '').trim() !== 'Y';
});
if (notB2bOrderIds.length > 0) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.NOT_B2B,
`仅 B2B 订单支持${actionText},以下订单不是B2B订单:${notB2bOrderIds.join(',')}`,
{ not_b2b_order_ids: notB2bOrderIds }
);
}
}
/**
* 断言订单满足开始备货的作业前置条件(不满足即整体失败)。
*
* 前置条件:已打印(print_status=fin)、已分配储位(storage_status=fin)、未拦截(intercept_status=none)。
* B2B 订单实物在库内备货,缺少上述任一环节都会导致错发/漏发。
*
* 领料(claim_status)不参与校验:领料只存在于「整波领料」流程(需订单在普通波次内,
* wave_id>0 且波次 source=0),而 B2B 订单不参与波次抓取、无波次,永远拿不到 claim_status=fin,
* 若把领料作为前置条件会永久卡死 B2B 备货。
*
* @param {Object} params 参数。
* @param {number} params.orderId 订单ID。
* @param {Object} params.row 订单行(需含 print_status/storage_status/intercept_status)。
* @return {void} 无返回值。
*/
assertPrepStartReady({ orderId, row }) {
const printStatus = String(row && row.print_status || '').trim();
const storageStatus = String(row && row.storage_status || '').trim();
const interceptStatus = String(row && row.intercept_status || '').trim() || 'none';
const reject = reason => buildPrepError(
B2B_PREP_ERROR_CODE.NOT_READY,
`订单${reason},不允许开始备货:${orderId}`,
{
order_id: orderId,
print_status: printStatus,
storage_status: storageStatus,
intercept_status: interceptStatus,
}
);
// 已拦截订单禁止继续仓储作业(与 intercept_guard 口径一致:非 none 即已拦截)
if (isInterceptedOrderStatus(interceptStatus)) {
throw reject('已拦截');
}
if (printStatus !== 'fin') {
throw reject('未打印');
}
if (storageStatus !== 'fin') {
throw reject('未分配储位');
}
}
/**
* 备货开始(单订单作业):记录备货人工号与开始时间,状态置为 padding。
*
* 前置条件:已打印、已分配储位且未拦截(见 assertPrepStartReady),
* 不满足直接失败、不写入任何备货记录。
* 同工号重复开始幂等成功(保留首次开始时间);其他工号已开始或已完成一律失败。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。
* @return {Promise<Object>} 处理结果。
*/
async startOrdersB2bPrep(params = {}) {
const { ctx } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds);
const prepOperator = resolvePrepOperator(params && params.operator, '开始备货');
const transaction = await ctx.model.transaction();
const startedRows = [];
try {
const { rowMap, b2bMap } = await this.loadPrepTargets({
warehouseId: normalizedWarehouseId,
orderIds: normalizedOrderIds,
transaction,
});
this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '开始备货' });
const now = new Date();
const b2bModel = ctx.model.OrderB2b;
for (const orderId of normalizedOrderIds) {
const detail = b2bMap.get(orderId) || null;
const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim();
const recordedOperatorId = Number(detail && detail.prep_operator_id || 0);
if (status === B2B_PREP_STATUS.FIN) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.STATUS_INVALID,
`订单已备货完成,不允许重新开始备货:${orderId}`,
{ order_id: orderId, prep_status: status }
);
}
if (recordedOperatorId > 0 && recordedOperatorId !== prepOperator.id) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH,
`订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许开始备货:${orderId}`,
{ order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id }
);
}
// 未打印 / 未分配储位 / 已拦截:禁止开始备货(幂等重复开始同样校验)。
// 领料不参与校验:领料依赖波次整波领单,B2B 订单无波次、永远未领料。
this.assertPrepStartReady({ orderId, row: rowMap.get(orderId) });
if (status === B2B_PREP_STATUS.PADDING && recordedOperatorId === prepOperator.id) {
// 同工号重复开始:幂等,保留原开始时间,仅补齐姓名为空的情况
if (detail && !String(detail.prep_operator_name || '').trim() && prepOperator.name) {
await b2bModel.update(
{ prep_operator_name: prepOperator.name },
{ where: { warehouse_id: normalizedWarehouseId, order_id: orderId }, transaction }
);
}
startedRows.push({ orderId, started_at: detail && detail.prep_start_at || now, idempotent: true });
continue;
}
const payload = {
prep_status: B2B_PREP_STATUS.PADDING,
prep_operator_id: prepOperator.id,
prep_operator_name: prepOperator.name,
prep_start_at: now,
};
if (detail) {
await b2bModel.update(payload, {
where: { warehouse_id: normalizedWarehouseId, order_id: orderId },
transaction,
});
} else {
await b2bModel.create({
warehouse_id: normalizedWarehouseId,
order_id: orderId,
created_at: now,
...payload,
}, { transaction });
}
startedRows.push({ orderId, started_at: now, idempotent: false });
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
await this.writePrepOperationLogs(startedRows.map(item => item.orderId), {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_PREP_START_OPERATION_CODE,
message: `备货开始(工号 ${prepOperator.id})`,
extras: { prep_operator_id: prepOperator.id },
scene: 'startOrdersB2bPrep',
});
return {
prep_status: B2B_PREP_STATUS.PADDING,
prep_operator_id: prepOperator.id,
prep_operator_name: prepOperator.name,
started_order_ids: [ ...new Set(startedRows.map(item => item.orderId)) ],
started_count: startedRows.length,
idempotent_order_ids: startedRows.filter(item => item.idempotent).map(item => item.orderId),
};
}
/**
* 取消备货(单订单作业):重置备货人、开始时间与备货状态(仅备货中的订单可取消)。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。
* @return {Promise<Object>} 处理结果。
*/
async cancelOrdersB2bPrep(params = {}) {
const { ctx } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds);
const prepOperator = resolvePrepOperator(params && params.operator, '取消备货');
const transaction = await ctx.model.transaction();
const canceledOrderIds = [];
try {
const { rowMap, b2bMap } = await this.loadPrepTargets({
warehouseId: normalizedWarehouseId,
orderIds: normalizedOrderIds,
transaction,
});
this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '取消备货' });
for (const orderId of normalizedOrderIds) {
const detail = b2bMap.get(orderId) || null;
const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim();
const recordedOperatorId = Number(detail && detail.prep_operator_id || 0);
if (status !== B2B_PREP_STATUS.PADDING) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.NOT_STARTED,
`订单未处于备货中,不允许取消备货:${orderId}`,
{ order_id: orderId, prep_status: status }
);
}
if (recordedOperatorId !== prepOperator.id) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH,
`订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许取消备货:${orderId}`,
{ order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id }
);
}
await ctx.model.OrderB2b.update({
prep_status: B2B_PREP_STATUS.NONE,
prep_operator_id: null,
prep_operator_name: null,
prep_start_at: null,
prep_at: null,
prep_duration_seconds: 0,
}, {
where: { warehouse_id: normalizedWarehouseId, order_id: orderId },
transaction,
});
canceledOrderIds.push(orderId);
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
await this.writePrepOperationLogs(canceledOrderIds, {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_PREP_CANCEL_OPERATION_CODE,
message: `取消备货(工号 ${prepOperator.id})`,
extras: { prep_operator_id: prepOperator.id },
scene: 'cancelOrdersB2bPrep',
});
return {
prep_status: B2B_PREP_STATUS.NONE,
canceled_order_ids: [ ...new Set(canceledOrderIds) ],
canceled_count: canceledOrderIds.length,
};
}
/**
* 备货结束(单订单作业):写入备货备注、总箱数、完成时间与备货用时,状态置为 fin。
*
* 仅备货中的订单可结束,且必须由记录在案的同一工号提交。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {string} params.prepRemark 备货备注。
* @param {number|string} params.totalBoxCount 总箱数。
* @param {Object|null} [params.operator=null] 操作人(备货人){ id, name }。
* @return {Promise<Object>} 处理结果。
*/
async finishOrdersB2bPrep(params = {}) {
const { ctx } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds);
const prepOperator = resolvePrepOperator(params && params.operator, '提交备货完成');
const prepRemark = String(params && params.prepRemark || '').trim();
if (!prepRemark) {
throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '备货备注不能为空');
}
if (prepRemark.length > 500) {
throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '备货备注不能超过 500 个字符');
}
const totalBoxCount = Number(params && params.totalBoxCount);
if (!Number.isInteger(totalBoxCount) || totalBoxCount < 0) {
throw buildPrepError(B2B_PREP_ERROR_CODE.INPUT_INVALID, '总箱数必须为大于等于 0 的整数');
}
const requirePackingQuantityMatch = await this.isB2bPackingQuantityCheckEnabled(normalizedWarehouseId);
const transaction = await ctx.model.transaction();
const finishedRows = [];
let finishedAt = null;
try {
const { rowMap, b2bMap, sourceTypeMap } = await this.loadPrepTargets({
warehouseId: normalizedWarehouseId,
orderIds: normalizedOrderIds,
transaction,
});
this.assertPrepOrders({ orderIds: normalizedOrderIds, rowMap, actionText: '提交备货完成' });
const now = new Date();
finishedAt = now;
for (const orderId of normalizedOrderIds) {
const detail = b2bMap.get(orderId) || null;
const status = String(detail && detail.prep_status || B2B_PREP_STATUS.NONE).trim();
const recordedOperatorId = Number(detail && detail.prep_operator_id || 0);
if (status !== B2B_PREP_STATUS.PADDING) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.NOT_STARTED,
`订单未处于备货中,不允许提交备货完成:${orderId}`,
{ order_id: orderId, prep_status: status }
);
}
if (recordedOperatorId !== prepOperator.id) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.OPERATOR_MISMATCH,
`订单备货人为其他工号(${recordedOperatorId}),当前工号(${prepOperator.id})不允许提交备货完成:${orderId}`,
{ order_id: orderId, prep_operator_id: recordedOperatorId, operator_id: prepOperator.id }
);
}
if (requirePackingQuantityMatch) {
await this.assertB2bPackingQuantityComplete({
warehouseId: normalizedWarehouseId,
orderId,
sourceType: sourceTypeMap.get(orderId),
totalBoxCount,
transaction,
});
}
const startAt = detail && detail.prep_start_at ? new Date(detail.prep_start_at) : null;
const durationSeconds = startAt && !Number.isNaN(startAt.getTime())
? Math.max(0, Math.round((now.getTime() - startAt.getTime()) / 1000))
: Number(detail && detail.prep_duration_seconds || 0);
await ctx.model.OrderB2b.update({
prep_status: B2B_PREP_STATUS.FIN,
prep_remark: prepRemark,
total_box_count: totalBoxCount,
prep_at: now,
prep_duration_seconds: durationSeconds,
}, {
where: { warehouse_id: normalizedWarehouseId, order_id: orderId },
transaction,
});
// 备货完成同步扣减库存:与拣货完成(pick.wavePickTaskComplete / recheck._completePickForOrder)口径一致
const stockResult = await this.completeB2bPrepStockOutbound({
warehouseId: normalizedWarehouseId,
orderId,
operator: params && params.operator,
transaction,
});
finishedRows.push({ orderId, durationSeconds, stockResult });
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
const durationSeconds = finishedRows.length > 0 ? finishedRows[0].durationSeconds : 0;
const stockResult = finishedRows.length > 0 && finishedRows[0].stockResult
? finishedRows[0].stockResult
: { storage_ids: [], deducted_quantity: 0 };
await this.writePrepOperationLogs(finishedRows.map(item => item.orderId), {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_PREP_FINISH_OPERATION_CODE,
message: `备货完成(总箱数 ${totalBoxCount},用时 ${durationSeconds} 秒)`,
extras: { prep_operator_id: prepOperator.id, total_box_count: totalBoxCount },
scene: 'finishOrdersB2bPrep',
});
return {
prep_status: B2B_PREP_STATUS.FIN,
prep_remark: prepRemark,
total_box_count: totalBoxCount,
prep_at: finishedAt,
finished_order_ids: [ ...new Set(finishedRows.map(item => item.orderId)) ],
finished_count: finishedRows.length,
prep_duration_seconds: durationSeconds,
stock_deducted_storage_ids: stockResult.storage_ids,
stock_deducted_quantity: stockResult.deducted_quantity,
};
}
/**
* 备货完成时同步扣减库存(与拣货完成口径一致)。
*
* 处理内容与 systems/pick.js#wavePickTaskComplete / recheckOrder#_completePickForOrder 一致:
* 1. 锁定并读取该订单 status='pending' 且未删除的 wms_picking 记录;
* 2. 按 storage_id 汇总数量,加行锁校验 wms_storage.locked_quantity 足够;
* 3. 扣减 wms_storage 的 locked_quantity 与 quantity;
* 4. 写入 wms_storage_transaction 出库流水(OUTBOUND / PICK_OUTBOUND);
* 5. 将 wms_picking 记录置为 fin,避免后续拣货/复核重复扣减。
*
* 无 pending 拣货记录(如 B2B 订单未走拣货流程或已扣减过)时不做任何变更。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @param {Object} params.transaction 事务对象。
* @param {string} [params.remark='备货完成出库(B2B)'] 流水备注。
* @return {Promise<{ storage_ids: number[], deducted_quantity: number }>} 扣减结果。
*/
async completeB2bPrepStockOutbound({ warehouseId, orderId, operator, transaction, remark }) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const normalizedWarehouseId = Number(warehouseId || 0);
const normalizedOrderId = Number(orderId || 0);
const emptyResult = { storage_ids: [], deducted_quantity: 0 };
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0
|| !Number.isInteger(normalizedOrderId) || normalizedOrderId <= 0) {
return emptyResult;
}
// 与拣货完成一致:先锁 pending 拣货记录,防止并发重复扣减
const pickingRows = await ctx.model.query(`
SELECT id, storage_id, quantity, space_id
FROM wms_picking
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
AND status = 'pending'
AND deleted_at IS NULL
FOR UPDATE
`, {
replacements: { orderId: normalizedOrderId, warehouseId: normalizedWarehouseId },
type: ctx.model.QueryTypes.SELECT,
transaction,
});
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
if (normalizedPickingRows.length === 0) {
return emptyResult;
}
// 拣货记录置 fin(避免后续拣货/复核再次扣减)
await ctx.model.query(`
UPDATE wms_picking
SET status = 'fin', updated_at = NOW()
WHERE order_id = :orderId
AND warehouse_id = :warehouseId
AND status = 'pending'
AND deleted_at IS NULL
`, {
replacements: { orderId: normalizedOrderId, warehouseId: normalizedWarehouseId },
type: ctx.model.QueryTypes.UPDATE,
transaction,
});
const storageQtyMap = new Map();
for (const row of normalizedPickingRows) {
const storageId = Number(row && row.storage_id || 0);
if (!Number.isInteger(storageId) || storageId <= 0) {
continue;
}
const currentQty = storageQtyMap.get(storageId) || 0;
storageQtyMap.set(storageId, currentQty + (Number(row.quantity) || 0));
}
const storageIds = [ ...storageQtyMap.keys() ].filter(storageId => (storageQtyMap.get(storageId) || 0) > 0);
if (storageIds.length === 0) {
return emptyResult;
}
const storageRows = await ctx.model.Storage.findAll({
where: {
id: { [Op.in]: storageIds },
warehouse_id: normalizedWarehouseId,
},
attributes: [
'id', 'locked_quantity', 'quantity',
'store_id', 'stock_id', 'batch_no', 'inventory_type', 'space_id',
],
lock: transaction.LOCK.UPDATE,
raw: true,
transaction,
});
for (const storageRow of (Array.isArray(storageRows) ? storageRows : [])) {
const storageId = Number(storageRow && storageRow.id || 0);
const deduction = storageQtyMap.get(storageId) || 0;
const locked = Number(storageRow && storageRow.locked_quantity) || 0;
if (locked < deduction) {
throw buildPrepError(
B2B_PREP_ERROR_CODE.STATUS_INVALID,
`库存记录 ${storageId} 锁定数量不足:当前锁定 ${locked},需扣减 ${deduction}`,
{ storage_id: storageId, locked_quantity: locked, deduction_quantity: deduction }
);
}
}
const caseClauses = storageIds
.map(storageId => `WHEN ${storageId} THEN ${storageQtyMap.get(storageId)}`)
.join(' ');
await ctx.model.query(`
UPDATE wms_storage
SET locked_quantity = locked_quantity - CASE id ${caseClauses} END,
quantity = quantity - CASE id ${caseClauses} END,
updated_at = NOW()
WHERE id IN (:storageIds)
AND warehouse_id = :warehouseId
`, {
replacements: {
storageIds,
warehouseId: normalizedWarehouseId,
},
transaction,
});
const operatorId = String(operator && operator.id || '').trim();
const operatorName = String(operator && operator.name || 'system').trim() || 'system';
const transactionRows = [];
let deductedQuantity = 0;
for (const storageRow of (Array.isArray(storageRows) ? storageRows : [])) {
const storageId = Number(storageRow && storageRow.id || 0);
const deduction = storageQtyMap.get(storageId) || 0;
if (deduction <= 0) {
continue;
}
deductedQuantity += deduction;
const beforeQty = Number(storageRow.quantity) || 0;
const beforeLocked = Number(storageRow.locked_quantity) || 0;
transactionRows.push({
transaction_type: 'OUTBOUND',
warehouse_id: normalizedWarehouseId,
store_id: Number(storageRow.store_id) || 0,
stock_id: Number(storageRow.stock_id) || 0,
storage_id: storageId,
space_id: Number(storageRow.space_id) || null,
quantity: deduction,
before_quantity: beforeQty,
after_quantity: Math.max(0, beforeQty - deduction),
before_locked_quantity: beforeLocked,
after_locked_quantity: Math.max(0, beforeLocked - deduction),
batch_no: storageRow.batch_no || null,
inventory_type: storageRow.inventory_type || 'ZP',
order_type: 'PICK_OUTBOUND',
order_no: String(normalizedOrderId),
order_id: normalizedOrderId,
source_order_codes: String(normalizedOrderId),
operator_id: operatorId,
operator_name: operatorName,
remark: String(remark || '备货完成出库(B2B)').slice(0, 500),
created_at: new Date(),
});
}
if (transactionRows.length > 0) {
await ctx.model.StorageTransaction.bulkCreate(transactionRows, { transaction });
}
return {
storage_ids: storageIds,
deducted_quantity: deductedQuantity,
};
}
/**
* 归一化提货车牌入参。
*
* 去掉空格与常见分隔符(·、•、-、-、_)并转大写;空串 / null 表示清空,返回 null;
* 未传(undefined)视为参数缺失直接报错。仅做基础格式校验(首字符为汉字或字母,
* 整体 5~10 位),避免误拒军牌、使领馆牌、挂车等特殊牌照。
*
* @param {*} value 原始车牌。
* @return {string|null} 归一化车牌,清空时为 null。
*/
normalizePickupPlateNumber(value) {
if (value === undefined) {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.INPUT_INVALID,
'pickup_plate_number 参数不能为空(清空车牌请传空字符串或 null)'
);
}
const normalized = String(value === null ? '' : value)
.replace(/[\s·•\--_]/g, '')
.toUpperCase();
if (!normalized) {
return null;
}
if (normalized.length > B2B_PICKUP_PLATE_MAX_LENGTH) {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.INPUT_INVALID,
`提货车牌不能超过 ${B2B_PICKUP_PLATE_MAX_LENGTH} 个字符`,
{ pickup_plate_number: normalized, max_length: B2B_PICKUP_PLATE_MAX_LENGTH }
);
}
if (!B2B_PICKUP_PLATE_PATTERN.test(normalized)) {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.INPUT_INVALID,
'提货车牌格式不正确(示例:粤A12345、粤AD12345、苏E1234挂)',
{ pickup_plate_number: normalized }
);
}
return normalized;
}
/**
* 录入/修改 B2B 提货车牌(单订单作业)。
*
* 仅 B2B 订单可录入,且必须在提货前完成:已提货(is_picked_up='Y')后车牌锁定,
* 不允许再修改;已取消订单拒绝。作业明细行缺失时按默认值补建。
* 传空字符串或 null 表示清空车牌;车牌去空格/分隔符并转大写后落库。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {string|null} params.pickupPlateNumber 提货车牌(空串/null 表示清空)。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { order_id, delivery_order_code, pickup_plate_number,
* previous_pickup_plate_number, changed, detail_created }
*/
async setOrdersB2bPickupPlate(params = {}) {
const { ctx } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, {
inputCode: B2B_PLATE_ERROR_CODE.INPUT_INVALID,
actionText: '录入提货车牌',
});
const pickupPlateNumber = this.normalizePickupPlateNumber(params && params.pickupPlateNumber);
const orderId = normalizedOrderIds[0];
const transaction = await ctx.model.transaction();
let previousPickupPlateNumber = null;
let detailCreated = false;
let deliveryOrderCode = '';
try {
const { rowMap, b2bMap } = await this.loadPrepTargets({
warehouseId: normalizedWarehouseId,
orderIds: normalizedOrderIds,
transaction,
});
const orderRow = rowMap.get(orderId) || null;
if (!orderRow) {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.NOT_FOUND,
`订单不存在或不属于当前仓库,无法录入提货车牌:${orderId}`,
{ not_found_order_ids: [ orderId ] }
);
}
if (String(orderRow.is_b2b || '').trim() !== 'Y') {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.NOT_B2B,
`仅 B2B 订单支持录入提货车牌,以下订单不是B2B订单:${orderId}`,
{ not_b2b_order_ids: [ orderId ] }
);
}
if (String(orderRow.status || '').trim() === 'cancel') {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.STATUS_INVALID,
`订单已取消,不允许录入提货车牌:${orderId}`,
{ order_id: orderId, status: 'cancel' }
);
}
const detail = b2bMap.get(orderId) || null;
previousPickupPlateNumber = String(detail && detail.pickup_plate_number || '').trim() || null;
// 车牌随提货锁定:提货即出库,出库后再改车牌会导致留证与实物/车辆对不上
if (detail && String(detail.is_picked_up || '').trim() === 'Y') {
throw buildB2bError(
B2B_PLATE_ERROR_CODE.STATUS_INVALID,
`订单已提货,不允许修改提货车牌:${orderId}`,
{ order_id: orderId, pickup_plate_number: previousPickupPlateNumber }
);
}
if (detail) {
await ctx.model.OrderB2b.update({ pickup_plate_number: pickupPlateNumber }, {
where: { warehouse_id: normalizedWarehouseId, order_id: orderId },
transaction,
});
} else {
detailCreated = true;
await ctx.model.OrderB2b.create({
warehouse_id: normalizedWarehouseId,
order_id: orderId,
pickup_plate_number: pickupPlateNumber,
created_at: new Date(),
}, { transaction });
}
deliveryOrderCode = String(orderRow.delivery_order_code || '').trim();
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
const changed = previousPickupPlateNumber !== pickupPlateNumber;
if (changed) {
await this.writePrepOperationLogs([ orderId ], {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_PICKUP_PLATE_OPERATION_CODE,
message: pickupPlateNumber ? `录入提货车牌(${pickupPlateNumber})` : '清空提货车牌',
extras: {
pickup_plate_number: pickupPlateNumber,
previous_pickup_plate_number: previousPickupPlateNumber,
},
scene: 'setOrdersB2bPickupPlate',
});
}
return {
order_id: orderId,
delivery_order_code: deliveryOrderCode,
pickup_plate_number: pickupPlateNumber,
previous_pickup_plate_number: previousPickupPlateNumber,
changed,
detail_created: detailCreated,
};
}
/**
* 归一化提货照片入参(提货时随单提交,追加语义)。
*
* 支持 `[file_id]`、`['file_id']`、`[{ file_id, display_order }]` 混合写法;
* 按 file_id 去重并保留首次出现顺序,display_order 缺省按数组下标补 0 起序号。
* 未传(undefined / null)返回空数组(表示本次不附带提货照片)。
*
* @param {*} rawImages 原始入参。
* @return {Array<{ file_id: number, display_order: number }>} 归一化后的图片列表。
*/
normalizePickupImages(rawImages) {
if (rawImages === undefined || rawImages === null) {
return [];
}
return this.normalizeOrderImages(rawImages);
}
/**
* 校验提货照片文件是否存在(仅一轮存在性校验,不校验仓库归属)。
*
* @param {Array<number>} fileIds 文件ID列表。
* @param {Object|null} [transaction=null] 事务对象。
* @return {Promise<void>} 无返回值;存在缺失时抛 B2B_IMAGE_FILE_INVALID。
*/
async assertPickupFilesExist(fileIds = [], transaction = null) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const normalizedFileIds = [ ...new Set(
(Array.isArray(fileIds) ? fileIds : [])
.map(item => Number(item))
.filter(item => Number.isInteger(item) && item > 0)
) ];
if (normalizedFileIds.length === 0) {
return;
}
const rows = await ctx.model.File.findAll({
where: {
id: { [Op.in]: normalizedFileIds },
is_deleted: false,
},
attributes: [ 'id' ],
raw: true,
...(transaction ? { transaction } : {}),
});
const existingFileIdSet = new Set((Array.isArray(rows) ? rows : [])
.map(row => Number(row && row.id || 0)));
const missingFileIds = normalizedFileIds.filter(fileId => !existingFileIdSet.has(fileId));
if (missingFileIds.length > 0) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.FILE_INVALID,
`提货照片文件不存在或已删除:${missingFileIds.join(',')}`,
{ file_ids: missingFileIds }
);
}
}
/**
* 追加提货照片关联(仅新增,不删除已有照片)。
*
* 落 wms_file_reference:business_type='b2b_pickup'、business_id=订单ID、
* warehouse_id=当前仓库;display_order 在已有最大序号之后顺延。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {Array<{ file_id: number }>} params.imageItems 图片列表。
* @param {Object} params.transaction 事务对象。
* @param {string} [params.createdBy='system'] 创建人。
* @return {Promise<number[]>} 本次新增的 file_id 列表。
*/
async appendPickupImages({ warehouseId, orderId, imageItems, transaction, createdBy }) {
const { ctx } = this;
const items = Array.isArray(imageItems) ? imageItems : [];
const fileReferenceModel = ctx.model && ctx.model.FileReference;
if (items.length === 0
|| !fileReferenceModel
|| typeof fileReferenceModel.findAll !== 'function'
|| typeof fileReferenceModel.bulkCreate !== 'function') {
return [];
}
const referenceWhere = {
business_type: B2B_PICKUP_IMAGE_BUSINESS_TYPE,
business_id: String(orderId),
warehouse_id: warehouseId,
};
const existingRefs = await fileReferenceModel.findAll({
where: referenceWhere,
attributes: [ 'id', 'file_id', 'display_order' ],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const existingList = Array.isArray(existingRefs) ? existingRefs : [];
const existingFileIdSet = new Set(existingList.map(row => Number(row.file_id)));
const maxDisplayOrder = existingList.reduce(
(max, row) => Math.max(max, Number(row.display_order || 0)),
-1
);
const toCreate = items
.filter(item => !existingFileIdSet.has(item.file_id))
.map((item, index) => ({
...referenceWhere,
file_id: item.file_id,
display_order: maxDisplayOrder + 1 + index,
created_by: String(createdBy || 'system').trim() || 'system',
created_at: new Date(),
}));
if (toCreate.length === 0) {
return [];
}
await fileReferenceModel.bulkCreate(toCreate, { transaction, ignoreDuplicates: true });
return toCreate.map(row => row.file_id);
}
/**
* 读取订单提货照片(含文件 URL),按 display_order、id 升序。
*
* @param {Object} params 参数。
* @param {number} params.warehouseId 仓库ID。
* @param {number} params.orderId 订单ID。
* @param {Object|null} [params.transaction=null] 事务对象。
* @return {Promise<Array<{ file_id: number, url: (string|null), display_order: number }>>} 提货照片列表。
*/
async loadPickupImages({ warehouseId, orderId, transaction = null }) {
const { ctx } = this;
const fileReferenceModel = ctx.model && ctx.model.FileReference;
if (!fileReferenceModel || typeof fileReferenceModel.findAll !== 'function') {
return [];
}
const rows = await fileReferenceModel.findAll({
where: {
business_type: B2B_PICKUP_IMAGE_BUSINESS_TYPE,
business_id: String(orderId),
warehouse_id: warehouseId,
},
include: [{
model: ctx.model.File,
as: 'file',
attributes: [ 'file_url' ],
required: false,
}],
order: [[ 'display_order', 'ASC' ], [ 'id', 'ASC' ]],
raw: true,
...(transaction ? { transaction } : {}),
});
return (Array.isArray(rows) ? rows : [])
.map(row => ({
file_id: Number(row && row.file_id || 0),
url: String(row && row['file.file_url'] || '').trim() || null,
display_order: Number(row && row.display_order || 0),
}))
.filter(item => Number.isInteger(item.file_id) && item.file_id > 0);
}
/**
* B2B 提货(单订单作业):记录提货时间,is_picked_up 置为 Y,并把订单主表标记为已出库。
*
* 仅 B2B 订单可提货,且要求备货已完成(prep_status='fin');
* 已提货订单重复调用幂等成功(保留首次提货时间)。
* 可选传 pickupPlateNumber 在同一事务内写入提货车牌;提货后车牌锁定,不允许再改。
*
* 提货即出库完成:同一事务内把订单所在表(current 优先、dispatch 兜底)的
* outbound_status 置 fin、step 置 4、delivery_time 置提货时间,
* 使出库迁移调度(schedule/sync_outbound_orders_to_delivery)按既有状态条件把订单搬到配送表;
* 已提货但主表未完成出库的历史订单在重复调用时按首次提货时间补写(自愈)。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {string|null} [params.pickupPlateNumber] 提货车牌(可选;传空串/null 表示清空)。
* @param {Array<number|Object>} [params.pickupImages] 提货照片 file_id 列表(可选;仅校验存在性后追加)。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { is_picked_up, picked_up_at, pickup_plate_number, pickup_images,
* outbound_status, step, delivery_time, picked_up_order_ids, picked_up_count, already_picked_up }
*/
async pickupOrdersB2b(params = {}) {
const { ctx } = this;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, {
inputCode: B2B_PICKUP_ERROR_CODE.INPUT_INVALID,
actionText: '提货',
});
const hasPickupPlateInput = params && Object.prototype.hasOwnProperty.call(params, 'pickupPlateNumber')
&& params.pickupPlateNumber !== undefined;
const normalizedPickupPlate = hasPickupPlateInput
? this.normalizePickupPlateNumber(params.pickupPlateNumber)
: null;
const pickupImageItems = this.normalizePickupImages(params && params.pickupImages);
const transaction = await ctx.model.transaction();
let pickedUpAt = null;
let alreadyPickedUp = false;
let outboundMarked = false;
let pickupPlateNumber = null;
let addedPickupFileIds = [];
let pickupImages = [];
try {
const { rowMap, b2bMap, modelMap } = await this.loadPrepTargets({
warehouseId: normalizedWarehouseId,
orderIds: normalizedOrderIds,
transaction,
});
const orderId = normalizedOrderIds[0];
const orderRow = rowMap.get(orderId) || null;
if (!orderRow) {
throw buildPrepError(
B2B_PICKUP_ERROR_CODE.NOT_FOUND,
`订单不存在或不属于当前仓库,无法提货:${orderId}`,
{ not_found_order_ids: [ orderId ] }
);
}
if (String(orderRow.is_b2b || '').trim() !== 'Y') {
throw buildPrepError(
B2B_PICKUP_ERROR_CODE.NOT_B2B,
`仅 B2B 订单支持提货,以下订单不是B2B订单:${orderId}`,
{ not_b2b_order_ids: [ orderId ] }
);
}
if (String(orderRow.status || '').trim() === 'cancel') {
throw buildPrepError(
B2B_PICKUP_ERROR_CODE.STATUS_INVALID,
`订单已取消,不允许提货:${orderId}`,
{ order_id: orderId, status: 'cancel' }
);
}
const detail = b2bMap.get(orderId) || null;
if (!detail) {
throw buildPrepError(
B2B_PICKUP_ERROR_CODE.STATUS_INVALID,
`订单未备货完成,不允许提货:${orderId}`,
{ order_id: orderId, prep_status: B2B_PREP_STATUS.NONE }
);
}
const storedPickupPlate = String(detail && detail.pickup_plate_number || '').trim() || null;
if (String(detail.is_picked_up || '').trim() === 'Y') {
// 已提货:幂等成功,保留首次提货时间;车牌随提货锁定,不允许再改
if (hasPickupPlateInput && normalizedPickupPlate !== storedPickupPlate) {
throw buildB2bError(
B2B_PICKUP_ERROR_CODE.STATUS_INVALID,
`订单已提货,不允许修改提货车牌:${orderId}`,
{ order_id: orderId, pickup_plate_number: storedPickupPlate }
);
}
alreadyPickedUp = true;
pickedUpAt = detail.picked_up_at || null;
pickupPlateNumber = storedPickupPlate;
} else {
if (String(detail.prep_status || B2B_PREP_STATUS.NONE).trim() !== B2B_PREP_STATUS.FIN) {
throw buildPrepError(
B2B_PICKUP_ERROR_CODE.STATUS_INVALID,
`订单未备货完成,不允许提货:${orderId}`,
{ order_id: orderId, prep_status: String(detail.prep_status || B2B_PREP_STATUS.NONE).trim() }
);
}
pickedUpAt = new Date();
const pickupPayload = {
is_picked_up: 'Y',
picked_up_at: pickedUpAt,
};
if (hasPickupPlateInput) {
pickupPayload.pickup_plate_number = normalizedPickupPlate;
}
await ctx.model.OrderB2b.update(pickupPayload, {
where: { warehouse_id: normalizedWarehouseId, order_id: orderId },
transaction,
});
pickupPlateNumber = hasPickupPlateInput ? normalizedPickupPlate : storedPickupPlate;
}
// 提货照片:只做一轮存在性校验后追加,不覆盖已有照片(提货前预传、提货时补充均走同一路径)
if (pickupImageItems.length > 0) {
await this.assertPickupFilesExist(pickupImageItems.map(item => item.file_id), transaction);
addedPickupFileIds = await this.appendPickupImages({
warehouseId: normalizedWarehouseId,
orderId,
imageItems: pickupImageItems,
transaction,
createdBy: params && params.operator && params.operator.name
|| ctx.user && (ctx.user.employees_name || ctx.user.name)
|| 'system',
});
}
pickupImages = await this.loadPickupImages({
warehouseId: normalizedWarehouseId,
orderId,
transaction,
});
// 提货即出库完成:主表写 outbound_status=fin / step=4 / delivery_time,
// 由出库迁移调度按既有状态条件把订单搬到配送表(无需给迁移脚本加 B2B 特判)。
// 已提货的历史订单(is_picked_up=Y 但主表未完成)在此按首次提货时间补写,实现自愈。
const currentOutboundStatus = String(orderRow.outbound_status || '').trim();
const currentStep = Number(orderRow.step || 0);
const needMarkOutbound = currentOutboundStatus !== B2B_OUTBOUND_STATUS_FIN
|| currentStep !== B2B_OUTBOUND_STEP;
if (needMarkOutbound) {
const orderModelToUpdate = modelMap.get(orderId);
if (!orderModelToUpdate || typeof orderModelToUpdate.update !== 'function') {
throw new Error(`无法定位订单所在分表模型,出库状态写入失败:${orderId}`);
}
const deliveryTime = pickedUpAt || orderRow.delivery_time || new Date();
await orderModelToUpdate.update({
outbound_status: B2B_OUTBOUND_STATUS_FIN,
step: B2B_OUTBOUND_STEP,
delivery_time: deliveryTime,
updated_at: new Date(),
}, {
where: { id: orderId, warehouse_id: normalizedWarehouseId },
transaction,
});
outboundMarked = true;
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
if (!alreadyPickedUp) {
await this.writePrepOperationLogs([ normalizedOrderIds[0] ], {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_PICKUP_OPERATION_CODE,
message: 'B2B订单提货',
extras: {
...(hasPickupPlateInput ? { pickup_plate_number: pickupPlateNumber } : {}),
...(addedPickupFileIds.length > 0 ? { pickup_file_ids: addedPickupFileIds } : {}),
},
scene: 'pickupOrdersB2b',
});
}
return {
is_picked_up: 'Y',
picked_up_at: pickedUpAt,
pickup_plate_number: pickupPlateNumber,
pickup_images: pickupImages,
pickup_image_count: pickupImages.length,
outbound_status: B2B_OUTBOUND_STATUS_FIN,
step: B2B_OUTBOUND_STEP,
outbound_marked: outboundMarked,
picked_up_order_ids: [ normalizedOrderIds[0] ],
picked_up_count: 1,
already_picked_up: alreadyPickedUp,
};
}
/**
* 归一化订单图片入参。
*
* 支持 `[{ file_id, display_order }]`、`[file_id]`、`['file_id']` 混合写法;
* 按 file_id 去重并保留首次出现顺序,display_order 缺省按数组下标补 0 起序号。
*
* @param {*} rawImages 原始图片入参。
* @return {Array<{ file_id: number, display_order: number }>} 归一化后的图片列表(可为空数组)。
*/
normalizeOrderImages(rawImages) {
if (rawImages === undefined || rawImages === null) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.INPUT_INVALID,
'images 参数不能为空(清空图片请传空数组)'
);
}
if (!Array.isArray(rawImages)) {
throw buildB2bError(B2B_IMAGE_ERROR_CODE.INPUT_INVALID, 'images 必须为数组');
}
const seenFileIds = new Set();
const normalized = [];
for (const item of rawImages) {
const rawFileId = item && typeof item === 'object' && !Array.isArray(item)
? (item.file_id ?? item.fileId ?? item.id)
: item;
const fileId = Number(rawFileId);
if (!Number.isInteger(fileId) || fileId <= 0) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.INPUT_INVALID,
'图片 file_id 必须为正整数',
{ invalid_file_id: rawFileId }
);
}
if (seenFileIds.has(fileId)) {
continue;
}
seenFileIds.add(fileId);
const rawDisplayOrder = item && typeof item === 'object' && !Array.isArray(item)
? (item.display_order ?? item.displayOrder ?? item.sort_order ?? item.sortOrder)
: undefined;
const displayOrder = rawDisplayOrder === undefined || rawDisplayOrder === null || rawDisplayOrder === ''
? normalized.length
: Number(rawDisplayOrder);
if (!Number.isInteger(displayOrder) || displayOrder < 0) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.INPUT_INVALID,
'图片 display_order 必须为非负整数',
{ file_id: fileId, display_order: rawDisplayOrder }
);
}
normalized.push({ file_id: fileId, display_order: displayOrder });
}
if (normalized.length > B2B_ORDER_IMAGE_MAX) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.INPUT_INVALID,
`单个订单最多维护 ${B2B_ORDER_IMAGE_MAX} 张图片,当前 ${normalized.length} 张`,
{ max: B2B_ORDER_IMAGE_MAX, current: normalized.length }
);
}
return normalized;
}
/**
* 更新 B2B 订单备货留证照片(全量覆盖)。
*
* 图片关系统一落在 wms_file_reference:business_type='b2b_order'、business_id=订单ID、
* warehouse_id=当前仓库、display_order 控制顺序;wms_file 只做文件本体复用,不做物理删除。
*
* 入参 images 为全量覆盖语义:未包含的旧关联会被删除,新关联按列表顺序写入;
* 传空数组表示清空该订单备货照片。仅 B2B 订单(is_b2b='Y')且未取消的订单可更新。
* 交易对象在 current 分表优先、dispatch 分表兜底查找;文件必须属于当前仓库且未删除。
*
* @param {Object} params 参数。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID数组(仅 1 个)。
* @param {Array<Object|number|string>} params.images 图片列表(file_id / display_order)。
* @param {Object|null} [params.operator=null] 操作人 { id, name }。
* @return {Promise<Object>} { order_id, business_type, image_count, images, added_file_ids, removed_file_ids }
*/
async updateOrderImages(params = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const businessType = B2B_PREP_IMAGE_BUSINESS_TYPE;
const normalizedWarehouseId = Number(params && params.warehouseId || 0);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error('未识别到当前仓库上下文');
}
const normalizedOrderIds = this.normalizeB2bOrderIds(params && params.orderIds, {
inputCode: B2B_IMAGE_ERROR_CODE.INPUT_INVALID,
actionText: '更新订单图片',
});
const orderId = normalizedOrderIds[0];
const imageItems = this.normalizeOrderImages(params && params.images);
const operator = params && params.operator && typeof params.operator === 'object'
? params.operator
: null;
// ── 1. 订单定位(current 优先、dispatch 兜底)与 B2B 校验 ──
const factory = ctx.model.OrderDeliveryFactory;
const ORDER_ATTRIBUTES = [ 'id', 'delivery_order_code', 'is_b2b', 'status' ];
const orderWhere = { id: orderId, warehouse_id: normalizedWarehouseId };
const currentModel = await factory.getCurrentModel(normalizedWarehouseId);
let orderRow = await currentModel.findOne({ where: orderWhere, attributes: ORDER_ATTRIBUTES, raw: true });
if (!orderRow) {
const dispatchModel = await factory.getDispatchModel(normalizedWarehouseId);
orderRow = await dispatchModel.findOne({ where: orderWhere, attributes: ORDER_ATTRIBUTES, raw: true });
}
if (!orderRow) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.NOT_FOUND,
`订单不存在或不属于当前仓库,无法更新图片:${orderId}`,
{ order_id: orderId }
);
}
if (String(orderRow.is_b2b || '').trim() !== 'Y') {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.NOT_B2B,
`仅 B2B 订单支持更新订单图片,以下订单不是B2B订单:${orderId}`,
{ order_id: orderId }
);
}
if (String(orderRow.status || '').trim() === 'cancel') {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.STATUS_INVALID,
`订单已取消,不允许更新图片:${orderId}`,
{ order_id: orderId, status: 'cancel' }
);
}
// ── 2. 文件归属校验:必须属于当前仓库且未删除 ──
const fileIds = imageItems.map(item => item.file_id);
const fileUrlMap = new Map();
if (fileIds.length > 0) {
const fileRows = await ctx.model.File.findAll({
where: {
id: { [Op.in]: fileIds },
warehouse_id: normalizedWarehouseId,
is_deleted: false,
},
attributes: [ 'id', 'file_url' ],
raw: true,
});
for (const row of (Array.isArray(fileRows) ? fileRows : [])) {
fileUrlMap.set(Number(row.id), String(row.file_url || '').trim());
}
const invalidFileIds = fileIds.filter(fileId => !fileUrlMap.has(fileId));
if (invalidFileIds.length > 0) {
throw buildB2bError(
B2B_IMAGE_ERROR_CODE.FILE_INVALID,
`图片文件不存在、已删除或不属于当前仓库:${invalidFileIds.join(',')}`,
{ file_ids: invalidFileIds }
);
}
}
// ── 3. 事务内全量同步 wms_file_reference ──
const businessId = String(orderId);
const referenceWhere = {
business_type: businessType,
business_id: businessId,
warehouse_id: normalizedWarehouseId,
};
const createdBy = String(
operator && operator.name || ctx.user && (ctx.user.employees_name || ctx.user.name) || ''
).trim() || 'system';
const transaction = await ctx.model.transaction();
const addedFileIds = [];
const removedFileIds = [];
try {
const existingRefs = await ctx.model.FileReference.findAll({
where: referenceWhere,
attributes: [ 'id', 'file_id', 'display_order' ],
raw: true,
transaction,
lock: transaction.LOCK.UPDATE,
});
const existingRefsList = Array.isArray(existingRefs) ? existingRefs : [];
const existingFileIdSet = new Set(existingRefsList.map(row => Number(row.file_id)));
const keepFileIdSet = new Set(fileIds);
const toDeleteIds = existingRefsList
.filter(row => !keepFileIdSet.has(Number(row.file_id)))
.map(row => Number(row.id))
.filter(id => Number.isInteger(id) && id > 0);
const toCreate = imageItems.filter(item => !existingFileIdSet.has(item.file_id));
const toUpdateOrder = imageItems.filter(item => {
if (!existingFileIdSet.has(item.file_id)) {
return false;
}
const existing = existingRefsList.find(row => Number(row.file_id) === item.file_id);
return Number(existing && existing.display_order || 0) !== item.display_order;
});
if (toDeleteIds.length > 0) {
await ctx.model.FileReference.destroy({
where: { ...referenceWhere, id: { [Op.in]: toDeleteIds } },
transaction,
});
removedFileIds.push(...existingRefsList
.filter(row => toDeleteIds.includes(Number(row.id)))
.map(row => Number(row.file_id)));
}
if (toCreate.length > 0) {
await ctx.model.FileReference.bulkCreate(toCreate.map(item => ({
...referenceWhere,
file_id: item.file_id,
display_order: item.display_order,
created_by: createdBy,
created_at: new Date(),
})), { transaction, ignoreDuplicates: true });
addedFileIds.push(...toCreate.map(item => item.file_id));
}
for (const item of toUpdateOrder) {
await ctx.model.FileReference.update(
{ display_order: item.display_order },
{ where: { ...referenceWhere, file_id: item.file_id }, transaction }
);
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
// ── 4. 回读最终图片列表(含文件 URL) ──
const finalRefs = await ctx.model.FileReference.findAll({
where: referenceWhere,
include: [{
model: ctx.model.File,
as: 'file',
attributes: [ 'file_url' ],
required: false,
}],
order: [[ 'display_order', 'ASC' ], [ 'id', 'ASC' ]],
raw: true,
});
const images = (Array.isArray(finalRefs) ? finalRefs : [])
.map(row => ({
file_id: Number(row.file_id),
url: String(row['file.file_url'] || '').trim() || null,
display_order: Number(row.display_order || 0),
}))
.filter(item => Number.isInteger(item.file_id) && item.file_id > 0);
// ── 5. 操作日志(提交后写入,失败仅告警) ──
await this.writePrepOperationLogs([ orderId ], {
warehouseId: normalizedWarehouseId,
operator: params && params.operator,
operationCode: ORDER_B2B_IMAGES_OPERATION_CODE,
message: `更新B2B订单图片(共 ${images.length} 张)`,
extras: {
business_type: businessType,
image_count: images.length,
added_file_ids: addedFileIds,
removed_file_ids: removedFileIds,
},
scene: 'updateOrderImages',
});
return {
order_id: orderId,
delivery_order_code: String(orderRow.delivery_order_code || '').trim(),
business_type: businessType,
image_count: images.length,
images,
added_file_ids: addedFileIds,
removed_file_ids: removedFileIds,
};
}
/**
* 归一化备货/提货单订单入参(单订单作业,仅允许 1 个订单ID)。
* @param {*} rawIds 原始入参。
* @param {Object} [options={}] 选项。
* @param {string} [options.inputCode] 入参错误码。
* @param {string} [options.actionText='处理'] 动作文案。
* @return {number[]} 单元素订单ID数组。
*/
normalizeB2bOrderIds(rawIds, options = {}) {
const errorCode = options.inputCode || B2B_PREP_ERROR_CODE.INPUT_INVALID;
const actionText = String(options.actionText || '备货作业').trim();
const normalized = [ ...new Set(
(Array.isArray(rawIds) ? rawIds : [ rawIds ])
.map(item => Number(item))
.filter(item => Number.isInteger(item) && item > 0)
) ];
if (normalized.length === 0) {
throw buildPrepError(errorCode, '订单ID不能为空');
}
if (normalized.length > 1) {
throw buildPrepError(
errorCode,
`${actionText}仅支持单个订单,请单条提交`,
{ order_ids: normalized }
);
}
return normalized;
}
/**
* 写备货作业操作日志(事务提交后调用,失败仅告警)。
*
* @param {number[]} orderIds 订单ID数组。
* @param {Object} params 日志参数。
* @return {Promise<void>} 无返回值。
*/
async writePrepOperationLogs(orderIds = [], params = {}) {
const { ctx } = this;
const operator = params.operator && typeof params.operator === 'object' ? params.operator : null;
const extras = params.extras && typeof params.extras === 'object' && !Array.isArray(params.extras)
? params.extras
: {};
for (const orderId of orderIds) {
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: Number(orderId),
operationCode: params.operationCode,
operationAction: 'UPDATE',
changeSummary: params.message,
operator,
extras: {
warehouseId: params.warehouseId,
orderId: Number(orderId),
...extras,
message: params.message,
},
beforeChanges: null,
});
} catch (error) {
ctx.logger.warn(`[orderB2b.${params.scene}] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${error.message}`);
}
}
}
}
module.exports = OrderB2bService;