WMS_MAIN/app/service/systems/workbench.js
liufumingren b5e5d4d588 feat(storeWarehouse,report,notice,order): 签约导出与代开户备注兜底、报表meta下线、入库完成通知与编码规范化
- storeWarehouse: 货主签约列表异步导出 export/exportTaskProgress(26列中文表头Excel+进度回写);openAccount 代开户未传 store_remask(或传空)时默认取公司全称前50字符填充,保证货主名称在列表/导出中始终有值

- report: 下线 report.meta(破坏性),窗口参数改由 definition.typeList、勾选字段经 definition.list 提供;报表投递目标货主状态放宽为 1/2(正常/审核中);reportDelivery 实体展示名称兼容下划线/驼峰并优雅回退 ID

- notice/order: 入库单完成通知货主(entry_order_completed,固定订阅回退链:收货组→售后组→仓库异常群);入库明细 itemId 规范化(非法值降级按 item_code 精确/归一化条码匹配,剥离中文后缀,多命中报错防错配);库存预警定时任务与 webhook 模型调整

- storage: 快捷直入/入库单基本信息等相关小改(inbound_direct_log、storage/entry、storage/inventory)

- docs: methods/system 0.3.62→0.3.63、openapi/qimen 同步,AI_METHOD_ROUTING 与 report-config-guide 同步,methods/changes/*.json 补变更记录
2026-08-31 17:17:48 +08:00

1601 lines
58 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const Service = require('egg').Service;
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
/** @type {string} 工作台波次订单实时计数缓存 key 前缀(最终 key:{前缀}:{warehouseId}:{waveId}) */
const WAVE_ORDER_COUNT_CACHE_KEY_PREFIX = 'cache:workbench:wave_order_count';
/** @type {number} 工作台波次订单实时计数缓存 TTL(秒),TTL 内分表 COUNT 只执行一次 */
const WAVE_ORDER_COUNT_CACHE_TTL_SECONDS = 15;
class WorkbenchService extends Service {
/**
* 查询工作台列表(仓库隔离 + 软删除过滤)
* @param {Object} params - { pagination, where }
* @returns {Promise<{list: Array, pagination: Object}>}
*/
async list(params = {}) {
const { ctx } = this;
const { Op } = ctx.app.Sequelize;
const warehouseId = ctx.user.store_id;
const { pagination = {}, where = {} } = params;
const page = Math.max(1, parseInt(pagination.page) || 1);
const pageSize = Math.min(200, Math.max(1, parseInt(pagination.pageSize) || 20));
const queryWhere = {
warehouse_id: warehouseId,
};
// 白名单字段筛选
if (where.name) {
queryWhere.name = { [Op.like]: `%${where.name}%` };
}
if (where.barcode) {
queryWhere.barcode = { [Op.like]: `%${where.barcode}%` };
}
if (where.status !== undefined && where.status !== null && where.status !== '') {
queryWhere.status = parseInt(where.status);
}
const { count, rows } = await ctx.model.Workbench.findAndCountAll({
where: queryWhere,
order: [['created_at', 'DESC']],
offset: (page - 1) * pageSize,
limit: pageSize,
});
return {
list: rows,
pagination: {
page,
pageSize,
total: count,
totalPages: Math.ceil(count / pageSize),
hasPrevious: page > 1,
hasNext: page * pageSize < count,
},
};
}
/**
* 查询单个工作台详情
* @param {number} id - 工作台 ID
* @returns {Promise<Object>}
*/
async detail(id) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权访问');
}
return record;
}
/**
* 创建工作台
* @param {Object} data - { name, barcode, status, remark }
* @returns {Promise<Object>}
*/
async create(data) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
if (!data.name || !String(data.name).trim()) {
throw new Error('工作台名称不能为空');
}
const record = await ctx.model.Workbench.create({
warehouse_id: warehouseId,
name: String(data.name).trim(),
barcode: data.barcode ? String(data.barcode).trim() : null,
type: data.type || 'personal',
status: data.status !== undefined ? parseInt(data.status) : 1,
device_ids: data.device_ids || null,
remark: data.remark ? String(data.remark).trim() : null,
});
return record;
}
/**
* 更新工作台
* @param {number} id - 工作台 ID
* @param {Object} data - 要更新的字段 { name, barcode, status, remark }
* @returns {Promise<Object>}
*/
async update(id, data) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权操作');
}
const updateFields = {};
if (data.name !== undefined) updateFields.name = String(data.name).trim();
if (data.barcode !== undefined) updateFields.barcode = data.barcode ? String(data.barcode).trim() : null;
if (data.type !== undefined) updateFields.type = data.type;
if (data.status !== undefined) updateFields.status = parseInt(data.status);
if (data.device_ids !== undefined) updateFields.device_ids = data.device_ids;
if (data.remark !== undefined) updateFields.remark = data.remark ? String(data.remark).trim() : null;
if (Object.keys(updateFields).length === 0) {
throw new Error('没有需要更新的字段');
}
await record.update(updateFields);
return record;
}
/**
* 软删除工作台
* @param {number} id - 工作台 ID
* @returns {Promise<void>}
*/
async delete(id) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权操作');
}
await record.destroy(); // paranoid: true → 自动设置 deleted_at
}
/**
* 绑定/解绑摄像头到工作台
* @param {number} id - 工作台 ID
* @param {number[]} cameraIds - 摄像头 ID 数组,传空数组或 null 表示解绑
* @returns {Promise<Object>}
*/
async bindCamera(id, cameraIds) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) throw new Error('工作台不存在或无权操作');
const ids = Array.isArray(cameraIds) ? cameraIds : [];
if (ids.length > 0) {
const cameras = await ctx.model.Camera.findAll({
where: { id: ids, warehouse_id: warehouseId },
attributes: ['id'],
});
const validIds = cameras.map(c => c.id);
const invalidIds = ids.filter(cid => !validIds.includes(cid));
if (invalidIds.length > 0) {
throw new Error(`摄像头 ${invalidIds.join(', ')} 不存在或无权操作`);
}
}
await record.update({ device_ids: ids.length > 0 ? ids : null });
return record;
}
/**
* 工作台业务入口
* @param {string} name - 业务名称(如 queryOrder)
* @param {*} data - 业务数据
* @returns {Promise<Object>}
*/
async business(name, data) {
const { ctx } = this;
ctx.logger.info('[Systems.Workbench.business] 收到业务调度 name=%s data=%j', name, data);
switch (name) {
case 'queryOrder':
case 'query':
return await this._queryOrder(data || {});
case 'packOrder':
return await this._packOrder(data || {});
case 'finishPack':
return await this._finishPack(data || {});
case 'sendWeight':
return await this._sendWeight(data || {});
case '':
default:
throw new Error(`不支持的业务类型: ${name}`);
}
}
/**
* 实时统计波次下的订单数量(并发遍历 current + dispatch 分表)
*
* current 与 dispatch 两张分表的 COUNT 相互独立,使用 Promise.all 并发执行,
* 将缓存未命中时的实时统计耗时从两张表串行累加压缩为单表耗时级别;
* 单张分表查询失败时按 0 处理,不影响另一张表的统计结果。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的订单总数
*/
async _countWaveOrders(warehouseId, waveId) {
const { ctx } = this;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const counts = await Promise.all(tableOrders.map(async entry => {
try {
const model = await entry.getModel();
if (!model) return 0;
return await model.count({ where: { wave_id: waveId, warehouse_id: warehouseId } });
} catch (_err) { return 0; }
}));
return counts.reduce((total, count) => total + count, 0);
}
/**
* 团购波次订单实时计数(带 Redis 短 TTL 缓存兜底)
*
* 分表 COUNT 无可用索引时扫描行数大、耗时长(生产实测 680~730ms/次)。
* wave_batch.total_orders 为多处异步维护的快照值,存在漂移风险,不能直接替代实时计数,
* 因此对实时计数结果按 (warehouseId, waveId) 维度做短 TTL 缓存:
* TTL 内重复查询直接命中缓存,缓存不可用或读取失败时降级为实时统计。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的订单总数
*/
async _countWaveOrdersCached(warehouseId, waveId) {
const { ctx, app } = this;
const cacheKey = `${WAVE_ORDER_COUNT_CACHE_KEY_PREFIX}:${warehouseId}:${waveId}`;
if (app && typeof app.getCacheAsync === 'function') {
try {
const cached = await app.getCacheAsync(cacheKey);
if (cached !== null && cached !== undefined) {
const parsed = Number(cached);
if (Number.isFinite(parsed) && parsed >= 0) {
return parsed;
}
}
} catch (cacheReadErr) {
ctx.logger.warn('[Workbench._countWaveOrdersCached] 读取缓存失败,降级为实时计数: %s', cacheReadErr.message);
}
}
const total = await this._countWaveOrders(warehouseId, waveId);
if (app && typeof app.setCacheAsync === 'function') {
try {
await app.setCacheAsync(cacheKey, total, WAVE_ORDER_COUNT_CACHE_TTL_SECONDS);
} catch (cacheWriteErr) {
ctx.logger.warn('[Workbench._countWaveOrdersCached] 写入缓存失败,不影响本次返回: %s', cacheWriteErr.message);
}
}
return total;
}
/**
* 获取波次下所有订单ID(遍历 current + dispatch 分表)
* @param {number} warehouseId
* @param {number} waveId
* @returns {Promise<number[]>}
*/
async _getWaveOrderIds(warehouseId, waveId) {
const { ctx } = this;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const orderIds = [];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const rows = await model.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id' ],
raw: true,
});
orderIds.push(...rows.map(r => r.id));
} catch (_err) { continue; }
}
return [ ...new Set(orderIds) ];
}
/**
* 打包任务字段白名单:只有这些字段的变化才会记入操作日志
*/
PACK_OPLOG_FIELD_WHITELIST = new Set([
'pack_mode',
'status',
'pack_quantity',
'item_quantity',
'sku_count',
'workbench_id',
'wave_no',
]);
/**
* 打包任务字段中文翻译
*/
PACK_OPLOG_FIELD_LABEL = {
pack_mode: '打包模式',
status: '任务状态',
pack_quantity: '打包数量',
item_quantity: '商品总数量',
sku_count: '商品种类数',
workbench_id: '工作台',
wave_no: '波次号',
};
/**
* 打包任务字段值翻译
*/
PACK_OPLOG_VALUE_LABEL = {
pack_mode: { 1: '散单', 2: '团购' },
status: { 0: '待处理', 1: '打包中', 2: '已完成', 3: '异常' },
};
/**
* 构建打包操作日志的变更描述。
* @param {Object} packData 打包数据
* @returns {string} 变更描述
*/
_buildPackChangeSummary(packData) {
const whitelist = this.PACK_OPLOG_FIELD_WHITELIST;
const fieldLabel = this.PACK_OPLOG_FIELD_LABEL;
const valueLabel = this.PACK_OPLOG_VALUE_LABEL;
const parts = [];
for (const [ key, value ] of Object.entries(packData)) {
if (!whitelist.has(key) || value === undefined || value === null) continue;
const label = fieldLabel[key] || key;
const valStr = (valueLabel[key] && valueLabel[key][value] !== undefined)
? valueLabel[key][value]
: String(value);
parts.push(`${label}: ${valStr}`);
}
return parts.join(',');
}
/**
* 写入打包操作日志。
* - 散单:写入单个订单操作日志
* - 团购:批量写入波次下所有订单的操作日志
* 写入失败不影响主流程。
*
* @param {Object} options
* @param {number} options.warehouseId 仓库ID
* @param {number} options.orderId 当前订单ID
* @param {number} options.waveId 波次ID
* @param {string} options.waveNo 波次号
* @param {number} options.isSandan 是否散单(1=散单 0=团购)
* @param {Object} options.packData 打包数据(用于变更描述)
* @param {Array<Object>} options.users 打包人员列表
*/
async _writePackOperationLog({ warehouseId, orderId, waveId, waveNo, isSandan, packData, users }) {
const { ctx } = this;
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (!operationLogService || typeof operationLogService.createOperationLogs !== 'function') {
return;
}
// 操作人信息:从 users 中取第一个作为主操作人
const operator = {
id: users && users[0] ? String(users[0].wms_account_id || users[0].id || '') : null,
name: users && users[0] ? (users[0].real_name || '') : null,
};
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) {
// 散单:写入单个订单操作日志
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `散单${actionText}:${changeSummary}`,
},
}]);
ctx.logger.info('[Workbench._writePackOperationLog] 散单操作日志已写入 orderId=%d', orderId);
} else {
// 团购:批量写入波次下所有订单的操作日志
if (!waveId || waveId <= 0) {
// 无波次ID时按散单处理
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `${actionText}:${changeSummary}`,
},
}]);
return;
}
const waveOrderIds = await this._getWaveOrderIds(warehouseId, waveId);
if (waveOrderIds.length === 0) {
// 波次下无订单,只写当前订单
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `${actionText}(波次 ${waveNo || waveId}):${changeSummary}`,
},
}]);
return;
}
const messagePrefix = `${isFinish ? '团购打包完成' : '团购开始打包'}(波次 ${waveNo || waveId},共${waveOrderIds.length}单):`;
const payloads = waveOrderIds.map(oid => ({
businessType: 'order',
businessId: String(oid),
operationCode,
operator,
extras: {
warehouseId,
message: `${messagePrefix}${changeSummary}`,
},
}));
await operationLogService.createOperationLogs(payloads);
ctx.logger.info('[Workbench._writePackOperationLog] 团购操作日志已批量写入 waveNo=%s orderCount=%d',
waveNo || waveId, waveOrderIds.length);
}
} catch (e) {
ctx.logger.warn('[Workbench._writePackOperationLog] 写入操作日志失败,不影响主流程', {
error: e && e.message,
orderId,
waveId,
warehouseId,
});
}
}
/**
* 更新订单打包状态字段(散单按订单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 }
* @returns {Promise<Object>}
*/
async _packOrder(params) {
const { ctx } = this;
const { delivery_order_code: deliveryOrderCode, wave_no: waveNo,
warehouse_id: inputWarehouseId, workbench_id: workbenchIdRaw,
status: packStatus, pack_time: packTime,
wave_total_orders: waveTotalOrders,
items_count: itemsCount,
items_total: itemsTotal,
users: usersParam } = params;
if (!deliveryOrderCode) throw new Error('发货单号不能为空');
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
// 防护 NaN:parseInt 对非数字字符串返回 NaN,会导致 Sequelize 生成非法 SQL
const workbenchId = (workbenchIdRaw !== undefined && workbenchIdRaw !== null && workbenchIdRaw !== '')
? parseInt(workbenchIdRaw)
: null;
const validWorkbenchId = (workbenchId !== null && !isNaN(workbenchId) && workbenchId > 0)
? workbenchId
: null;
const packTimeMs = packTime ? Number(packTime) * 1000 : Date.now();
// 步骤1:查找订单
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const row = await model.findOne({
where: { delivery_order_code: deliveryOrderCode, warehouse_id: warehouseId },
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (!orderRow) throw new Error(`未找到发货单 [${deliveryOrderCode}]`);
// 拦截流程中的订单不允许打包
if (isInterceptedOrderStatus(orderRow.intercept_status)) {
throw new Error(`订单已被拦截,无法打包 [${deliveryOrderCode}]`);
}
const orderId = orderRow.id;
const waveId = orderRow.wave_id || 0;
const actualWaveNo = waveNo || orderRow.wave_no || '';
// 步骤2:获取波次信息,判断散单/团购
let waveType = null;
let totalOrders = 0;
let isSandan = 1;
if (waveId > 0) {
try {
const waveBatch = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: ['wave_type', 'total_orders'],
raw: true,
});
if (waveBatch) {
waveType = waveBatch.wave_type;
isSandan = Number(waveType) === 1 ? 0 : 1;
// 实时统计波次订单数(而非依赖 wave_batch.total_orders 快照)
totalOrders = await this._countWaveOrders(warehouseId, waveId);
}
} catch (_err) { /* ignore */ }
}
// 步骤3:获取工作台 device_ids
let deviceIds = null;
if (validWorkbenchId) {
try {
const wb = await ctx.model.Workbench.findByPk(validWorkbenchId, {
attributes: ['device_ids'],
raw: true,
});
deviceIds = wb && wb.device_ids ? wb.device_ids : null;
} catch (_err) { /* ignore */ }
}
// 步骤4:同一工作台有新的打包任务时,关闭上一个未结束的任务
if (validWorkbenchId) {
const previousTask = await ctx.model.PackTask.findOne({
where: {
workbench_id: validWorkbenchId,
warehouse_id: warehouseId,
order_id: { [ctx.app.Sequelize.Op.ne]: orderId },
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
});
if (previousTask) {
const previousEndTime = await this.resolvePackTaskEndTime(previousTask, new Date(packTimeMs));
await previousTask.update({ end_time: previousEndTime, status: 2 });
ctx.logger.info('[Workbench._packOrder] 关闭上一个未结束任务 taskId=%d orderId=%d workbenchId=%d',
previousTask.id, previousTask.order_id, validWorkbenchId);
}
}
// 步骤5:去重 — 散单按 order_id 物理删除旧记录,团购按 wave_no 物理删除旧记录
if (isSandan === 1) {
// 散单:按 order_id 去重,先收集旧任务ID清理关联打包人,再物理移除旧任务
const oldTasks = await ctx.model.PackTask.findAll({
where: { order_id: orderId, warehouse_id: warehouseId },
attributes: ['id'],
raw: true,
paranoid: false,
});
if (oldTasks.length > 0) {
const oldTaskIds = oldTasks.map(t => t.id);
await ctx.model.PackTaskPacker.destroy({
where: { pack_task_id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
await ctx.model.PackTask.destroy({
where: { id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
ctx.logger.info('[Workbench._packOrder] 散单去重:物理删除 %d 条旧记录 orderId=%d', oldTasks.length, orderId);
}
} else {
// 团购:按 wave_no 去重,先收集旧任务ID清理关联打包人,再物理移除旧任务
if (actualWaveNo) {
const oldTasks = await ctx.model.PackTask.findAll({
where: { wave_no: actualWaveNo, warehouse_id: warehouseId },
attributes: ['id'],
raw: true,
paranoid: false,
});
if (oldTasks.length > 0) {
const oldTaskIds = oldTasks.map(t => t.id);
await ctx.model.PackTaskPacker.destroy({
where: { pack_task_id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
await ctx.model.PackTask.destroy({
where: { id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
ctx.logger.info('[Workbench._packOrder] 团购去重:物理删除 %d 条旧记录 waveNo=%s', oldTasks.length, actualWaveNo);
}
}
}
// 步骤6:创建新的打包任务
const packData = {
order_id: orderId,
warehouse_id: warehouseId,
workbench_id: validWorkbenchId,
wave_id: waveId,
wave_no: actualWaveNo,
waybill_code: null, // 后续可从 order_express 补
pack_mode: isSandan === 0 ? 2 : 1, // 1=散单 2=团购
status: packStatus !== undefined ? parseInt(packStatus) : 1,
pack_quantity: waveTotalOrders !== undefined ? parseInt(waveTotalOrders) || 0 : 1,
item_quantity: itemsTotal !== undefined ? parseInt(itemsTotal) || 0 : (orderRow.items_total || 0),
sku_count: itemsCount !== undefined ? parseInt(itemsCount) || 0 : (orderRow.item_count || 0),
start_time: new Date(packTimeMs),
end_time: packStatus >= 2 ? new Date(packTimeMs) : null,
device_ids: deviceIds,
};
const packTask = await ctx.model.PackTask.create(packData);
ctx.logger.info('[Workbench._packOrder] 创建打包任务 taskId=%d orderId=%d', packTask.id, orderId);
// 步骤6.5:更新订单的打包状态字段(散单按订单更新,团购按波次批量更新)
await this._updateOrderPackStatus(warehouseId, {
orderId,
waveId: isSandan === 1 ? 0 : waveId,
packStatus,
caller: 'Workbench._packOrder',
});
// 步骤7:写入打包人员信息
const users = Array.isArray(usersParam) ? usersParam : [];
let operatorText = '';
if (users.length > 0) {
// account_id 未知时写 null(表列允许 NULL):唯一索引 uix_pack_task_account 对
// NULL 不生效,避免多人打包(account_id 全为 0)时违反唯一约束导致主流程中断。
// 真实账号仍按 account_id 去重;无账号时按姓名去重。
const seenPackerKeys = new Set();
const packerRecords = [];
for (const user of users) {
const accountIdRaw = user.wms_account_id != null
? user.wms_account_id
: (user.id != null ? user.id : null);
const accountId = accountIdRaw != null ? (parseInt(accountIdRaw) || null) : null;
const accountName = user.real_name || '';
const dedupeKey = accountId !== null ? `id:${accountId}` : `name:${accountName}`;
if (seenPackerKeys.has(dedupeKey)) continue;
seenPackerKeys.add(dedupeKey);
packerRecords.push({
pack_task_id: packTask.id,
account_id: accountId,
account_name: accountName,
seq: packerRecords.length,
});
}
if (packerRecords.length > 0) {
await ctx.model.PackTaskPacker.bulkCreate(packerRecords);
}
operatorText = users.map(u => u.real_name || '').filter(Boolean).join(',');
// 回写 operator_text 到打包任务
await packTask.update({ operator_text: operatorText });
ctx.logger.info('[Workbench._packOrder] 写入 %d 个打包人员 operatorText=%s', users.length, operatorText);
}
// 步骤7.5:下发 OSD 叠加到工作台绑定的摄像头(带 Redis 缓存去重)
const cameraIds = Array.isArray(deviceIds) ? deviceIds : [];
if (cameraIds.length > 0) {
let osdText = '';
if (isSandan === 1) {
// 散单:用运单号
const expressRecord = await ctx.model.OrderExpress.findOne({
where: { order_id: orderId, warehouse_id: warehouseId },
attributes: ['waybill_code'],
raw: true,
});
osdText = (expressRecord && expressRecord.waybill_code) || deliveryOrderCode;
} else {
// 团购:波次号+总量
osdText = `波次${actualWaveNo} 共${totalOrders}单`;
}
// 写入 OSD 缓存
try {
const osdCacheKey = `osd_${validWorkbenchId}`;
await this.app.setCacheAsync(osdCacheKey, osdText, 3600);
ctx.logger.info('[Workbench._packOrder] OSD缓存已写入 workbenchId=%d text=%s',
validWorkbenchId, osdText);
} catch (cacheErr) {
ctx.logger.warn('[Workbench._packOrder] OSD缓存写入失败 workbenchId=%d err=%s',
validWorkbenchId, cacheErr.message);
}
const OsdClient = require('../../lib/osd_client');
const osdClient = new OsdClient(ctx);
// 异步下发,不阻塞打包主流程
Promise.all(cameraIds.map(async cameraId => {
try {
const camera = await ctx.model.Camera.findOne({
where: { id: cameraId, warehouse_id: warehouseId },
raw: true,
});
if (!camera || !camera.ip) return;
const result = await osdClient.setOsd({
camera,
warehouseId,
text: osdText,
});
if (!result.success) {
ctx.logger.warn('[Workbench._packOrder] OSD下发失败 cameraId=%d error=%s',
cameraId, result.error || '打印服务返回异常');
}
} catch (err) {
ctx.logger.warn('[Workbench._packOrder] OSD下发异常 cameraId=%d err=%s', cameraId, err.message);
}
})).catch(err => {
ctx.logger.warn('[Workbench._packOrder] OSD批量下发异常 err=%s', err.message);
});
}
// 步骤8:写入操作日志(散单写单个订单,团购批量写波次所有订单)
await this._writePackOperationLog({
warehouseId,
orderId,
waveId,
waveNo: actualWaveNo,
isSandan,
packData,
users,
});
const result = {
task_id: packTask.id,
order_id: orderId,
delivery_order_code: deliveryOrderCode,
wave_no: actualWaveNo,
isSandan,
pack_mode: packData.pack_mode,
status: packData.status,
};
// 团购单附加波次总量
if (isSandan === 0) {
result.batch = { wave_id: waveId, wave_no: actualWaveNo, wave_type: waveType, total_orders: totalOrders };
}
return result;
}
/**
* 按仓库配置的打包最大时长约束任务结束时间。
* 候选结束时间超过 开始时间+上限时长 时,截断为上限时间点。
* 未配置有效时长或开始时间非法时不做约束,原样返回。
*
* @param {Object} packTask 打包任务实例(需含 warehouse_id / pack_mode / start_time)
* @param {Date|string} endTime 候选结束时间
* @return {Promise<Date>} 约束后的结束时间
*/
async resolvePackTaskEndTime(packTask, endTime) {
const { ctx } = this;
const candidate = endTime instanceof Date ? endTime : new Date(endTime);
if (!packTask || !Number.isFinite(candidate.getTime())) {
return endTime;
}
const startMs = new Date(packTask.start_time).getTime();
if (!Number.isFinite(startMs)) {
return endTime;
}
const isGroup = Number(packTask.pack_mode) === 2;
let limitMinutes = null;
try {
const warehouseId = Number(packTask.warehouse_id || 0);
const subjectConfig = await ctx.service.systems.deliveryOrder.getStoreSubjectConfig(warehouseId);
const rawMinutes = isGroup
? subjectConfig.group_order_pack_max_minutes
: subjectConfig.single_order_pack_max_minutes;
limitMinutes = Number(rawMinutes);
} catch (error) {
ctx.logger.warn('[Workbench.resolvePackTaskEndTime] 读取仓库配置失败: %s', error.message);
}
// 未配置有效时长时不约束结束时间
if (!Number.isInteger(limitMinutes) || limitMinutes <= 0) {
return endTime;
}
const maxEndMs = startMs + limitMinutes * 60 * 1000;
if (candidate.getTime() > maxEndMs) {
const cappedEndTime = new Date(maxEndMs);
ctx.logger.info(
'[Workbench.resolvePackTaskEndTime] 结束时间超过打包上限,截断为上限时间 taskId=%d packMode=%s limitMinutes=%d end=%s',
packTask.id,
isGroup ? 'group' : 'single',
limitMinutes,
cappedEndTime.toISOString()
);
return cappedEndTime;
}
return endTime;
}
/**
* 工作台打包完成:传入工作台ID,查找最后一个未结束的打包任务并结束
* @param {Object} params - { workbench_id, warehouse_id }
* @returns {Promise<Object>}
*/
async _finishPack(params) {
const { ctx } = this;
const { workbench_id: workbenchIdRaw, warehouse_id: inputWarehouseId } = params;
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
const workbenchId = (workbenchIdRaw !== undefined && workbenchIdRaw !== null && workbenchIdRaw !== '')
? parseInt(workbenchIdRaw)
: null;
const validWorkbenchId = (workbenchId !== null && !isNaN(workbenchId) && workbenchId > 0)
? workbenchId
: null;
if (!validWorkbenchId) throw new Error('工作台ID不能为空');
// 查找该工作台最后一个未结束的打包任务(按 id 倒序取最新)
const lastTask = await ctx.model.PackTask.findOne({
where: {
workbench_id: validWorkbenchId,
warehouse_id: warehouseId,
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
order: [[ 'id', 'DESC' ]],
});
if (!lastTask) {
ctx.logger.info('[Workbench._finishPack] 工作台 %d 无未结束的打包任务', validWorkbenchId);
return { workbench_id: validWorkbenchId, finished: false, message: '无未结束的打包任务' };
}
const now = new Date();
const endTime = await this.resolvePackTaskEndTime(lastTask, now);
await lastTask.update({ end_time: endTime, status: 2 });
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,
task_id: lastTask.id,
order_id: lastTask.order_id,
end_time: endTime,
};
}
/**
* 称重上报:条码(sn) → 运单号 → 更新称重重量
* 支持散单直接更新和团购波次批量称重
* @param {Object} params - { barcode, weight(克), warehouseId }
* @returns {Promise<Object>} weighing_weight/total_weight 单位为 g
*/
async _sendWeight(params) {
const { ctx } = this;
const { barcode, weight, warehouseId: inputWarehouseId } = params;
// 参数校验
if (!barcode || !String(barcode).trim()) {
throw new Error('条码(sn)不能为空');
}
if (weight === null || weight === undefined || String(weight).trim() === '') {
throw new Error('重量(weight)不能为空');
}
if (!inputWarehouseId) {
throw new Error('仓库ID不能为空');
}
const normalizedBarcode = String(barcode).trim();
const warehouseId = parseInt(inputWarehouseId);
// 校验重量格式(入参单位:克),必须大于0
const weightText = String(weight).trim();
if (!/^\d+$/.test(weightText)) {
throw new Error('重量格式非法,必须为正整数(单位 g)');
}
const weightGram = Number(weightText);
if (!Number.isFinite(weightGram) || weightGram <= 0) {
throw new Error('重量必须大于0');
}
// DB 存储单位已统一为 g,无需转换
const normalizedWeight = weightGram;
// 步骤1:条码 → 运单记录(按 waybill_code + warehouse_id 精确匹配)
const expressRow = await ctx.model.OrderExpress.findOne({
where: {
waybill_code: normalizedBarcode,
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'business_key' ],
raw: true,
});
if (!expressRow) {
throw new Error(`未找到条码 [${normalizedBarcode}] 对应的运单记录`);
}
const orderId = Number(expressRow.order_id);
// 步骤2:遍历 current → history → dispatch 分表查找订单及波次信息
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'history', getModel: () => orderDeliveryFactory.getHistoryModel(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 (_err) { /* 定位失败,保持原遍历顺序 */ }
let orderRow = null;
let orderDeliveryModel = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no', 'items_weight', 'intercept_status' ],
raw: true,
});
if (row) {
orderRow = row;
orderDeliveryModel = model;
break;
}
} catch (_err) {
ctx.logger.warn('[Workbench._sendWeight] 查询表 %s 失败: %s', entry.label, _err.message);
continue;
}
}
if (!orderRow) {
throw new Error(`未找到运单对应的订单 [id=${orderId}, warehouse=${warehouseId}]`);
}
// 拦截流程中的订单不允许称重
if (isInterceptedOrderStatus(orderRow.intercept_status)) {
throw new Error(`订单已被拦截,无法称重 [${normalizedBarcode}]`);
}
const waveId = Number(orderRow.wave_id || 0);
// 步骤3:散单(wave_id=0)→ 仅更新该运单的称重重量
if (waveId === 0) {
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{ where: { id: Number(expressRow.id) } }
);
ctx.logger.info('[Workbench._sendWeight] 散单称重 barcode=%s orderId=%d weightG=%s',
normalizedBarcode, orderId, normalizedWeight);
// 写入操作日志
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
order_id: orderId,
weighing_weight: normalizedWeight,
items_weight: Number(orderRow.items_weight || 0),
mode: 'single',
};
}
// 步骤4:查询波次类型,判断是否为团购波次
const waveRow = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 非团购波次 → 降级为散单逻辑
if (!waveRow || Number(waveRow.wave_type) !== 1) {
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{ where: { id: Number(expressRow.id) } }
);
ctx.logger.info('[Workbench._sendWeight] 非团购波次称重 barcode=%s orderId=%d weightG=%s waveType=%s',
normalizedBarcode, orderId, normalizedWeight, waveRow ? waveRow.wave_type : 'N/A');
// 写入操作日志
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
order_id: orderId,
weighing_weight: normalizedWeight,
items_weight: Number(orderRow.items_weight || 0),
mode: 'single',
};
}
// 步骤5:团购波次(wave_type=1)→ 批量更新波次下所有运单的称重重量
const { Op } = ctx.app.Sequelize;
const waveOrders = await orderDeliveryModel.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (!waveOrders || waveOrders.length === 0) {
throw new Error('波次下未找到订单');
}
// 波次内拦截订单不参与批量称重
const interceptedWaveOrderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
const orderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => !isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
if (interceptedWaveOrderIds.length > 0) {
ctx.logger.info('[Workbench._sendWeight] 波次内拦截订单不参与称重 waveId=%d orderIds=%s',
waveId, interceptedWaveOrderIds.join(','));
}
const totalCount = orderIds.length;
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{
where: {
order_id: { [Op.in]: orderIds },
delete_at: null,
},
}
);
ctx.logger.info('[Workbench._sendWeight] 团购波次批量称重 barcode=%s waveId=%d waveNo=%s orderCount=%d weightG=%s',
normalizedBarcode, waveId, waveRow.wave_no, totalCount, normalizedWeight);
// 写入操作日志(团购波次:逐订单批量写入)
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
waveId,
waveNo: String(waveRow.wave_no || ''),
waveOrderIds: orderIds,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
wave_id: waveId,
wave_no: String(waveRow.wave_no || ''),
weighing_weight: normalizedWeight,
total_weight: normalizedWeight * totalCount,
order_count: totalCount,
items_weight: Number(orderRow.items_weight || 0),
mode: 'wave',
};
}
/**
* 写入称重操作日志(内部方法,失败不影响主流程)
* @param {Object} opts
* @param {number} opts.orderId 触发订单ID
* @param {string} opts.barcode 条码/运单号
* @param {number} opts.weightGram 称重重量(克)
* @param {number} opts.normalizedWeight 称重重量(克)
* @param {number} opts.warehouseId 仓库ID
* @param {number} [opts.waveId] 波次ID(团购时传入)
* @param {string} [opts.waveNo] 波次号
* @param {number[]} [opts.waveOrderIds] 波次下所有订单ID(团购时传入,逐条写日志)
*/
async _writeWeighOpLog(opts = {}) {
const { ctx } = this;
const {
orderId, barcode, weightGram, normalizedWeight, warehouseId,
waveId, waveNo, waveOrderIds,
} = opts;
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (!operationLogService || typeof operationLogService.createOperationLogs !== 'function') {
return;
}
const isWave = waveId && waveId > 0 && Array.isArray(waveOrderIds) && waveOrderIds.length > 0;
const operator = { id: '', name: 'system' };
if (isWave) {
// 团购波次:逐订单批量写入操作日志
const orderCount = waveOrderIds.length;
const message = `工作台团购波次称重 ${normalizedWeight}g,波次 ${waveNo || waveId},共 ${orderCount} 单,触发条码 ${barcode}`;
const payloads = waveOrderIds.map(oid => ({
businessType: 'order',
businessId: String(oid),
operationCode: 'ORDER_WEIGH',
operator,
extras: {
warehouseId,
message,
barcode,
weightGram,
weighingWeight: normalizedWeight,
waveId,
waveNo: waveNo || '',
orderCount,
},
}));
await operationLogService.createOperationLogs(payloads);
ctx.logger.info('[Workbench._writeWeighOpLog] 团购称重操作日志已批量写入 waveId=%d orderCount=%d',
waveId, orderCount);
} else {
// 散单:单条操作日志
const payload = {
businessType: 'order',
businessId: String(orderId),
operationCode: 'ORDER_WEIGH',
operator,
extras: {
warehouseId,
message: `工作台称重 ${normalizedWeight}g,条码 ${barcode}`,
barcode,
weightGram,
weighingWeight: normalizedWeight,
orderId,
},
};
await operationLogService.createOperationLogs([ payload ]);
ctx.logger.info('[Workbench._writeWeighOpLog] 散单称重操作日志已写入 orderId=%d barcode=%s',
orderId, barcode);
}
} catch (e) {
ctx.logger.warn('[Workbench._writeWeighOpLog] 写入操作日志失败,不影响主流程', {
error: e && e.message,
orderId,
barcode,
});
}
}
/**
* 条码查订单:条码 → wms_order_express → 待处理/配送订单详情
* 散单(isSandan=1)时在响应 order 对象中额外返回 intercept_flag / pack_flag 两个 0/1 标志:
* 拦截状态(intercept_status)不等于 none 时 intercept_flag=1,否则 0;
* 打包状态(pack_status)不等于 none 时 pack_flag=1,否则 0。
* @param {Object} params - { barcode, warehouseId }
* @return {Promise<Object>} 查询结果 { barcode, waybill_code, isSandan, store_remark, express, order, items, source_table, batch? }
*/
async _queryOrder(params) {
const { ctx } = this;
const { barcode, warehouseId: inputWarehouseId } = params;
if (!barcode || !String(barcode).trim()) {
throw new Error('条码不能为空');
}
if (!inputWarehouseId || !String(inputWarehouseId).trim()) {
throw new Error('仓库ID不能为空');
}
const normalizedBarcode = String(barcode).trim();
const warehouseId = parseInt(inputWarehouseId);
// 步骤1:条码 → order_id + warehouse_id(必须限制仓库)
const expressRecord = await ctx.model.OrderExpress.findOne({
where: {
waybill_code: normalizedBarcode,
warehouse_id: warehouseId,
status: 1,
},
attributes: ['order_id', 'warehouse_id', 'waybill_code', 'logistics_name', 'weighing_weight', 'package_material_name_snapshot'],
raw: true,
});
if (!expressRecord) {
throw new Error(`未找到条码 [${normalizedBarcode}] 对应的运单记录`);
}
const { order_id: orderId, waybill_code: waybillCode } = expressRecord;
// 步骤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) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
raw: true,
});
if (row) {
orderRow = row;
sourceTable = entry.label;
break;
}
} catch (_err) {
ctx.logger.warn('[Workbench._queryOrder] 查询表 %s 失败: %s', entry.label, _err.message);
continue;
}
}
if (!orderRow) {
throw new Error(`未在待处理或配送表中找到订单 [id=${orderId}, warehouse=${warehouseId}]`);
}
ctx.logger.info('[Workbench._queryOrder] 条码=%s 命中 orderId=%d source=%s',
normalizedBarcode, orderId, sourceTable);
// 步骤3:判断波次类型(散单 vs 团购),团购需返回波次总量
let waveType = null;
let totalBatchOrders = 0;
let isSandan = 1; // 默认散单
const waveId = orderRow.wave_id;
if (waveId && Number(waveId) > 0) {
try {
// 查询波次信息
const waveBatch = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: ['wave_id', 'wave_type', 'total_orders'],
raw: true,
});
if (waveBatch) {
waveType = waveBatch.wave_type;
// wave_type=1 → 团购单(isSandan=0); 其他(2=散单等) → 散单(isSandan=1)
if (Number(waveType) === 1) {
isSandan = 0;
// 仅团购单组装波次总量:实时统计带短 TTL 缓存;
// 散单不再触发分表 COUNT,避免 680ms+ 的无用扫描
totalBatchOrders = await this._countWaveOrdersCached(warehouseId, waveId);
} else {
isSandan = 1;
}
}
} catch (waveErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询波次信息失败 waveId=%d: %s', waveId, waveErr.message);
}
}
// 步骤4:查询订单商品明细 + 关联 stock 详情(带缓存)
let items = [];
try {
const getItemsModel = sourceTable === 'dispatch'
? () => ctx.model.OrderItemsFactory.getDispatchModel(warehouseId)
: () => ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const itemsModel = await getItemsModel();
if (itemsModel) {
const orderItems = await itemsModel.findAll({
where: { order_id: orderId },
attributes: [
'id', 'order_id', 'item_id', 'item_code', 'item_name',
'plan_qty', 'actual_price', 'stock_id', 'order_line_no',
'inventory_type', 'item_snapshot',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
if (orderItems.length > 0) {
// 收集所有 stock_id,批量查询 stock 详情(带缓存)
const stockIds = [ ...new Set(
orderItems.map(item => Number(item.stock_id)).filter(id => id > 0)
) ];
/** @type {Map<number, Object>} */
const stockMap = new Map();
if (stockIds.length > 0) {
try {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{ warehouseId }
);
for (const detail of stockDetails) {
stockMap.set(Number(detail.id), detail);
}
} catch (stockErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询 stock 详情失败: %s', stockErr.message);
}
}
// 组装 items,合并 stock 信息
items = orderItems.map(item => {
const stockId = Number(item.stock_id);
const stock = stockMap.get(stockId) || {};
return {
id: item.id,
order_id: item.order_id,
item_id: item.item_id,
item_code: item.item_code || stock.item_code || '',
item_name: item.item_name || stock.item_name || '',
plan_qty: item.plan_qty,
actual_price: item.actual_price,
stock_id: stockId,
order_line_no: item.order_line_no || '',
inventory_type: item.inventory_type || '',
sku_property: stock.sku_property || '',
stock_unit: stock.stock_unit || '',
barcodes: stock.barcodes || [],
image_url: stock.image_url || '',
packing_requirements: String(stock.packing_requirements || '').trim(),
};
});
}
}
} catch (itemsErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询订单商品失败: %s', itemsErr.message);
}
// 步骤5:查询货主备注(从合约表 store_warehouse.store_remask)
let storeRemark = '';
const storeId = Number(orderRow.store_id || 0);
if (storeId > 0) {
try {
const swRow = await ctx.model.StoreWarehouse.findOne({
where: { store_id: storeId, warehouse_id: warehouseId },
attributes: ['store_remask'],
raw: true,
});
storeRemark = (swRow && swRow.store_remask) ? String(swRow.store_remask).trim() : '';
} catch (swErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询货主备注失败 storeId=%d: %s', storeId, swErr.message);
}
}
// 步骤6:散单标志位计算(拦截/打包状态空值归一化为 none,非 none 记 1,否则 0)
const normalizedInterceptStatus = String(orderRow.intercept_status || '').trim() || 'none';
const normalizedPackStatus = String(orderRow.pack_status || '').trim() || 'none';
const interceptFlag = normalizedInterceptStatus === 'none' ? 0 : 1;
const packFlag = normalizedPackStatus === 'none' ? 0 : 1;
const result = {
barcode: normalizedBarcode,
waybill_code: waybillCode,
isSandan,
store_remark: storeRemark,
express: {
logistics_name: expressRecord.logistics_name,
weighing_weight: expressRecord.weighing_weight,
package_material_name: expressRecord.package_material_name_snapshot || '',
},
order: {
id: orderRow.id,
delivery_order_code: orderRow.delivery_order_code,
order_type: orderRow.order_type,
warehouse_id: orderRow.warehouse_id,
store_id: orderRow.store_id,
status: orderRow.status,
step: orderRow.step,
wave_id: orderRow.wave_id,
wave_no: orderRow.wave_no,
post_status: orderRow.post_status,
pick_status: orderRow.pick_status,
pack_status: orderRow.pack_status,
intercept_status: orderRow.intercept_status,
recheck_status: orderRow.recheck_status,
outbound_status: orderRow.outbound_status,
items_count: orderRow.items_count,
items_total: orderRow.items_total,
items_weight: orderRow.items_weight,
source_platform_code: orderRow.source_platform_code,
logistics_name: orderRow.logistics_name,
create_at: orderRow.create_at,
updated_at: orderRow.updated_at,
},
items,
source_table: sourceTable,
};
// 散单附加拦截/打包 0/1 标志(原始状态字段仍保留在 order 中,不破坏既有调用方)
if (isSandan === 1) {
result.order.intercept_flag = interceptFlag;
result.order.pack_flag = packFlag;
}
// 团购单附加波次总量信息
if (isSandan === 0) {
result.batch = {
wave_id: waveId,
wave_no: orderRow.wave_no,
wave_type: waveType,
total_orders: totalBatchOrders,
};
}
return result;
}
/**
* 检查条码在仓库内是否已存在(排除指定ID)
* @param {string} barcode - 条码
* @param {number} [excludeId] - 排除的工作台ID(更新时使用)
* @returns {Promise<boolean>}
*/
async checkBarcodeExists(barcode, excludeId) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
if (!barcode) return false;
const where = {
warehouse_id: warehouseId,
barcode: String(barcode).trim(),
};
if (excludeId) {
const { Op } = ctx.app.Sequelize;
where.id = { [Op.ne]: excludeId };
}
const count = await ctx.model.Workbench.count({ where });
return count > 0;
}
}
module.exports = WorkbenchService;