WMS_MAIN/app/service/systems/workbench.js
liufumingren e5196dc1ea feat(pack): 打包任务最大时长约束与自动结束
- 仓库设置新增 single_order_pack_max_minutes(默认3)/group_order_pack_max_minutes(默认40) 配置
- 新增每小时定时任务扫描未结束打包任务,超时自动结束(end=start+上限)
- 结束时间统一截断为开始时间+上限时长(finishPack/新任务顶替/setEndTime 接口)
2026-08-15 23:12:51 +08:00

1410 lines
48 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;
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 分表)
* @param {number} warehouseId
* @param {number} waveId
* @returns {Promise<number>}
*/
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) },
];
let total = 0;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const count = await model.count({ where: { wave_id: waveId, warehouse_id: warehouseId } });
total += count;
} catch (_err) { continue; }
}
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';
if (isSandan === 1) {
// 散单:写入单个订单操作日志
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `散单打包完成:${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: `打包完成:${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: `打包完成(波次 ${waveNo || waveId}):${changeSummary}`,
},
}]);
return;
}
const messagePrefix = `团购打包完成(波次 ${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,
});
}
}
/**
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录
* @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}]`);
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:更新订单的打包状态字段
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 },
});
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; }
}
}
// 步骤7:写入打包人员信息
const users = Array.isArray(usersParam) ? usersParam : [];
let operatorText = '';
if (users.length > 0) {
const packerRecords = users.map((user, idx) => ({
pack_task_id: packTask.id,
account_id: user.wms_account_id != null ? parseInt(user.wms_account_id) || 0 : 0,
account_name: user.real_name || '',
seq: idx,
}));
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);
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' ],
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}]`);
}
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' ],
raw: true,
});
if (!waveOrders || waveOrders.length === 0) {
throw new Error('波次下未找到订单');
}
const orderIds = waveOrders.map(o => Number(o.id));
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 → 待处理/配送订单详情
* @param {Object} params - { barcode, warehouseId }
* @returns {Promise<Object>}
*/
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) },
];
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;
} else {
isSandan = 1;
}
// 实时统计波次订单数
totalBatchOrders = await this._countWaveOrders(warehouseId, waveId);
}
} 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 || '',
};
});
}
}
} 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);
}
}
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,
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,
};
// 团购单附加波次总量信息
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;