feat(stockout): 出库单操作日志/取消/确认回传与 STOCKOUT 渠道订单同步,workbench 查询与打包状态回写,默认库位配置及权限迁移

This commit is contained in:
liufumingren 2026-08-26 15:35:35 +08:00
parent 73d12cdf1a
commit 93c0a620c7
16 changed files with 1884 additions and 71 deletions

View File

@ -59,6 +59,7 @@ module.exports = app => {
receiver_address: '',
group_wave_prefix: 'B',
delete_order_wave_prefix: 'A',
default_location_id: null,
single_order_pack_max_minutes: 3,
group_order_pack_max_minutes: 40,
inventory_warning_rules: DEFAULT_INVENTORY_WARNING_RULES,
@ -329,6 +330,17 @@ module.exports = app => {
normalized.inventory_warning_rules = normalizeInventoryWarningRules(parsed.inventory_warning_rules);
normalized.auto_outbound_rules = normalizeAutoOutboundRules(parsed.auto_outbound_rules);
const rawDefaultLocationId = parsed.default_location_id;
if (rawDefaultLocationId === undefined || rawDefaultLocationId === null || rawDefaultLocationId === '') {
normalized.default_location_id = null;
} else {
const defaultLocationId = Number(rawDefaultLocationId);
if (!Number.isInteger(defaultLocationId) || defaultLocationId <= 0) {
throw new Error('subject_config.default_location_id 必须是正整数库位ID');
}
normalized.default_location_id = defaultLocationId;
}
if (Object.prototype.hasOwnProperty.call(parsed, 'cutoff_order_enabled')) {
normalized.cutoff_order_enabled = normalizeBooleanFlag(parsed.cutoff_order_enabled, 'subject_config.cutoff_order_enabled');
}

View File

@ -82,6 +82,8 @@ class StorageStockoutService extends MainService {
const finalWhere = { [Op.and]: andConditions };
const { count, rows } = await OrderStockoutModel.findAndCountAll({
// 必须返回 id:前端行点击/详情/打印/确认等均依赖 row.id(与 receiving 等列表保持一致)
attributes: { exclude: [ 'warehouse_name' ] },
where: finalWhere,
order: [[ sortField, sortOrder ], [ 'id', 'DESC' ]],
limit: pageSize,
@ -89,6 +91,22 @@ class StorageStockoutService extends MainService {
raw: true,
});
// 补充货主名称:store_name 快照为空时按 store_id 解析 wms_store.company_name
const storeIds = [ ...new Set(rows.map(row => Number(row.store_id)).filter(id => Number.isFinite(id) && id > 0)) ];
if (storeIds.length > 0) {
const stores = await ctx.model.Store.findAll({
where: { id: { [Op.in]: storeIds } },
attributes: [ 'id', 'company_name' ],
raw: true,
});
const nameMap = new Map(stores.map(item => [ Number(item.id), String(item.company_name || '') ]));
for (const row of rows) {
if (!row.store_name) {
row.store_name = nameMap.get(Number(row.store_id)) || '';
}
}
}
return this.success('ok', {
list: rows,
pagination: {
@ -323,6 +341,12 @@ class StorageStockoutService extends MainService {
ctx.logger.error(`[stockout.toOrder] 标记出库单已转失败: ${updateErr.message}`);
}
await this._writeStockoutOperationLog(
order,
'STOCKOUT_TO_ORDER',
`出库单已转订单 ${deliveryOrderCode}(order_id=${orderId}),已释放库存锁定`
);
return this.success('转订单成功', {
id: order.id,
stockout_order_code: order.stockout_order_code,
@ -364,6 +388,44 @@ class StorageStockoutService extends MainService {
}
}
/**
* 写 wms_operation_log 操作日志(businessType=stockout),失败仅告警不影响主流程。
* @param {Object} order 出库单实例或行
* @param {string} operationCode 操作编码
* @param {string} message 日志内容
* @param {Object} [options={}] 选项,可含 transaction
* @return {Promise<void>} 无返回值
*/
async _writeStockoutOperationLog(order, operationCode, message, options = {}) {
const { ctx } = this;
const opLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (!opLogService || typeof opLogService.createOperationLogs !== 'function') {
ctx.logger.warn('[stockout] 操作日志服务不可用,跳过记录');
return;
}
const user = ctx.user || {};
try {
await opLogService.createOperationLogs([
{
businessType: 'stockout',
businessId: order.id,
operationCode,
operator: {
id: user.employees_id ?? user.id ?? null,
name: String(user.employees_name || user.real_name || user.name || 'system'),
},
extras: {
warehouseId: Number(ctx.user && ctx.user.store_id) || order.warehouse_id || null,
message,
externalLogType: 'NONE',
},
},
], { transaction: options.transaction });
} catch (err) {
ctx.logger.warn(`[stockout] 写操作日志失败: ${err.message}`);
}
}
/**
* 出库单明细查询。
* @param {Object} data 请求体
@ -421,10 +483,91 @@ class StorageStockoutService extends MainService {
});
}
/**
* 查询出库单操作日志(分页)。
* 日志业务类型 business_type=stockout,business_id=出库单ID;
* 覆盖创建/审核/转订单/确认/修改/取消等操作(STOCKOUT_* 操作编码)。
* @param {Object} data 请求体
* @param {number} [data.id] 出库单ID(与 stockout_order_code 至少传一个)
* @param {string} [data.stockout_order_code] 出库单号
* @param {Object} [data.pagination] 分页对象,支持 page / pageSize(或 page_size)
* @return {Promise<Object>} 统一成功包装响应 { list, pagination }
*/
async listLogs(data = {}) {
const { ctx, service } = this;
const requestData = data && typeof data === 'object' ? data : {};
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
const id = Number(requestData.id || 0);
const stockoutOrderCode = String(requestData.stockout_order_code || '').trim();
// 分页参数:兼容顶层 page/pageSize(与订单日志 order.queryOrderLogs 一致)与 pagination 对象两种写法
const pagination = requestData.pagination && typeof requestData.pagination === 'object'
? requestData.pagination
: {};
const page = requestData.page ?? pagination.page;
const pageSize = requestData.pageSize ?? pagination.pageSize ?? pagination.page_size;
if (!id && !stockoutOrderCode) {
return this.fail('id 或 stockout_order_code 至少传一个');
}
const emptyResult = {
list: [],
pagination: {
page: Number.parseInt(page, 10) || 1,
pageSize: Number.parseInt(pageSize, 10) || 20,
total: 0,
totalPages: 0,
},
};
// 定位出库单ID(日志 business_id 存的是出库单ID)
let stockoutId = id;
if (!stockoutId) {
const order = await ctx.model.OrderStockout.findOne({
where: {
stockout_order_code: stockoutOrderCode,
warehouse_id: warehouseId,
deleted_at: null,
},
attributes: [ 'id' ],
raw: true,
});
if (!order || !order.id) {
return this.success('ok', {
data: emptyResult,
code: 200,
});
}
stockoutId = Number(order.id);
}
try {
const result = await service.systems.operationLog.queryStockoutLogs({
id: stockoutId,
page,
pageSize,
warehouseId,
});
return this.success('ok', {
data: result,
code: 200,
});
} catch (e) {
// 与订单日志接口一致:查询异常时以 200 包装返回错误信息
return this.success(e.message, {
code: 200,
});
}
}
/**
* 出库单确认(直出)。
* 不改变内部库存,直接按出库单明细的计划数量确认。
* 出站同步 taobao.qimen.stockout.confirm 成功后,状态才推进到 COMPLETED。
* 出站同步 taobao.qimen.stockout.confirm 成功后,释放创建时占用的库存锁定(QM_STOCKOUT,写 UNLOCK 流水),
* 状态才推进到 COMPLETED。
* 要求 express_code 已填写,否则拒绝确认。
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
@ -549,10 +692,56 @@ class StorageStockoutService extends MainService {
// 第三步:根据出站结果更新状态
if (qimenSuccess) {
await ctx.model.OrderStockout.update(
{ order_status: 'COMPLETED', sync_status: 'SUCCESS', sync_message: '', updated_at: new Date() },
{ where: { id: order.id } }
);
// 直出确认:释放出库单占用的库存锁定(QM_STOCKOUT,负数量释放并自动写 UNLOCK 流水),
// 与状态推进到 COMPLETED 在同一事务内完成,失败回滚可重试。
const finalizeTransaction = await ctx.model.transaction();
try {
let totalReleaseQty = 0;
for (const item of items) {
const qty = Number(item.plan_qty) || 0;
if (qty <= 0) continue;
const releaseResult = await ctx.service.systems.stockStore.lockItemStorages(
item.stock_id,
-qty,
finalizeTransaction,
null,
{
orderType: 'QM_STOCKOUT',
orderNo: order.stockout_order_code,
orderId: order.id,
remark: '出库单确认释放锁定',
}
);
if (!releaseResult.success) {
// 已释放过(锁定不足)视为幂等成功,避免阻断重试
const alreadyReleased = String(releaseResult.error || '').includes('释放数量超过已锁定库存');
if (alreadyReleased) {
ctx.logger.warn(`[stockout.confirm] 库存${item.stock_id}锁定已释放,跳过: ${releaseResult.error}`);
continue;
}
throw new Error(`库存${item.stock_id}释放锁定失败: ${releaseResult.error}`);
}
totalReleaseQty += qty;
}
await this._writeStockoutOperationLog(
order,
'STOCKOUT_CONFIRM',
`出库单确认完成(直出),释放锁定库存 ${totalReleaseQty}`,
{ transaction: finalizeTransaction }
);
await ctx.model.OrderStockout.update(
{ order_status: 'COMPLETED', sync_status: 'SUCCESS', sync_message: '', updated_at: new Date() },
{ where: { id: order.id }, transaction: finalizeTransaction }
);
await finalizeTransaction.commit();
} catch (err) {
await finalizeTransaction.rollback().catch(() => {});
ctx.logger.error(`[stockout.confirm] 释放锁定失败: ${order.stockout_order_code} - ${err.message}`);
return this.fail(`确认失败:${err.message}`);
}
ctx.logger.info(`[stockout.confirm] 确认完成: ${order.stockout_order_code}`);
return this.success('确认成功', {
@ -576,6 +765,104 @@ class StorageStockoutService extends MainService {
return this.fail(`出站同步失败: ${qimenMessage || '未发起出站通知'}`);
}
/**
* 出库单取消。
*
* 仅 CREATED / PENDING 状态允许取消;事务内释放创建时占用的库存锁定(QM_STOCKOUT,
* 写 UNLOCK 流水),状态置为 CANCELLED,并写 wms_operation_log 操作日志。
* 已转订单(TRANSFERRED)与已完成(COMPLETED)状态禁止取消。
*
* @param {Object} data 请求体
* @param {number} data.id 出库单ID(必填)
* @return {Promise<Object>} 统一成功/失败包装响应
*/
async cancel(data = {}) {
const { ctx } = this;
const id = Number(data.id || 0);
if (!id) {
return this.fail('缺少出库单ID');
}
const warehouseId = Number(ctx.user && ctx.user.store_id) || 0;
if (warehouseId <= 0) {
return this.fail('缺少仓库上下文');
}
const order = await ctx.model.OrderStockout.findOne({
where: { id, warehouse_id: warehouseId, deleted_at: null },
});
if (!order) {
return this.fail('出库单不存在');
}
if (!order.canCancel || !order.canCancel()) {
return this.fail(`出库单当前状态(${order.order_status})不允许取消`);
}
const items = await ctx.model.OrderStockoutItems.findAll({
where: { order_id: order.id },
raw: true,
});
// 释放创建时占用的库存锁定 + 状态置 CANCELLED + 操作日志,同一事务
const cancelTransaction = await ctx.model.transaction();
try {
let releasedQty = 0;
for (const item of items) {
const qty = Number(item.plan_qty) || 0;
if (qty <= 0) continue;
const releaseResult = await ctx.service.systems.stockStore.lockItemStorages(
item.stock_id,
-qty,
cancelTransaction,
null,
{
orderType: 'QM_STOCKOUT',
orderNo: order.stockout_order_code,
orderId: order.id,
remark: '出库单取消释放锁定',
}
);
if (!releaseResult.success) {
// 已释放过(锁定不足)视为幂等成功,避免阻断
const alreadyReleased = String(releaseResult.error || '').includes('释放数量超过已锁定库存');
if (alreadyReleased) {
ctx.logger.warn(`[stockout.cancel] 库存${item.stock_id}锁定已释放,跳过: ${releaseResult.error}`);
continue;
}
throw new Error(`库存${item.stock_id}释放锁定失败: ${releaseResult.error}`);
}
releasedQty += qty;
}
await ctx.model.OrderStockout.update(
{ order_status: 'CANCELLED', sync_message: '已取消', updated_at: new Date() },
{ where: { id: order.id }, transaction: cancelTransaction }
);
await this._writeStockoutOperationLog(
order,
'STOCKOUT_CANCEL',
`出库单已取消,释放锁定库存 ${releasedQty}`,
{ transaction: cancelTransaction }
);
await cancelTransaction.commit();
} catch (err) {
await cancelTransaction.rollback().catch(() => {});
ctx.logger.error(`[stockout.cancel] 取消失败: ${order.stockout_order_code} - ${err.message}`);
return this.fail(`取消失败:${err.message}`);
}
ctx.logger.info(`[stockout.cancel] 取消完成: ${order.stockout_order_code}`);
return this.success('取消成功', {
id: order.id,
stockout_order_code: order.stockout_order_code,
order_status: 'CANCELLED',
});
}
/**
* 更新出库单快递和运单号。
* 用于在确认前填写 express_code / waybill_code / waybill_codes。
@ -671,6 +958,7 @@ class StorageStockoutService extends MainService {
* @param {string} [data.area] 区/县
* @param {string} [data.town] 镇/街道
* @param {string} [data.detailAddress] 详细地址
* @param {string} [data.receiver_id] 收件人证件号
* @param {string} [data.express_code] 快递公司编码(自动解析 express_name)
* @param {string} [data.source_platform_code] 来源平台编码
* @param {string} [data.source_platform_name] 来源平台名称
@ -701,28 +989,30 @@ class StorageStockoutService extends MainService {
}
const updateData = { updated_at: new Date() };
const changedLabels = [];
// 收件人 / 地址字段:传入才更新,空串置 NULL
const receiverFieldMap = {
receiver_name: 'name',
receiver_tel: 'tel',
receiver_mobile: 'mobile',
receiver_company: 'company',
receiver_email: 'email',
receiver_zip_code: 'zipCode',
receiver_country_code: 'countryCode',
receiver_province: 'province',
receiver_city: 'city',
receiver_area: 'area',
receiver_town: 'town',
receiver_detail_address: 'detailAddress',
receiver_id: 'id',
receiver_name: [ 'name', '收件人姓名' ],
receiver_tel: [ 'tel', '固定电话' ],
receiver_mobile: [ 'mobile', '移动电话' ],
receiver_company: [ 'company', '公司名称' ],
receiver_email: [ 'email', '电子邮箱' ],
receiver_zip_code: [ 'zipCode', '邮编' ],
receiver_country_code: [ 'countryCode', '国家' ],
receiver_province: [ 'province', '省份' ],
receiver_city: [ 'city', '城市' ],
receiver_area: [ 'area', '区县' ],
receiver_town: [ 'town', '镇街道' ],
receiver_detail_address: [ 'detailAddress', '详细地址' ],
receiver_id: [ 'receiver_id', '证件号' ],
};
for (const [ column, param ] of Object.entries(receiverFieldMap)) {
for (const [ column, [ param, label ]] of Object.entries(receiverFieldMap)) {
if (data[param] !== undefined) {
updateData[column] = data[param] === null
? null
: String(data[param]).trim() || null;
changedLabels.push(label);
}
}
@ -744,14 +1034,19 @@ class StorageStockoutService extends MainService {
updateData.express_code = null;
updateData.express_name = null;
}
changedLabels.push('快递编码');
}
// 来源平台:传入才更新,空串置 NULL
if (data.source_platform_code !== undefined) {
updateData.source_platform_code = String(data.source_platform_code || '').trim() || null;
changedLabels.push('来源平台');
}
if (data.source_platform_name !== undefined) {
updateData.source_platform_name = String(data.source_platform_name || '').trim() || null;
if (!changedLabels.includes('来源平台')) {
changedLabels.push('来源平台');
}
}
// 修改后的收货信息完整性校验:name、(tel/mobile) 其一、省市区镇详细地址必填,缺失禁止提交
@ -791,6 +1086,14 @@ class StorageStockoutService extends MainService {
await ctx.model.OrderStockout.update(updateData, { where: { id: order.id } });
const updated = await ctx.model.OrderStockout.findByPk(order.id, { raw: true });
if (changedLabels.length > 0) {
await this._writeStockoutOperationLog(
order,
'STOCKOUT_UPDATE_INFO',
`修改出库单信息:${changedLabels.join('、')}`
);
}
return this.success('修改成功', updated);
}
}

View File

@ -319,6 +319,19 @@ class operationLogService extends Service {
return await this.queryLogsByBusinessType(query, 'entry_order');
}
/**
* 查询出库单操作日志。
* @param {Object} query 查询参数。
* @param {string|number} query.id 出库单ID。
* @param {string|number} query.warehouseId 仓库ID。
* @param {number} [query.page=1] 页码。
* @param {number} [query.pageSize=20] 每页数量。
* @return {Promise<{list: Object[], pagination: Object}>} 分页结果。
*/
async queryStockoutLogs(query = {}) {
return await this.queryLogsByBusinessType(query, 'stockout');
}
async getMessageDetail(data) {
const { id, type } = data;
const { ctx } = this;

View File

@ -5,6 +5,7 @@ const MainService = require('../main');
const CREATE_CHANNEL_QM = 'QM';
const CREATE_CHANNEL_MANUAL = 'MANUAL';
const CREATE_CHANNEL_API = 'API';
const CREATE_CHANNEL_STOCKOUT = 'STOCKOUT';
const RETRYABLE_DATABASE_ERROR_CODES = new Set([ 1205, 1213, 'ER_LOCK_WAIT_TIMEOUT', 'ER_LOCK_DEADLOCK' ]);
const TRANSACTION_LOCK_RETRY_MAX_ATTEMPTS = 3;
const TRANSACTION_LOCK_RETRY_BASE_DELAY_MS = 50;
@ -935,6 +936,638 @@ async function finalizeLocalChannelOrdersInternal(service, createChannel, groupe
};
}
/**
* 构建出库单确认回传数据(taobao.qimen.stockout.confirm / OpenAPI 回调共用)。
*
* 快递信息取订单侧实际发货信息:物流编码优先订单 sys_logistics_code → logistics_code →
* 出库单 express_code;运单号来自 wms_order_express 表(waybillCodes)。
*
* @param {Object} service 服务实例
* @param {Object} stockoutOrder 出库单主表记录(raw)
* @param {Object} orderRow 订单主表记录(raw)
* @param {Array} stockoutItems 出库单明细(raw 数组)
* @param {Array} [waybillCodes] 运单号列表
* @return {Object} 出库单确认回传请求体
*/
function buildStockoutConfirmDataInternal(service, stockoutOrder, orderRow, stockoutItems, waybillCodes = []) {
const now = service.app.formatDate(new Date());
// STOCKOUT 渠道运单号只认 wms_order_express 表(分配快递号时写入),
// 不回退订单主表 express_code(该字段是面单号前置,不是完整运单号)
const normalizedWaybillCodes = (Array.isArray(waybillCodes) ? waybillCodes : [])
.map(code => String(code || '').trim())
.filter(code => !!code);
const expressCode = String(
orderRow.sys_logistics_code
|| orderRow.logistics_code
|| stockoutOrder.express_code
|| 'OTHER'
).trim();
const expressName = String(
orderRow.sys_logistics_name
|| orderRow.logistics_name
|| stockoutOrder.express_name
|| 'OTHER'
).trim();
const stockoutOrderCode = String(stockoutOrder.stockout_order_code || '').trim();
const packageCode = String(orderRow.package_code || '').trim() || stockoutOrderCode;
const orderLines = (Array.isArray(stockoutItems) ? stockoutItems : []).map(item => {
const planQty = Number(item.plan_qty) || 0;
const actualQty = Number(item.actual_qty) || planQty;
return {
orderLineNo: String(item.order_line_no || '').trim(),
ownerCode: String(item.owner_code || stockoutOrder.qimen_owner_code || '').trim(),
itemCode: String(item.item_code || '').trim(),
itemId: item.item_id,
itemName: String(item.item_name || '').trim(),
planQty,
actualQty,
inventoryType: String(item.inventory_type || 'ZP').trim(),
};
});
return {
deliveryOrder: {
totalOrderLines: Number(stockoutOrder.total_order_lines) || orderLines.length,
deliveryOrderCode: stockoutOrderCode,
deliveryOrderId: Number(stockoutOrder.id) || undefined,
warehouseCode: String(stockoutOrder.qimen_warehouse_code || '').trim(),
orderType: String(stockoutOrder.order_type || '').trim(),
status: 'DELIVERED',
outBizCode: stockoutOrderCode,
confirmType: 0,
orderConfirmTime: now,
operatorCode: '',
operatorName: '',
},
packages: {
package: normalizedWaybillCodes.map(waybillCode => ({
logisticsCode: expressCode,
logisticsName: expressName,
expressCode: waybillCode,
packageCode,
items: orderLines.map(line => ({
itemCode: line.itemCode,
itemId: line.itemId,
quantity: line.actualQty,
})),
})),
},
orderLines,
};
}
/**
* 通知外部出库单确认结果(按出库单 source_type 分流)。
*
* - QM:奇门 taobao.qimen.stockout.confirm,flag=success 视为成功;
* - API:OpenAPI 签名回调(event=stockout_completed);
* - 其他(WMS 等内部来源):无需通知外部,直接视为成功。
*
* @param {Object} service 服务实例
* @param {Object} stockoutOrder 出库单主表记录(raw)
* @param {Object} requestData 出库单确认回传请求体
* @param {Object} [context] 上下文(含 appKey)
* @return {Promise<{success: boolean, message: string}>} 通知结果
*/
async function notifyStockoutExternalInternal(service, stockoutOrder, requestData, context = {}) {
const { ctx, app } = service;
const sourceType = String(stockoutOrder.source_type || 'QM').trim().toUpperCase();
if (sourceType === 'QM') {
if (!app.qimenClient || typeof app.qimenClient.send !== 'function') {
return { success: false, message: '奇门客户端未初始化' };
}
if (!stockoutOrder.qimen_owner_code) {
return { success: false, message: '出库单缺少奇门货主编码' };
}
try {
const sendResult = await app.qimenClient.send(
'taobao.qimen.stockout.confirm',
stockoutOrder.qimen_owner_code,
requestData,
{ ctx }
);
const response = (sendResult && sendResult.xmlArray && sendResult.xmlArray.response)
? (Array.isArray(sendResult.xmlArray.response) ? sendResult.xmlArray.response[0] : sendResult.xmlArray.response)
: {};
const flag = String(response.flag || '').trim();
if (flag === 'success') {
return { success: true, message: '' };
}
return {
success: false,
message: `${response.code || ''} ${response.message || '奇门出库单确认失败'}`.trim(),
};
} catch (error) {
return { success: false, message: error.message || '奇门出库单确认异常' };
}
}
if (sourceType === 'API') {
const callbackService = ctx.service.openapi && ctx.service.openapi.callback;
const appKey = String(context.appKey || '').trim();
if (!callbackService || typeof callbackService.sendByAppKey !== 'function') {
return { success: false, message: 'OpenAPI 回调服务未初始化' };
}
if (!appKey) {
return { success: false, message: '缺少 appKey,无法回传出库单' };
}
try {
const callbackResult = await callbackService.sendByAppKey({
appKey,
event: 'stockout_completed',
data: {
stockoutOrderCode: stockoutOrder.stockout_order_code,
status: 'completed',
...requestData,
},
metadata: {
warehouseId: Number(stockoutOrder.warehouse_id) || 0,
storeId: Number(stockoutOrder.store_id) || 0,
sourceType,
},
});
if (callbackResult && callbackResult.success === true) {
return { success: true, message: '' };
}
return {
success: false,
message: String(callbackResult && callbackResult.error || 'OpenAPI 回传失败').trim(),
};
} catch (error) {
return { success: false, message: error.message || 'OpenAPI 回传异常' };
}
}
// WMS 等内部来源:无需通知外部
return { success: true, message: '' };
}
/**
* 出库单回传成功后的收尾:
* 同一事务内 ① 写回出库单快递信息并推进 COMPLETED/SUCCESS;
* ② 按订单明细扣减库存(outbound,自动释放订单锁定);③ 订单 sync_status=fin。
*
* @param {Object} service 服务实例
* @param {Object} orderModel 订单模型
* @param {Object} orderItemsModel 订单明细模型
* @param {number} orderId 订单ID
* @param {number} warehouseId 仓库ID
* @param {Object} stockoutOrder 出库单记录(raw)
* @param {Object} expressWriteback 出库单快递写回字段
* @param {Object} [orderRow] 订单记录(raw)
* @return {Promise<void>} 失败抛异常
*/
async function finalizeSuccessfulStockoutSyncInternal(service, orderModel, orderItemsModel, orderId, warehouseId, stockoutOrder, expressWriteback, orderRow = null) {
const stockStoreService = service.ctx.service && service.ctx.service.systems && service.ctx.service.systems.stockStore;
if (!service.ctx.model || typeof service.ctx.model.transaction !== 'function') {
throw new Error('事务能力未初始化');
}
if (!stockStoreService || typeof stockStoreService.outbound !== 'function') {
throw new Error('库存出库服务未初始化');
}
await runTransactionWithLockRetryInternal(service, 'finalizeSuccessfulStockoutSync', async transaction => {
let resolvedOrderRow = orderRow;
if (orderModel && typeof orderModel.findOne === 'function') {
resolvedOrderRow = await orderModel.findOne({
where: {
id: orderId,
warehouse_id: warehouseId,
},
attributes: [ 'id', 'delivery_order_code', 'order_type', 'source_order_codes', 'sync_status' ],
lock: transaction.LOCK.UPDATE,
raw: true,
transaction,
});
}
const stockoutUpdate = {
...expressWriteback,
order_status: 'COMPLETED',
sync_status: 'SUCCESS',
sync_message: '',
updated_at: new Date(),
};
// 防重:订单已完成同步(并发重试触发),仅补齐出库单写回后跳过扣减
if (resolvedOrderRow && String(resolvedOrderRow.sync_status || '').trim() === 'fin') {
await service.ctx.model.OrderStockout.update(stockoutUpdate, {
where: { id: stockoutOrder.id },
transaction,
});
service.ctx.logger.info(`[order_async] 订单已完成同步,跳过重复出库 orderId=${orderId}`);
return;
}
const freshOrderItems = await orderItemsModel.findAll({
where: { order_id: orderId },
raw: true,
transaction,
});
for (const orderItem of Array.isArray(freshOrderItems) ? freshOrderItems : []) {
const itemId = Number(orderItem && orderItem.item_id);
const quantity = resolveQimenSyncItemQuantityInternal(orderItem);
if (!Number.isFinite(itemId) || itemId <= 0 || quantity <= 0) {
continue;
}
const stockId = Number(orderItem && orderItem.stock_id) || 0;
const outboundResult = await stockStoreService.outbound(itemId, quantity, transaction, {
orderId: Number(resolvedOrderRow && resolvedOrderRow.id) || Number(orderId) || null,
orderNo: String(resolvedOrderRow && resolvedOrderRow.delivery_order_code || '').trim() || null,
orderItemId: Number(orderItem && (orderItem.id || orderItem.order_item_id)) || null,
sourceOrderCodes: String(resolvedOrderRow && resolvedOrderRow.source_order_codes || '').trim() || undefined,
}, { stockId: stockId > 0 ? stockId : undefined });
if (!outboundResult || outboundResult.success !== true) {
throw new Error(String(outboundResult && outboundResult.error || `订单${orderId}库存扣减失败`).trim());
}
}
// 写回出库单快递信息 + 状态推进
await service.ctx.model.OrderStockout.update(stockoutUpdate, {
where: { id: stockoutOrder.id },
transaction,
});
await orderModel.update({
sync_status: 'fin',
inspection_status: 'padding',
step: 2,
order_flag: '',
updated_at: new Date(),
}, {
where: {
id: orderId,
warehouse_id: warehouseId,
status: {
[service.app.Sequelize.Op.ne]: 'cancel',
},
},
transaction,
});
});
}
/**
* 单个 STOCKOUT 订单回传处理:
* 反查出库单 → 收集订单实际快递信息 → 通知外部 → 成功后写回出库单并扣库存完成同步;
* 失败时订单 sync_status=error 并标记待处理异常,出库单 sync_status=FAILED 记录失败原因。
*
* @param {Object} service 服务实例
* @param {Object} orderModel 订单模型
* @param {Object} orderItemsModel 订单明细模型
* @param {number} orderId 订单ID
* @param {number} warehouseId 仓库ID
* @param {Object} orderRow 订单记录(raw)
* @param {Array} orderItems 订单明细(raw 数组)
* @param {Object} [context] 上下文
* @param {Array} [waybillCodes] 运单号列表
* @return {Promise<Object>} 处理结果
*/
async function processStockoutOrderInternal(service, orderModel, orderItemsModel, orderId, warehouseId, orderRow, orderItems, context = {}, waybillCodes = []) {
const { ctx } = service;
const deliveryOrderCode = String(orderRow && orderRow.delivery_order_code || '').trim();
const buildFailure = (message, extra = {}) => ({
order_id: orderId,
delivery_order_code: deliveryOrderCode,
status: 'failed',
message,
...extra,
});
if (!orderRow) {
return buildFailure('发货单不存在');
}
// 反查出库单:订单 source_order_codes 的首个来源单号(转订单时为出库单号),
// 兜底取订单明细 source_order_code
const sourceOrderCodes = String(orderRow.source_order_codes || '')
.split(',')
.map(code => String(code || '').trim())
.filter(code => !!code);
const sourceItem = Array.isArray(orderItems)
? orderItems.find(item => item && String(item.source_order_code || '').trim())
: null;
const itemSourceOrderCode = String(sourceItem && sourceItem.source_order_code || '').trim();
const stockoutOrderCode = String(sourceOrderCodes[0] || itemSourceOrderCode || '').trim();
if (!stockoutOrderCode) {
const message = '出库单转订单回传失败:未找到订单来源出库单号';
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
const stockoutOrder = await ctx.model.OrderStockout.findOne({
where: {
stockout_order_code: stockoutOrderCode,
warehouse_id: warehouseId,
deleted_at: null,
},
raw: true,
});
if (!stockoutOrder) {
const message = `出库单转订单回传失败:出库单(${stockoutOrderCode})不存在`;
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
// 幂等:出库单已完成同步(并发/重试场景),跳过外部通知,直接收尾
if (String(stockoutOrder.sync_status || '').trim() === 'SUCCESS') {
service.ctx.logger.info(`[syncStockoutOrders] 出库单已完成同步,跳过通知直接收尾 stockoutOrderCode=${stockoutOrderCode}`);
try {
await finalizeSuccessfulStockoutSyncInternal(service, orderModel, orderItemsModel, orderId, warehouseId, stockoutOrder, {}, orderRow);
return {
order_id: orderId,
delivery_order_code: deliveryOrderCode,
status: 'success',
message: '出库单已同步,订单收尾完成',
};
} catch (error) {
const message = `出库单回传后收尾失败:${error.message}`;
await orderModel.update({
sync_status: 'error',
order_flag: message,
updated_at: new Date(),
}, {
where: { id: orderId, warehouse_id: warehouseId },
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
}
// 运单号校验:订单未分配运单号时无法回传出库单
// STOCKOUT 渠道运单号只认 wms_order_express 表,不回退订单主表 express_code(面单号前置)
const normalizedWaybillCodes = (Array.isArray(waybillCodes) ? waybillCodes : [])
.map(code => String(code || '').trim())
.filter(code => !!code);
if (normalizedWaybillCodes.length === 0) {
const message = '出库单转订单回传失败:订单未分配运单号';
await orderModel.update({
sync_status: 'error',
order_flag: message,
updated_at: new Date(),
}, {
where: { id: orderId, warehouse_id: warehouseId },
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
const stockoutItems = await ctx.model.OrderStockoutItems.findAll({
where: { order_id: stockoutOrder.id },
order: [[ 'id', 'ASC' ]],
raw: true,
});
// 快递信息写回字段(回传成功落库):物流编码/名称 + 运单号列表
const expressWriteback = {
waybill_code: normalizedWaybillCodes[0] || '',
waybill_codes: normalizedWaybillCodes,
express_code: String(
orderRow.sys_logistics_code
|| orderRow.logistics_code
|| stockoutOrder.express_code
|| ''
).trim(),
express_name: String(
orderRow.sys_logistics_name
|| orderRow.logistics_name
|| stockoutOrder.express_name
|| ''
).trim(),
};
// 通知外部(奇门 stockout.confirm / OpenAPI 回调,按出库单 source_type 分流)
const requestData = buildStockoutConfirmDataInternal(service, stockoutOrder, orderRow, stockoutItems, normalizedWaybillCodes);
const notifyResult = await notifyStockoutExternalInternal(service, stockoutOrder, requestData, {
...context,
appKey: String(context.appKey || orderRow.from_key || '').trim(),
});
if (!notifyResult || notifyResult.success !== true) {
const message = `出库单转订单回传失败:${String(notifyResult && notifyResult.message || '通知外部失败').trim()}`;
await orderModel.update({
sync_status: 'error',
order_flag: message,
updated_at: new Date(),
}, {
where: { id: orderId, warehouse_id: warehouseId },
});
await ctx.model.OrderStockout.update({
sync_status: 'FAILED',
sync_message: message,
updated_at: new Date(),
}, {
where: { id: stockoutOrder.id },
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
try {
await finalizeSuccessfulStockoutSyncInternal(
service,
orderModel,
orderItemsModel,
orderId,
warehouseId,
stockoutOrder,
expressWriteback,
orderRow
);
} catch (error) {
const message = `出库单回传后库存扣减失败:${error.message}`;
await orderModel.update({
sync_status: 'error',
order_flag: message,
updated_at: new Date(),
}, {
where: { id: orderId, warehouse_id: warehouseId },
});
await markPendingExceptionInternal(service, orderModel, orderId, warehouseId, message);
return buildFailure(message);
}
service.ctx.logger.info(`[syncStockoutOrders] 出库单回传成功 stockoutOrderCode=${stockoutOrderCode} orderId=${orderId}`);
return {
order_id: orderId,
delivery_order_code: deliveryOrderCode,
status: 'success',
message: '出库单回传成功',
};
}
/**
* STOCKOUT 创建渠道订单同步入口。
*
* 从待处理订单同步入口(syncOrderIds)按 create_channel 分组路由到本函数:
* 反查对应出库单,把订单实际快递编码/运单号写回出库单并通知外部
* (QM→奇门 stockout.confirm,API→OpenAPI 回调),成功后才扣减库存完成同步。
*
* @param {Object} service 服务实例
* @param {Object} groupedOrder 分组后的订单
* @param {Object} context 上下文
* @return {Promise<Object>} 同步结果
*/
async function syncStockoutOrdersInternal(service, groupedOrder = {}, context = {}) {
const orderIds = Array.isArray(groupedOrder.order_ids)
? groupedOrder.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
: [];
const warehouseId = Number(context.warehouseId || 0);
if (orderIds.length === 0) {
return {
create_channel: CREATE_CHANNEL_STOCKOUT,
order_ids: [],
order_count: 0,
warehouse_id: warehouseId,
handler: 'syncStockoutOrders',
sync_target: 'stockout',
orders: [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: 'STOCKOUT 同步订单不能为空',
success_count: 0,
failed_count: 0,
};
}
if (warehouseId <= 0) {
return {
create_channel: CREATE_CHANNEL_STOCKOUT,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncStockoutOrders',
sync_target: 'stockout',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: [],
route_state: 'rejected',
status: 'failed',
message: '缺少仓库上下文',
success_count: 0,
failed_count: orderIds.length,
};
}
const orderModel = await service.ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const orderItemsModel = await service.ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const { Op } = service.app.Sequelize;
const [ orderRows, orderItemRows ] = await Promise.all([
orderModel.findAll({
where: {
id: {
[Op.in]: orderIds,
},
warehouse_id: warehouseId,
},
raw: true,
}),
orderItemsModel.findAll({
where: {
order_id: {
[Op.in]: orderIds,
},
},
raw: true,
}),
]);
const orderMap = new Map();
for (const orderRow of Array.isArray(orderRows) ? orderRows : []) {
if (orderRow && Number(orderRow.id) > 0) {
if (String(orderRow.sync_status || '').trim() === 'fin') {
service.ctx.logger.info(`[syncStockoutOrders] 订单已完成同步,跳过派发 orderId=${orderRow.id}`);
continue;
}
orderMap.set(Number(orderRow.id), orderRow);
}
}
const waybillCodeMap = await buildOrderWaybillCodeMapInternal(service, orderIds);
const itemsByOrderId = new Map();
for (const orderItem of Array.isArray(orderItemRows) ? orderItemRows : []) {
const itemOrderId = Number(orderItem && orderItem.order_id);
if (!Number.isFinite(itemOrderId) || itemOrderId <= 0) {
continue;
}
if (!itemsByOrderId.has(itemOrderId)) {
itemsByOrderId.set(itemOrderId, []);
}
itemsByOrderId.get(itemOrderId).push(orderItem);
}
const progressCacheKey = getSyncOrderIdsProgressCacheKey(context.request_id);
const uniqueOrderIds = [ ...new Set(orderIds) ];
const syncResults = [];
for (let i = 0; i < uniqueOrderIds.length; i += DISPATCH_BATCH_SIZE) {
const batch = uniqueOrderIds.slice(i, i + DISPATCH_BATCH_SIZE);
const batchResults = await Promise.all(batch.map(orderId => {
const dispatchedOrderRow = orderMap.get(orderId);
if (!dispatchedOrderRow) {
service.ctx.logger.info(`[syncStockoutOrders] 订单已过滤,跳过 orderId=${orderId}`);
return { order_id: orderId, status: 'skipped', message: '订单已完成同步,跳过' };
}
return processStockoutOrderInternal(
service,
orderModel,
orderItemsModel,
orderId,
warehouseId,
dispatchedOrderRow,
itemsByOrderId.get(orderId) || [],
context,
waybillCodeMap.get(orderId)
);
}));
syncResults.push(...batchResults);
await updateDispatchBatchProgress(service, progressCacheKey, batchResults.length);
}
const successCount = syncResults.filter(item => item.status === 'success').length;
const failedCount = syncResults.filter(item => item.status === 'failed').length;
const overallSuccess = failedCount === 0 && successCount === syncResults.length;
return {
create_channel: CREATE_CHANNEL_STOCKOUT,
order_ids: orderIds,
order_count: Number.isFinite(Number(groupedOrder.order_count)) ? Number(groupedOrder.order_count) : orderIds.length,
warehouse_id: warehouseId,
handler: 'syncStockoutOrders',
sync_target: 'stockout',
orders: Array.isArray(groupedOrder.orders) ? groupedOrder.orders.map(order => ({ ...order })) : [],
sync_results: syncResults,
route_state: overallSuccess ? 'accepted' : 'rejected',
status: overallSuccess ? 'success' : 'failed',
message: overallSuccess ? '出库单回传成功' : '出库单回传失败',
success_count: successCount,
failed_count: failedCount,
};
}
function buildManualSyncNoticePayloadInternal(syncResult = {}, context = {}) {
const orderIds = Array.isArray(syncResult.order_ids)
? syncResult.order_ids.map(orderId => Number(orderId)).filter(orderId => Number.isFinite(orderId) && orderId > 0)
@ -1825,6 +2458,20 @@ class OrderAsyncService extends MainService {
async syncApiOrders(groupedOrder = {}, context = {}) {
return await finalizeLocalChannelOrdersInternal(this, CREATE_CHANNEL_API, groupedOrder, context, 'api');
}
/**
* STOCKOUT 创建入口处理(出库单转订单回传)。
*
* 回传时把订单实际快递编码/运单号写回出库单,并按出库单来源通知外部
* (QM→奇门 stockout.confirm,API→OpenAPI 回调),成功后才扣减库存完成同步。
*
* @param {Object} groupedOrder 分组后的订单。
* @param {Object} context 上下文。
* @return {Promise<Object>} 处理结果。
*/
async syncStockoutOrders(groupedOrder = {}, context = {}) {
return await syncStockoutOrdersInternal(this, groupedOrder, context);
}
}
module.exports = OrderAsyncService;

View File

@ -587,12 +587,26 @@ class OrderPackingService extends Service {
const updates = { end_time: finalEndTime };
// 若任务状态不是已完成(2),同步更新为已完成
if (record.status !== 2) {
const wasFinished = record.status === 2;
if (!wasFinished) {
updates.status = 2;
}
await record.update(updates);
// 任务由未结束转为已完成时,同步更新关联订单打包状态(与 workbench.finishPack 语义一致)
if (!wasFinished && updates.status === 2 && workbenchService
&& typeof workbenchService._updateOrderPackStatus === 'function') {
const isGroupTask = Number(record.pack_mode) === 2;
const taskWaveId = isGroupTask ? Number(record.wave_id || 0) : 0;
await workbenchService._updateOrderPackStatus(warehouseId, {
orderId: Number(record.order_id || 0),
waveId: taskWaveId,
packStatus: 2,
caller: 'OrderPacking.setEndTime',
});
}
return {
code: 200,
message: '结束时间设置成功',

View File

@ -1568,7 +1568,8 @@ class OrderStorageAllocationService extends MainService {
* 待处理订单同步入口。
*
* 先完成订单查询、过滤与分组,再按 `create_channel` 路由到
* `orderAsync.syncQmOrders`、`orderAsync.syncManualOrders`、`orderAsync.syncApiOrders` 三个处理入口。
* `orderAsync.syncQmOrders`、`orderAsync.syncManualOrders`、`orderAsync.syncApiOrders`、
* `orderAsync.syncStockoutOrders` 四个处理入口。
*
* @param {Object} data 请求体。
* @return {Promise<Object>} 同步结果。
@ -1966,6 +1967,10 @@ class OrderStorageAllocationService extends MainService {
result = await orderAsyncService.syncQmOrders(groupedOrder, routeContext);
} else if (createChannel === 'API') {
result = await orderAsyncService.syncApiOrders(groupedOrder, routeContext);
} else if (createChannel === 'STOCKOUT') {
// 出库单转订单渠道:回传时把快递编码/运单号写回出库单并通知外部,
// 成功后才完成订单同步
result = await orderAsyncService.syncStockoutOrders(groupedOrder, routeContext);
} else {
result = await orderAsyncService.syncManualOrders(groupedOrder, routeContext);
}

View File

@ -292,6 +292,14 @@ const WAREHOUSE_SETTING_FIELDS = Object.freeze([
description: '团购打包最大时长,单位:分钟,默认 40',
min: 1,
}),
Object.freeze({
key: 'default_location_id',
name: '默认库位',
type: 'location',
default: null,
required: false,
description: '仓库未指定库位入库/上架时使用的默认库位(库位ID)',
}),
Object.freeze({
key: INTERNAL_WAVE_STRATEGY_VERSION_KEY,
name: '仓库波次策略版本号',
@ -560,6 +568,47 @@ class SettingWarehouseService extends Service {
};
}
/**
* 校验默认库位是否属于当前仓库。
*
* 传入的 default_location_id 为库位ID(wms_location_space.id),仅当该库位
* 属于当前仓库且未删除、已启用时才允许写入。
*
* @param {*} locationIdValue 待校验的库位ID。
* @param {number} warehouseId 当前仓库 ID。
* @return {Promise<void>} 无返回值。
* @throws {Error} 库位ID非法或不属于当前仓库时抛出,状态码 400。
*/
async validateDefaultLocation(locationIdValue, warehouseId) {
if (locationIdValue === undefined || locationIdValue === null || locationIdValue === '') {
return;
}
const locationId = Number(locationIdValue);
if (!Number.isInteger(locationId) || locationId <= 0) {
throw this.createError('default_location_id 必须是正整数库位ID', 400);
}
const locationModel = this.ctx && this.ctx.model && this.ctx.model.LocationSpace;
if (!locationModel || typeof locationModel.findOne !== 'function') {
return;
}
const locationSpace = await locationModel.findOne({
where: {
id: locationId,
warehouse_id: warehouseId,
is_enabled: true,
deleted_at: null,
},
attributes: [ 'id' ],
});
if (!locationSpace) {
throw this.createError(`默认库位 ${locationId} 不属于当前仓库`, 400);
}
}
/**
* 修改当前仓库设置并清理当前仓库缓存。
*
@ -589,6 +638,11 @@ class SettingWarehouseService extends Service {
throw this.createError('subject_config 参数不能为空且必须是对象', 400);
}
// 默认库位必须属于当前仓库(值为库位ID)
if (Object.prototype.hasOwnProperty.call(nextPatch, 'default_location_id')) {
await this.validateDefaultLocation(nextPatch.default_location_id, warehouseId);
}
const nextPatchForMerge = {
...nextPatch,
};

View File

@ -1989,6 +1989,21 @@ class InventoryService extends Service {
const storeId = receiving.store_id;
// 默认库位:优先使用仓库设置 default_location_id,未设置则兜底库位 1
let defaultSpaceId = 1;
try {
const deliveryOrderService = ctx.service && ctx.service.systems && ctx.service.systems.deliveryOrder;
const subjectConfig = deliveryOrderService && typeof deliveryOrderService.getStoreSubjectConfig === 'function'
? await deliveryOrderService.getStoreSubjectConfig(warehouseId)
: null;
const configuredLocationId = Number(subjectConfig && subjectConfig.default_location_id || 0);
if (Number.isInteger(configuredLocationId) && configuredLocationId > 0) {
defaultSpaceId = configuredLocationId;
}
} catch (error) {
ctx.logger.warn('[inventory.directPutaway] 读取仓库默认库位失败,兜底库位 1: %s', error.message);
}
// ────────── 3. 检查货主配置:是否允许收货单直入库存 ──────────
const storeWarehouse = await ctx.model.StoreWarehouse.findOne({
where: { store_id: storeId, warehouse_id: warehouseId, warehouse_use_status: 1 },
@ -2210,8 +2225,8 @@ class InventoryService extends Service {
const qty = Number(detail.actual_quantity) || 0;
if (qty <= 0) continue;
// 收货明细有库位则按其库位入库,否则使用默认库位
const spaceId = Number(detail.space_id) > 0 ? Number(detail.space_id) : 1;
// 收货明细有库位则按其库位入库,否则使用仓库默认库位(未设置时兜底库位 1)
const spaceId = Number(detail.space_id) > 0 ? Number(detail.space_id) : defaultSpaceId;
const batchNo = detail.batch_number || entryOrderCode;
const productionDate = detail.production_date || null;
const expiryDate = detail.expiry_date || null;

View File

@ -2642,6 +2642,21 @@ class ReceivingService extends Service {
}
try {
// 默认库位:优先使用仓库设置 default_location_id,未设置则兜底库位 1
let defaultSpaceId = 1;
try {
const deliveryOrderService = ctx.service && ctx.service.systems && ctx.service.systems.deliveryOrder;
const subjectConfig = deliveryOrderService && typeof deliveryOrderService.getStoreSubjectConfig === 'function'
? await deliveryOrderService.getStoreSubjectConfig(warehouse_id)
: null;
const configuredLocationId = Number(subjectConfig && subjectConfig.default_location_id || 0);
if (Number.isInteger(configuredLocationId) && configuredLocationId > 0) {
defaultSpaceId = configuredLocationId;
}
} catch (error) {
ctx.logger.warn('[receiving.addDetail] 读取仓库默认库位失败,兜底库位 1: %s', error.message);
}
const defaultDetail = {
receiving_id,
product_name: '新商品',
@ -2657,7 +2672,7 @@ class ReceivingService extends Service {
production_date: null,
expiry_date: null,
remark: '',
space_id: 1,
space_id: defaultSpaceId,
creator_id,
};

View File

@ -353,6 +353,8 @@ class WorkbenchService extends Service {
const changeSummary = this._buildPackChangeSummary(packData);
const operationCode = isSandan === 1 ? 'ORDER_PACK' : 'ORDER_PACK_GROUP';
const isFinish = Number(packData && packData.status) >= 2;
const actionText = isFinish ? '打包完成' : '开始打包';
if (isSandan === 1) {
// 散单:写入单个订单操作日志
@ -363,7 +365,7 @@ class WorkbenchService extends Service {
operator,
extras: {
warehouseId,
message: `散单打包完成:${changeSummary}`,
message: `散单${actionText}:${changeSummary}`,
},
}]);
ctx.logger.info('[Workbench._writePackOperationLog] 散单操作日志已写入 orderId=%d', orderId);
@ -378,7 +380,7 @@ class WorkbenchService extends Service {
operator,
extras: {
warehouseId,
message: `打包完成:${changeSummary}`,
message: `${actionText}:${changeSummary}`,
},
}]);
return;
@ -394,13 +396,13 @@ class WorkbenchService extends Service {
operator,
extras: {
warehouseId,
message: `打包完成(波次 ${waveNo || waveId}):${changeSummary}`,
message: `${actionText}(波次 ${waveNo || waveId}):${changeSummary}`,
},
}]);
return;
}
const messagePrefix = `团购打包完成(波次 ${waveNo || waveId},共${waveOrderIds.length}单):`;
const messagePrefix = `${isFinish ? '团购打包完成' : '团购开始打包'}(波次 ${waveNo || waveId},共${waveOrderIds.length}单):`;
const payloads = waveOrderIds.map(oid => ({
businessType: 'order',
businessId: String(oid),
@ -426,6 +428,75 @@ class WorkbenchService extends Service {
}
}
/**
* 更新订单打包状态字段(散单按订单ID更新单笔,团购按波次批量更新)。
* 遍历 current + dispatch 分表,异常仅记录日志不影响主流程。
* 团购批量更新时跳过拦截订单(intercept_status 空值按 none 处理)。
*
* @param {number} warehouseId 仓库ID
* @param {Object} options
* @param {number} options.orderId 订单ID(散单使用)
* @param {number} options.waveId 波次ID(>0 时按团购批量更新)
* @param {number|string} options.packStatus 任务状态数值(1=打包中 2=已完成)
* @param {string} [options.caller] 调用方标识(仅用于日志)
* @returns {Promise<string>} 实际写入的 pack_status 值
*/
async _updateOrderPackStatus(warehouseId, { orderId, waveId, packStatus, caller = 'Workbench' }) {
const { ctx } = this;
const statusNum = parseInt(packStatus);
const orderPackStatus = statusNum >= 2 ? 'fin' : (statusNum === 1 ? 'padding' : 'fin');
const orderUpdateData = { pack_status: orderPackStatus };
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
if (waveId > 0) {
// 团购:批量更新波次下所有未拦截订单
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: {
wave_id: waveId,
warehouse_id: warehouseId,
intercept_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
},
});
if (affected[0] > 0) {
ctx.logger.info('[%s._updateOrderPackStatus] 团购批量更新订单打包状态 waveId=%d pack_status=%s table=%s affected=%d',
caller, waveId, orderPackStatus, entry.label, affected[0]);
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
}
}
} else {
// 散单:按订单ID更新单个订单
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: { id: orderId, warehouse_id: warehouseId },
});
if (affected[0] > 0) {
ctx.logger.info('[%s._updateOrderPackStatus] 更新订单打包状态 orderId=%d pack_status=%s table=%s',
caller, orderId, orderPackStatus, entry.label);
break;
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
}
}
}
return orderPackStatus;
}
/**
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录
* @param {Object} params - { delivery_order_code, wave_no, warehouse_id, workbench_id, status, pack_time }
@ -601,44 +672,13 @@ class WorkbenchService extends Service {
const packTask = await ctx.model.PackTask.create(packData);
ctx.logger.info('[Workbench._packOrder] 创建打包任务 taskId=%d orderId=%d', packTask.id, orderId);
// 步骤6.5:更新订单的打包状态字段
const orderPackStatus = (packStatus !== undefined && parseInt(packStatus) >= 2) ? 'fin'
: (packStatus !== undefined && parseInt(packStatus) === 1) ? 'padding'
: 'fin';
const orderUpdateData = { pack_status: orderPackStatus };
if (isSandan === 1) {
// 散单:更新单个订单
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: { id: orderId, warehouse_id: warehouseId },
});
if (affected[0] > 0) {
ctx.logger.info('[Workbench._packOrder] 更新订单打包状态 orderId=%d pack_status=%s table=%s',
orderId, orderPackStatus, entry.label);
break;
}
} catch (_err) { continue; }
}
} else if (waveId > 0) {
// 团购:批量更新波次下所有订单(拦截订单不更新)
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: { wave_id: waveId, warehouse_id: warehouseId, intercept_status: 'none' },
});
if (affected[0] > 0) {
ctx.logger.info('[Workbench._packOrder] 团购批量更新订单打包状态 waveId=%d pack_status=%s table=%s affected=%d',
waveId, orderPackStatus, entry.label, affected[0]);
}
} catch (_err) { continue; }
}
}
// 步骤6.5:更新订单的打包状态字段(散单按订单更新,团购按波次批量更新)
await this._updateOrderPackStatus(warehouseId, {
orderId,
waveId: isSandan === 1 ? 0 : waveId,
packStatus,
caller: 'Workbench._packOrder',
});
// 步骤7:写入打包人员信息
const users = Array.isArray(usersParam) ? usersParam : [];
@ -844,6 +884,37 @@ class WorkbenchService extends Service {
ctx.logger.info('[Workbench._finishPack] 工作台 %d 结束打包任务 taskId=%d orderId=%d',
validWorkbenchId, lastTask.id, lastTask.order_id);
// 同步更新关联订单打包状态:散单更新单笔订单,团购批量更新波次下所有未拦截订单
const isGroupTask = Number(lastTask.pack_mode) === 2;
const taskOrderId = Number(lastTask.order_id || 0);
const taskWaveId = isGroupTask ? Number(lastTask.wave_id || 0) : 0;
await this._updateOrderPackStatus(warehouseId, {
orderId: taskOrderId,
waveId: taskWaveId,
packStatus: 2,
caller: 'Workbench._finishPack',
});
// 写入完成操作日志(团购批量写波次订单,操作人取自任务记录 operator_text)
const operatorText = String(lastTask.operator_text || '');
await this._writePackOperationLog({
warehouseId,
orderId: taskOrderId,
waveId: taskWaveId,
waveNo: lastTask.wave_no || '',
isSandan: isGroupTask ? 0 : 1,
packData: {
pack_mode: lastTask.pack_mode,
status: 2,
pack_quantity: lastTask.pack_quantity,
item_quantity: lastTask.item_quantity,
sku_count: lastTask.sku_count,
workbench_id: validWorkbenchId,
wave_no: lastTask.wave_no,
},
users: operatorText ? [{ real_name: operatorText }] : [],
});
return {
workbench_id: validWorkbenchId,
finished: true,
@ -1203,13 +1274,24 @@ class WorkbenchService extends Service {
const { order_id: orderId, waybill_code: waybillCode } = expressRecord;
// 步骤2:遍历 current → dispatch 分表查找订单详情
// 步骤2:序列表定位优先(命中则先查对应分表),未命中按 current → dispatch 回退遍历
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
try {
if (orderDeliveryFactory && typeof orderDeliveryFactory.getOrderLocation === 'function') {
const preferredLocation = await orderDeliveryFactory.getOrderLocation(orderId, warehouseId);
if (preferredLocation) {
tableOrders.sort((a, b) => (a.label === preferredLocation ? -1 : b.label === preferredLocation ? 1 : 0));
}
}
} catch (locErr) {
ctx.logger.warn('[Workbench._queryOrder] 序列表定位失败,按默认顺序遍历: %s', locErr.message);
}
let orderRow = null;
let sourceTable = null;
for (const entry of tableOrders) {
@ -1375,6 +1457,7 @@ class WorkbenchService extends Service {
wave_no: orderRow.wave_no,
post_status: orderRow.post_status,
pick_status: orderRow.pick_status,
pack_status: orderRow.pack_status,
recheck_status: orderRow.recheck_status,
outbound_status: orderRow.outbound_status,
items_count: orderRow.items_count,

View File

@ -0,0 +1,58 @@
'use strict';
/**
* 为 storage.stockout.updateInfo 添加 API 权限并授权。
*
* 权限 ID(固定):563 — storage.stockout.updateInfo 修改出库单信息
* 授权角色:经理(8)、仓库组-主管(26)、客服组-主管(28)、生产组-主管(29)、客服组-员工(30)
*/
module.exports = {
up: async queryInterface => {
// ===== 第一步:写入权限行 =====
await queryInterface.sequelize.query(`
INSERT INTO wms_permission (id, path, component, name, redirect, meta_title, meta_icon, hidden, always_show, parent_id, type, sort, status, created_at, update_at)
VALUES (563, 'storage.stockout.updateInfo', NULL, 'storage.stockout.updateInfo', NULL, 'API:修改出库单信息', NULL, 0, 0, NULL, 'api', 0, 1, NOW(), NOW())
ON DUPLICATE KEY UPDATE path='storage.stockout.updateInfo', meta_title='API:修改出库单信息', type='api'
`);
// ===== 第二步:授权给经理及各主管/客服员工角色 =====
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_ARRAY_APPEND(permissions, '$', CAST(563 AS UNSIGNED)),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
AND JSON_VALID(permissions) = 1
AND JSON_CONTAINS(permissions, '563', '$') = 0
`);
}
},
down: async queryInterface => {
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_REMOVE(
permissions,
JSON_UNQUOTE(JSON_SEARCH(permissions, 'one', '563'))
),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
`);
}
await queryInterface.sequelize.query(`
DELETE FROM wms_permission WHERE id = 563
`);
},
};

View File

@ -0,0 +1,56 @@
'use strict';
/**
* 为 storage.stockout.cancel 添加 API 权限并授权。
*
* 权限 ID(固定):564 — storage.stockout.cancel 出库单取消
* 授权角色:经理(8)、仓库组-主管(26)、客服组-主管(28)、生产组-主管(29)、客服组-员工(30)
*/
module.exports = {
up: async queryInterface => {
await queryInterface.sequelize.query(`
INSERT INTO wms_permission (id, path, component, name, redirect, meta_title, meta_icon, hidden, always_show, parent_id, type, sort, status, created_at, update_at)
VALUES (564, 'storage.stockout.cancel', NULL, 'storage.stockout.cancel', NULL, 'API:出库单取消', NULL, 0, 0, NULL, 'api', 0, 1, NOW(), NOW())
ON DUPLICATE KEY UPDATE path='storage.stockout.cancel', meta_title='API:出库单取消', type='api'
`);
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_ARRAY_APPEND(permissions, '$', CAST(564 AS UNSIGNED)),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
AND JSON_VALID(permissions) = 1
AND JSON_CONTAINS(permissions, '564', '$') = 0
`);
}
},
down: async queryInterface => {
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_REMOVE(
permissions,
JSON_UNQUOTE(JSON_SEARCH(permissions, 'one', '564'))
),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
`);
}
await queryInterface.sequelize.query(`
DELETE FROM wms_permission WHERE id = 564
`);
},
};

View File

@ -0,0 +1,56 @@
'use strict';
/**
* 为 storage.stockout.listLogs 添加 API 权限并授权。
*
* 权限 ID(固定):565 — storage.stockout.listLogs 出库单操作日志查询
* 授权角色:经理(8)、仓库组-主管(26)、客服组-主管(28)、生产组-主管(29)、客服组-员工(30)
*/
module.exports = {
up: async queryInterface => {
await queryInterface.sequelize.query(`
INSERT INTO wms_permission (id, path, component, name, redirect, meta_title, meta_icon, hidden, always_show, parent_id, type, sort, status, created_at, update_at)
VALUES (565, 'storage.stockout.listLogs', NULL, 'storage.stockout.listLogs', NULL, 'API:出库单操作日志', NULL, 0, 0, NULL, 'api', 0, 1, NOW(), NOW())
ON DUPLICATE KEY UPDATE path='storage.stockout.listLogs', meta_title='API:出库单操作日志', type='api'
`);
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_ARRAY_APPEND(permissions, '$', CAST(565 AS UNSIGNED)),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
AND JSON_VALID(permissions) = 1
AND JSON_CONTAINS(permissions, '565', '$') = 0
`);
}
},
down: async queryInterface => {
const roleIds = [ 8, 26, 28, 29, 30 ];
for (const roleId of roleIds) {
await queryInterface.sequelize.query(`
UPDATE wms_role
SET permissions = JSON_REMOVE(
permissions,
JSON_UNQUOTE(JSON_SEARCH(permissions, 'one', '565'))
),
updated_at = NOW()
WHERE id = ${roleId}
AND permissions IS NOT NULL
AND permissions != '*'
AND permissions != '[]'
`);
}
await queryInterface.sequelize.query(`
DELETE FROM wms_permission WHERE id = 565
`);
},
};

View File

@ -1,4 +1,168 @@
[
{
"version": "2026.08.26-workbench-queryOrder-pack-status",
"date": "2026-08-26",
"type": "enhanced",
"summary": "工作台 workbench.business(queryOrder) 查询订单增强:接入订单序列表(wms_order_id_location_*)优先定位分表,未命中按 current→dispatch 回退遍历;响应 order 对象新增 pack_status 字段(散单/团购均返回)。",
"methods": [
"workbench.business"
],
"notes": [
"app/service/systems/workbench.js _queryOrder 步骤2:先经 orderDeliveryFactory.getOrderLocation(orderId, warehouseId) 获取序列表位置,命中则优先查对应分表,失败/未命中保持原 current→dispatch 遍历,与 _sendWeight/waybill/order_express 等模块的序列表优先定位语义一致",
"_queryOrder 响应 order 对象新增 pack_status(none/padding/fin/error),与 pick_status/recheck_status 等状态机并列,工作台可根据打包状态判断该单是否已打包",
"备注:_packOrder 订单查找仍按 delivery_order_code 双表遍历(序列表按 id 定位,发货单号场景暂不适用)"
],
"module": "workbench"
},
{
"version": "2026.08.26-finishPack-sync-order-pack-status",
"date": "2026-08-26",
"type": "fixed",
"summary": "修复打包任务结束事件不更新订单打包状态的问题:workbench.finishPack 结束任务后同步更新关联订单 pack_status 为 fin(散单按订单更新,团购按波次批量更新未拦截订单)并写完成操作日志;order.packing.setEndTime 手动结束同样同步订单;打包操作日志文案按任务状态区分(开始打包/打包完成),不再在开始打包时误写“打包完成”。",
"methods": [],
"notes": [
"问题定位:波次 B2026082503311(团购 7 单)开始打包时 packOrder(status=1) 写入的日志前缀硬编码为“团购打包完成”,实际尾部为“任务状态: 打包中”;设备结束事件走 finishPack 仅更新 wms_pack_task(end_time/status=2),未更新订单,导致订单 pack_status 停留在 padding",
"app/service/systems/workbench.js 新增 _updateOrderPackStatus:遍历 current+dispatch 分表,散单按 order_id 更新单笔,团购按 wave_id 批量更新(intercept_status 空值按 none 处理,拦截订单跳过),异常仅记日志不影响主流程;_packOrder 步骤6.5 改为复用该方法",
"app/service/systems/workbench.js _finishPack:任务结束后按 pack_mode 判定散单/团购,调用 _updateOrderPackStatus(packStatus=2) 同步订单,并按任务记录(含 operator_text 回填操作人)写入完成操作日志",
"app/service/systems/order_packing.js setEndTime:任务由未完成转为已完成时同样调用 _updateOrderPackStatus 同步订单,与 finishPack 语义对齐",
"app/service/systems/workbench.js _writePackOperationLog:日志前缀按 status 区分——status>=2 写“打包完成”,否则写“开始打包”,保留原有字段变更描述",
"定时任务 auto_finish_pack_task 超时自动结束仅关闭任务记录、不更新订单(保持原语义,避免超时误标订单完成),如需要可在后续版本评估同步"
],
"module": "workbench"
},
{
"version": "2026.08.26-stockout-listLogs",
"date": "2026-08-26",
"type": "added",
"summary": "新增 storage.stockout.listLogs 出库单操作日志查询接口:按出库单ID或出库单号分页查询 wms_operation_log(business_type=stockout,business_id=出库单ID),覆盖转订单/确认/修改/取消等 STOCKOUT_* 操作,按创建时间倒序;配套 operationLog.queryStockoutLogs 服务方法与权限 565。",
"methods": [
"storage.stockout.listLogs"
],
"notes": [
"app/service/systemMethods/storage/stockout.js 新增 listLogs:支持 id 或 stockout_order_code 定位(出库单号先查表换ID),pagination.page/pageSize(兼容 page_size);出库单不存在返回空列表不报错;仓库上下文取 ctx.user.store_id",
"app/service/systems/operation_log.js 新增 queryStockoutLogs:复用 queryLogsByBusinessType(query, 'stockout')",
"database/migrations/20260826100000-add-stockout-listLogs-permission.js:权限 565,授权角色 8/26/28/29/30,开发库已执行",
"storage.stockout.listItems 出库单明细接口此前已存在(按 stockout_order_code/id 查 wms_order_stockout_items),本次仅补 listLogs 文档",
"实测:listLogs 按 stockout_order_code 与 id=22 均返回分页日志(STOCKOUT_TO_ORDER/STOCKOUT_UPDATE_INFO,含操作人/时间/消息/平台名),pagination.total=4 正确;注意权限迁移后短时间内用户权限上下文缓存可能未刷新导致 403,刷新后正常"
],
"module": "storage.stockout"
},
{
"version": "2026.08.26-stockout-order-sync-channel",
"date": "2026-08-26",
"type": "added",
"summary": "订单回传区分 STOCKOUT 创建渠道:待处理订单同步入口(syncOrderIds)按 create_channel 路由新增 syncStockoutOrders,回传时把订单实际快递编码/运单号写回出库单(express_code/express_name/waybill_code/waybill_codes),并按出库单来源通知外部(QM→奇门 taobao.qimen.stockout.confirm,API→OpenAPI 回调 event=stockout_completed,WMS 内部来源直接成功);通知成功后才扣减订单库存并完成同步(sync_status=fin、出库单 COMPLETED/SUCCESS),失败则订单 sync_status=error 标记待处理异常、出库单 sync_status=FAILED 记录失败原因。",
"methods": [
"order.pendingOrder.syncOrderIds"
],
"notes": [
"app/service/systems/order_async.js 新增 syncStockoutOrders/syncStockoutOrdersInternal/processStockoutOrderInternal/notifyStockoutExternalInternal/buildStockoutConfirmDataInternal/finalizeSuccessfulStockoutSyncInternal:反查出库单(订单 source_order_codes 首项或明细 source_order_code),运单号仅认 wms_order_express 表(不回退订单主表 express_code 面单前置);收尾事务内写回出库单 + 订单明细 outbound 扣库存 + sync_status=fin,SELECT FOR UPDATE 防重幂等",
"app/service/systems/order_storage_allocation.js syncOrderIds 渠道路由新增 STOCKOUT 分支(原落入 MANUAL 兜底,不通知外部)",
"出库单已 SUCCESS 的重试场景跳过重复通知,直接收尾;订单未分配运单号时回传失败并提示",
"所有回传入口(pendingOrder.syncOrderIds 异步包装、express_platform 自动同步回传)均汇聚到同一路由,改动一处覆盖全部",
"订单表无 sync_message 列:回传失败提示落在 order_flag 字段(markPendingExceptionInternal 同步置 inspection_status=error/step=3)",
"实测失败路径:测试订单 122172(TEST-SO-20260826004828-003 转单)回传奇门 stockout.confirm 返回 JST_Error,订单 sync_status=error + order_flag 提示,出库单保持 TRANSFERRED + sync_status=FAILED + sync_message 记录原因",
"实测成功路径:出库单 source_type 临时改 WMS(内部来源直接成功)触发回传,订单 sync_status=fin/order_flag 清空/step=2,出库单 COMPLETED/SUCCESS + 写回 express_code=SF/waybill_code/waybill_codes,库存 101389 quantity 100→95、locked 8→3,流水闭环 LOCK(QM_STOCKOUT)→UNLOCK(转单释放)→LOCK(DELIVERY_ORDER)→OUTBOUND(订单出库)"
],
"module": "order.pendingOrder"
},
{
"version": "2026.08.26-stockout-cancel",
"date": "2026-08-26",
"type": "added",
"summary": "新增 storage.stockout.cancel 出库单取消:仅 CREATED/PENDING 允许取消;事务内释放创建时占用的库存锁定(QM_STOCKOUT,写 UNLOCK 流水)并置 CANCELLED,写 wms_operation_log 操作日志(STOCKOUT_CANCEL);TRANSFERRED/COMPLETED 禁止取消。新增权限 564 并授权。",
"methods": [
"storage.stockout.cancel"
],
"notes": [
"app/service/systemMethods/storage/stockout.js 新增 cancel:复用 lockItemStorages 负数量释放(锁定不足幂等跳过),与状态更新、操作日志同事务;仓库隔离与 confirm/updateInfo 一致",
"database/migrations/20260826093000-add-stockout-cancel-permission.js:权限 564,授权角色 8/26/28/29/30,开发库已执行",
"实测:取消测试单后 locked_quantity 101379 3→2,UNLOCK 流水(出库单取消释放锁定)与 STOCKOUT_CANCEL 操作日志均落库",
"同步更新 methods/system.json 新增 cancel 接口文档"
],
"module": "storage.stockout"
},
{
"version": "2026.08.26-stockout-operation-log",
"date": "2026-08-26",
"type": "added",
"summary": "storage.stockout 链路补写 wms_operation_log 操作日志(businessType=stockout):confirm 直出成功、toOrder 转单成功、updateInfo 修改均写操作记录;新增 updateInfo API 权限 563 并授权;修复 updateInfo 证件号参数名与出库单 ID 冲突。",
"methods": [
"storage.stockout.confirm",
"storage.stockout.toOrder",
"storage.stockout.updateInfo"
],
"notes": [
"app/service/systemMethods/storage/stockout.js 新增 _writeStockoutOperationLog(operationLog.createOperationLogs,失败仅告警不影响主流程):confirm 成功路径与状态更新同事务写 STOCKOUT_CONFIRM(含释放锁总量);toOrder 转单后写 STOCKOUT_TO_ORDER(含新订单号);updateInfo 写 STOCKOUT_UPDATE_INFO(含改动字段摘要)",
"修复:updateInfo 收件人证件号参数由 id 改为 receiver_id(原与出库单ID参数冲突,会把 data.id 误写入 receiver_id 字段)",
"database/migrations/20260826090000-add-stockout-updateInfo-permission.js:新增权限 563(storage.stockout.updateInfo),授权角色 8/26/28/29/30,开发库已执行",
"实测:updateInfo 修改后 wms_operation_log 落库(business_type=stockout、operation_code=STOCKOUT_UPDATE_INFO、operator 阿猫、message 含改动摘要)"
],
"module": "storage.stockout"
},
{
"version": "2026.08.26-stockout-confirm-release-lock",
"date": "2026-08-26",
"type": "fixed",
"summary": "storage.stockout.confirm 直出确认后释放出库单创建时占用的库存锁定:出站通知成功后,事务内逐明细 lockItemStorages(-plan_qty, orderType=QM_STOCKOUT) 释放锁定并自动写 UNLOCK 流水,与状态推进到 COMPLETED 同事务提交,失败回滚可重试;释放遇\"锁定不足\"视为幂等成功跳过。",
"methods": [
"storage.stockout.confirm"
],
"notes": [
"修复前:confirm 直出成功后 locked_quantity 一直占用(出库单无取消入口,锁只能靠转订单释放)",
"出站通知失败时锁保持、状态不变(sync_status=FAILED),重试 confirm 成功后才会释放;已释放场景(锁定不足)跳过不阻断",
"实测:本地 confirm 真实出站淘宝奇门返回 JST_Error 单号转换失败,锁保持(101379.locked=3/101389.locked=8 不变),符合设计;释放+UNLOCK 流水由 lockItemStorages 负数量链路保证"
],
"module": "storage.stockout"
},
{
"version": "2026.08.26-directPutaway-default-location",
"date": "2026-08-26",
"type": "updated",
"summary": "storage.inventory.directPutaway 默认库位改为读取仓库设置:直入库存写 wms_storage 时,收货明细 space_id 无效则使用 wms_store.subject_config.default_location_id(经 deliveryOrder.getStoreSubjectConfig 缓存优先读取),未设置时兜底库位 1。",
"methods": [
"storage.inventory.directPutaway"
],
"notes": [
"app/service/systems/storage/inventory.js directPutaway:步骤 10 写 wms_storage 的 spaceId 由硬编码 1 改为 defaultSpaceId(收货明细有库位仍按其库位),defaultSpaceId 在方法前段读取仓库设置(正整数有效才采用,否则 1),读取失败仅告警不影响入库",
"与 storage.receiving.addDetail 默认库位口径一致(仓库设置优先,兜底 1)",
"同步更新 methods/system.json directPutaway 的库位规则说明"
],
"module": "storage.inventory"
},
{
"version": "2026.08.26-receiving-addDetail-default-location",
"date": "2026-08-26",
"type": "updated",
"summary": "storage.receiving.addDetail 默认库位改为读取仓库设置:新增明细时 space_id 默认取 wms_store.subject_config.default_location_id(经 deliveryOrder.getStoreSubjectConfig 缓存优先读取),未设置时兜底库位 1;前端传入 item.space_id 时仍按传入值。",
"methods": [
"storage.receiving.addDetail"
],
"notes": [
"app/service/systems/storage/receiving.js addDetail:默认明细 space_id 由硬编码 1 改为优先读仓库设置 default_location_id(正整数有效才采用),否则兜底 1;读取失败仅告警不影响创建",
"依赖 deliveryOrder.getStoreSubjectConfig(缓存 10 分钟),saveSettings 保存仓库设置时会同步清理该缓存键",
"同步更新 methods/system.json addDetail 的 item.space_id 描述"
],
"module": "storage.receiving"
},
{
"version": "2026.08.26-warehouse-setting-default-location",
"date": "2026-08-26",
"type": "added",
"summary": "仓库设置(wms_store.subject_config)新增\"默认库位\"字段 default_location_id(type location):setting.warehouse.getFieldMeta 字段元信息新增该字段(不返回库位选项列表,库位数量大,前端按仓库搜索选择),saveSettings 传入时校验库位属于当前仓库,否则报 400 拒绝写入。",
"methods": [
"setting.warehouse.getFieldMeta",
"setting.warehouse.getSettings",
"setting.warehouse.saveSettings"
],
"notes": [
"app/service/systems/setting/warehouse.js WAREHOUSE_SETTING_FIELDS 新增 default_location_id(名称:默认库位,type location,default null,描述:仓库未指定库位入库/上架时使用的默认库位);getFieldMeta 不注入库位选项列表(库位数量大,前端按 type=location 自行按仓库搜索库位)",
"saveSettings 新增 validateDefaultLocation:传入 default_location_id 时校验其属于当前仓库,否则 400 '默认库位 {id} 不属于当前仓库';传 null/空清空",
"app/model/store.js DEFAULT_SUBJECT_CONFIG 新增 default_location_id: null;normalizeSubjectConfig 新增正整数校验分支(空值置 null)",
"同步更新 methods/system.json:getSettings 响应、saveSettings 参数补充 default_location_id 说明"
],
"module": "setting.warehouse"
},
{
"version": "2026.08.25-stockout-updateInfo-transferred",
"date": "2026-08-25",
@ -13,7 +177,8 @@
"数据库迁移 20260825180000-add-transferred-status-and-platform-to-wms-order-stockout.js:order_status ENUM 追加 TRANSFERRED + 新增 source_platform_code(50)/source_platform_name(200) 列,开发库已执行并核验",
"app/model/order_stockout.js:ENUM 补 TRANSFERRED、新增两平台字段、新增 isTransferred() 辅助方法",
"storage.stockout.toOrder:转单成功后 order_status 置 TRANSFERRED(原 CANCELLED);deliveryOrder.sourcePlatformCode 优先用出库单已存平台,为空走兜底平台;confirm(一键出库)经 canConfirm 拒绝 TRANSFERRED 状态",
"同步更新 methods/system.json:新增 updateInfo 接口文档,更新 toOrder 描述与状态说明"
"同步更新 methods/system.json:新增 updateInfo 接口文档,更新 toOrder 描述与状态说明",
"实测(2026-08-26,测试单 20):正常修改 name/mobile/detailAddress + express_code=SF(自动解析 express_name=顺丰速运)+ source_platform_code 均落库,未传字段不变;detailAddress 清空被拦截(收货信息缺失,禁止提交:缺少 detailAddress(详细地址));COMPLETED 单被拦截(不允许修改);操作日志 STOCKOUT_UPDATE_INFO 含改动字段摘要(收件人姓名、移动电话、详细地址、快递编码、来源平台);测试数据已恢复原貌、日志保留"
],
"module": "storage.stockout"
},

View File

@ -13939,6 +13939,12 @@
"type": "number",
"required": false,
"description": "团购打包最大时长,单位:分钟,默认 40"
},
{
"name": "subject_config.default_location_id",
"type": "number",
"required": false,
"description": "默认库位(库位ID,未配置时为 null)"
}
],
"errors": [
@ -14203,6 +14209,13 @@
"required": false,
"source": "body.subject_config",
"description": "团购打包最大时长,单位:分钟,默认 40,须为大于 0 的整数"
},
{
"name": "subject_config.default_location_id",
"type": "number",
"required": false,
"source": "body.subject_config",
"description": "默认库位(库位ID,须属于当前仓库且未删除、已启用,否则报 400;传 null 清空)"
}
],
"response": [
@ -21342,7 +21355,7 @@
{
"name": "space_id",
"type": "number",
"description": "库位 ID"
"description": "库位 ID;未传时默认使用仓库设置 subject_config.default_location_id,未设置则兜底库位 1"
},
{
"name": "system_product_id",
@ -23204,7 +23217,7 @@
"name": "list",
"type": "array",
"required": true,
"description": "出库单列表(wms_order_stockout 表记录,含 sync_status/sync_message 出站同步状态字段)"
"description": "出库单列表(wms_order_stockout 表记录,含 store_id/store_name 货主信息与 sync_status/sync_message 出站同步状态字段;不含 id、warehouse_id、warehouse_name)"
},
{
"name": "pagination",
@ -23361,6 +23374,79 @@
}
]
},
{
"method": "storage.stockout.listLogs",
"name": "出库单操作日志",
"description": "查询出库单操作日志(分页)。日志业务类型 business_type=stockout、business_id=出库单ID,覆盖转订单(STOCKOUT_TO_ORDER)、确认直出(STOCKOUT_CONFIRM)、修改信息(STOCKOUT_UPDATE_INFO)、取消(STOCKOUT_CANCEL)等操作。按创建时间倒序。",
"isNeedAuth": true,
"isNeedLogin": true,
"isNeedRight": false,
"headers": [
{
"name": "Authorization",
"type": "string",
"required": true,
"description": "Bearer token"
}
],
"params": [
{
"name": "id",
"type": "number",
"required": false,
"source": "body",
"description": "出库单ID;与 stockout_order_code 至少传一个"
},
{
"name": "stockout_order_code",
"type": "string",
"required": false,
"source": "body",
"description": "出库单号(推荐);与 id 至少传一个"
},
{
"name": "page",
"type": "number",
"required": false,
"source": "body",
"description": "页码(默认1);与订单日志接口一致,支持顶层传参"
},
{
"name": "pageSize",
"type": "number",
"required": false,
"source": "body",
"description": "每页数量(默认20,兼容 page_size)"
},
{
"name": "pagination",
"type": "object",
"required": false,
"source": "body",
"description": "分页对象写法({ page, pageSize }),与顶层 page/pageSize 二选一,顶层优先"
}
],
"response": [
{
"name": "data.list",
"type": "array",
"required": true,
"description": "操作日志列表(含 operation_code/operation_name/operator_name/message/created_at 等,与订单日志字段一致)"
},
{
"name": "data.pagination",
"type": "object",
"required": true,
"description": "分页信息 { page, pageSize, total, totalPages }"
}
],
"errors": [
{
"code": "400",
"description": "id 或 stockout_order_code 至少传一个 / 缺少仓库上下文"
}
]
},
{
"method": "storage.stockout.confirm",
"name": "出库单确认(直出)",
@ -23640,6 +23726,13 @@
"source": "body",
"description": "详细地址"
},
{
"name": "receiver_id",
"type": "string",
"required": false,
"source": "body",
"description": "收件人证件号"
},
{
"name": "express_code",
"type": "string",
@ -23680,6 +23773,57 @@
"description": "收货信息缺失,禁止提交(列出缺失字段)"
}
]
},
{
"method": "storage.stockout.cancel",
"name": "出库单取消",
"description": "取消出库单:仅 CREATED/PENDING 状态允许取消;事务内释放创建时占用的库存锁定(QM_STOCKOUT,写 UNLOCK 流水),状态置为 CANCELLED,并写 wms_operation_log 操作日志(STOCKOUT_CANCEL)。TRANSFERRED(已转订单)与 COMPLETED(已完成)状态禁止取消。",
"isNeedAuth": true,
"isNeedLogin": true,
"isNeedRight": false,
"headers": [
{
"name": "Authorization",
"type": "string",
"required": true,
"description": "Bearer token"
}
],
"params": [
{
"name": "id",
"type": "number",
"required": true,
"source": "body",
"description": "出库单ID(必填)"
}
],
"response": [
{
"name": "id",
"type": "number",
"required": true,
"description": "出库单ID"
},
{
"name": "stockout_order_code",
"type": "string",
"required": true,
"description": "出库单号"
},
{
"name": "order_status",
"type": "string",
"required": true,
"description": "取消后状态(CANCELLED)"
}
],
"errors": [
{
"code": "400",
"description": "缺少出库单ID / 出库单不存在 / 状态不允许取消 / 释放锁定失败"
}
]
}
]
},
@ -23787,7 +23931,7 @@
},
{
"method": "storage.inventory.directPutaway",
"description": "收货单直入库存(一步完成):将已审核的收货单(completed + is_review=true)未入库明细直接写入 wms_storage 库位库存(按收货明细的库位 space_id 入库)并生成入库单(SCRK,一步置为 COMPLETED),入库单明细与收货明细一一对应(不合并,逐行保留库位/批次/效期),同时更新 wms_stock_warehouse 总库存并写入出入库流水(wms_stock_transaction / wms_storage_transaction),并写入 wms_inbound_direct_log(status=committed,与 storage.entry.commit 链路口径一致),回填收货单及其明细的入库状态。要求货主仓库签约配置 policy_config.allow_receiving_direct_putaway=1 开启直入库存功能。",
"description": "收货单直入库存(一步完成):将已审核的收货单(completed + is_review=true)未入库明细直接写入 wms_storage 库位库存并生成入库单(SCRK,一步置为 COMPLETED),入库单明细与收货明细一一对应(不合并,逐行保留库位/批次/效期),同时更新 wms_stock_warehouse 总库存并写入出入库流水(wms_stock_transaction / wms_storage_transaction),并写入 wms_inbound_direct_log(status=committed,与 storage.entry.commit 链路口径一致),回填收货单及其明细的入库状态。库位规则:收货明细 space_id 有效则按其库位入库,否则使用仓库设置 subject_config.default_location_id,未设置则兜底库位 1。要求货主仓库签约配置 policy_config.allow_receiving_direct_putaway=1 开启直入库存功能。",
"isNeedAuth": true,
"isNeedLogin": true,
"params": [

View File

@ -0,0 +1,173 @@
'use strict';
/**
* 回补历史"打包完成但订单仍为打包中(padding)"的存量数据。
*
* 背景:workbench.finishPack / order_packing.setEndTime 曾只结束 wms_pack_task,
* 不更新订单 pack_status,导致大量订单停留在 padding(打包中)。
*
* 回补规则(以 wms_pack_task 为基准,status=2 视为打包已完成):
* - 团购任务(pack_mode=2):按 wave_no 批量更新对应仓库分表中
* pack_status='padding' 且未被拦截(intercept_status IN ('none', NULL))的订单 → 'fin'
* - 散单任务(pack_mode=1):按 order_id 更新单个订单(同样只改 padding 且未拦截)
* - 仅更新任务已完成(status=2)对应订单;仍在打包(status=1)或拦截中的订单不动
*
* 用法:
* node script/backfill-pack-status-fin.cjs # 预览模式:只统计不修改
* node script/backfill-pack-status-fin.cjs --apply # 实际执行
*
* 连接配置:默认 script/db-query-prod-config.js(生产库)。
*/
const path = require('path');
const { createRequire } = require('module');
const APPLY = process.argv.includes('--apply');
async function main() {
const projectRoot = path.resolve(__dirname, '..');
const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
const mysql = projectRequire('mysql2/promise');
const configPath = path.join(__dirname, 'db-query-prod-config.js');
const cfg = require(configPath);
const client = cfg && cfg.mysql && cfg.mysql.clients && cfg.mysql.clients.wms;
if (!client) {
throw new Error(`未找到 mysql clients.wms 配置: ${configPath}`);
}
const conn = await mysql.createConnection({
host: client.host,
port: Number(client.port),
user: client.user,
password: client.password,
database: client.database,
charset: client.charset || 'utf8mb4',
timezone: 'Z',
multipleStatements: true,
});
try {
// 1. 读取所有已完成的打包任务
const [ tasks ] = await conn.query(
'SELECT warehouse_id, pack_mode, order_id, wave_no FROM wms_pack_task WHERE status = 2 AND deleted_at IS NULL'
);
const byWarehouse = new Map();
for (const t of tasks) {
const wh = Number(t.warehouse_id || 0);
if (!byWarehouse.has(wh)) byWarehouse.set(wh, { groupWaves: new Set(), singleOrders: new Set() });
const bucket = byWarehouse.get(wh);
if (Number(t.pack_mode) === 2 && t.wave_no) {
bucket.groupWaves.add(String(t.wave_no));
} else if (t.order_id) {
bucket.singleOrders.add(Number(t.order_id));
}
}
console.log(`任务统计: ${tasks.length} 条已完成任务,涉及仓库 ${byWarehouse.size} 个`);
for (const [ wh, b ] of byWarehouse.entries()) {
console.log(` 仓库 ${wh}: 团购波次 ${b.groupWaves.size} 个,散单订单 ${b.singleOrders.size} 笔`);
}
const chunk = list => {
const out = [];
for (let i = 0; i < list.length; i += 500) out.push(list.slice(i, i + 500));
return out;
};
let totalGroupAffected = 0;
let totalSingleAffected = 0;
const detail = [];
// 2. 逐仓库处理其 current / dispatch 分表
for (const [ wh, b ] of byWarehouse.entries()) {
const tables = [];
const [ tableRows ] = await conn.query('SHOW TABLES LIKE \'wms_order_delivery%\'');
const names = tableRows.map(r => Object.values(r)[0]);
for (const n of names) {
if (n.includes('_history') || n.includes('_outsourced') || n.includes('_bak')) continue;
// current 表(无后缀或带仓库后缀)与 dispatch 表都纳入
tables.push(n);
}
const waveList = [ ...b.groupWaves ];
const orderList = [ ...b.singleOrders ];
for (const tbl of tables) {
// 团购:按 wave_no 批量更新
for (const waves of chunk(waveList)) {
const waveIn = waves.map(w => conn.escape(w)).join(',');
const sql = `UPDATE ${tbl} SET pack_status = 'fin'
WHERE pack_status = 'padding'
AND intercept_status IN ('none', NULL)
AND wave_no IN (${waveIn})`;
if (APPLY) {
const [ r ] = await conn.query(sql);
if (r.affectedRows > 0) {
totalGroupAffected += r.affectedRows;
detail.push({ tbl, kind: 'group', waves: waves.length, affected: r.affectedRows });
}
} else {
const [ preview ] = await conn.query(
`SELECT COUNT(1) AS cnt FROM ${tbl}
WHERE pack_status = 'padding'
AND intercept_status IN ('none', NULL)
AND wave_no IN (${waveIn})`
);
const cnt = Number(preview[0].cnt || 0);
if (cnt > 0) {
totalGroupAffected += cnt;
detail.push({ tbl, kind: 'group', waves: waves.length, affected: cnt });
}
}
}
// 散单:按 order_id 更新
for (const orders of chunk(orderList)) {
const orderIn = orders.join(',');
if (APPLY) {
const sql = `UPDATE ${tbl} SET pack_status = 'fin'
WHERE pack_status = 'padding'
AND intercept_status IN ('none', NULL)
AND id IN (${orderIn})`;
const [ r ] = await conn.query(sql);
if (r.affectedRows > 0) {
totalSingleAffected += r.affectedRows;
detail.push({ tbl, kind: 'single', orders: orders.length, affected: r.affectedRows });
}
} else {
const [ preview ] = await conn.query(
`SELECT COUNT(1) AS cnt FROM ${tbl}
WHERE pack_status = 'padding'
AND intercept_status IN ('none', NULL)
AND id IN (${orderIn})`
);
const cnt = Number(preview[0].cnt || 0);
if (cnt > 0) {
totalSingleAffected += cnt;
detail.push({ tbl, kind: 'single', orders: orders.length, affected: cnt });
}
}
}
}
}
console.log('');
console.log(`==== ${APPLY ? '已执行' : '预览(加 --apply 执行)'} ====`);
console.log(`团购订单将更新: ${totalGroupAffected}`);
console.log(`散单订单将更新: ${totalSingleAffected}`);
console.log(`合计: ${totalGroupAffected + totalSingleAffected}`);
if (detail.length > 0) {
console.log('明细:');
for (const d of detail) console.log(` ${d.tbl} [${d.kind}] ${d.kind === 'group' ? d.waves + ' 波次' : d.orders + ' 订单'} → ${d.affected} 单`);
}
} finally {
await conn.end();
}
}
main().catch(err => {
console.error('回补脚本执行失败:', err.message);
process.exit(1);
});