fix: OrderExpress 查询添加仓库隔离 + workbench 业务增强

- _queryOrder: OrderExpress 查询增加 warehouse_id 过滤,避免跨仓库数据泄露
- _queryOrder: 新增订单商品明细查询,关联 stock 详情(带缓存)
- _packOrder: 同一工作台新任务进入时自动关闭上一个未结束任务
- order_packing.js: quickWhere 运单号查询增加 warehouse_id 过滤
- recheckOrder.js: getWaveOrdersBasic 运单查询增加 warehouse_id 过滤
- order_print.js: queryOrderExpressByOrderIds 增加 warehouseId 参数
- waybill.js: toOrder 运单查询在用户已登录时增加 warehouse_id 过滤
This commit is contained in:
liufumingren 2026-07-21 20:53:53 +08:00
parent 1537c1ac10
commit 52aa76af60
5 changed files with 1068 additions and 12 deletions

View File

@ -10,9 +10,9 @@ class RecheckOrderService extends OrderBaseService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck';
const _noNeedRight = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,queryRecheckOrderSingleList';
const _noNeedLog = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck';
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck';
const _noNeedAuth = 'scanOrder,scanTask,scanWaybill,confirmRecheck,recheckOrderList,confirmIntercept,batchQuickRecheck,queryRecheckOrderSingleList';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
@ -1043,7 +1043,7 @@ class RecheckOrderService extends OrderBaseService {
const waybillMap = new Map();
if (orderIds.length > 0 && ctx.model && ctx.model.OrderExpress) {
const expressRows = await ctx.model.OrderExpress.findAll({
where: { order_id: orderIds },
where: { order_id: orderIds, warehouse_id: warehouseId },
attributes: [ 'order_id', 'waybill_code' ],
order: [[ 'id', 'ASC' ]],
raw: true,
@ -3145,7 +3145,6 @@ class RecheckOrderService extends OrderBaseService {
o.weight_type,
o.status,
o.create_at,
o.pick_time,
o.recheck_time
FROM ${orderTableName} o
${whereClause}
@ -3191,7 +3190,6 @@ class RecheckOrderService extends OrderBaseService {
weight_type: this.formatWeightTypeLabel(row?.weight_type),
status: Number(row?.status || 0),
create_at: row?.create_at || null,
pick_time: row?.pick_time || null,
recheck_time: row?.recheck_time || null,
}));
@ -3927,6 +3925,7 @@ class RecheckOrderService extends OrderBaseService {
await orderModel.update(
{
recheck_status: 'fin',
print_status: 'fin',
recheck_time: now,
updated_at: now,
},

View File

@ -0,0 +1,394 @@
'use strict';
const Service = require('egg').Service;
/**
* 打包任务服务层(仓库侧)。
* 负责打包任务列表查询、详情查询等仓库维度的打包管理业务逻辑。
* 数据来源:wms_pack_task 表。
*/
class OrderPackingService extends Service {
/**
* 打包任务列表查询(仓库侧)。
* 按仓库维度(warehouse_id)查询打包任务,支持分页、筛选、排序。
*
* @param {Object} where 筛选条件对象
* @param {Object} [where.status] 任务状态:0=待处理 1=打包中 2=已完成 3=异常
* @param {Object} [where.pack_mode] 打包模式:1=散单 2=团购
* @param {Object} [where.waybill_code] 运单号(模糊匹配)
* @param {Object} [where.wave_no] 波次号(模糊匹配)
* @param {Object} [where.order_id] 订单ID(精确匹配)
* @param {Object} [where.workbench_id] 工作台ID(精确匹配)
* @param {Object} [where.quickWhere] 快捷搜索:支持波次号模糊匹配;运单号通过 express→order→wave 链路解析(团购按波次号查、散单按订单ID查)
* @param {Object} [where.start_time_start] 开始打包时间起始
* @param {Object} [where.start_time_end] 开始打包时间结束
* @param {Object} pagination 分页参数 { page, pageSize }
* @param {Object} sort 排序参数 { sortField, sortOrder }
* @return {Promise<Object>} 打包任务列表与分页信息
*/
async list(where = {}, pagination = {}, sort = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const page = Math.max(Number(pagination.page) || 1, 1);
const pageSize = Math.max(Number(pagination.pageSize) || 20, 1);
// 仓库上下文
const warehouseId = Number(ctx.user && ctx.user.store_id);
if (!warehouseId) {
return {
code: 400,
message: '用户未绑定仓库,无法查询打包任务',
data: {
list: [],
pagination: { page, pageSize, total: 0, totalPages: 0, hasPrevious: false, hasNext: false },
},
};
}
// 构建查询条件
const queryWhere = { warehouse_id: warehouseId };
// 状态筛选
if (where.status !== undefined && where.status !== null) {
const statusValue = where.status?.value ?? where.status;
if (statusValue !== '' && statusValue !== undefined && statusValue !== null) {
queryWhere.status = Number(statusValue);
}
}
// 打包模式筛选
if (where.pack_mode !== undefined && where.pack_mode !== null) {
const packModeValue = where.pack_mode?.value ?? where.pack_mode;
if (packModeValue !== '' && packModeValue !== undefined && packModeValue !== null) {
queryWhere.pack_mode = Number(packModeValue);
}
}
// 运单号模糊匹配
if (where.waybill_code) {
const waybillValue = where.waybill_code?.value ?? where.waybill_code;
if (waybillValue && String(waybillValue).trim()) {
queryWhere.waybill_code = { [Op.like]: `%${String(waybillValue).trim()}%` };
}
}
// 波次号模糊匹配
if (where.wave_no) {
const waveNoValue = where.wave_no?.value ?? where.wave_no;
if (waveNoValue && String(waveNoValue).trim()) {
queryWhere.wave_no = { [Op.like]: `%${String(waveNoValue).trim()}%` };
}
}
// 订单ID精确匹配
if (where.order_id !== undefined && where.order_id !== null) {
const orderIdValue = where.order_id?.value ?? where.order_id;
if (orderIdValue !== '' && orderIdValue !== undefined && orderIdValue !== null) {
queryWhere.order_id = Number(orderIdValue);
}
}
// 工作台ID精确匹配
if (where.workbench_id !== undefined && where.workbench_id !== null) {
const workbenchIdValue = where.workbench_id?.value ?? where.workbench_id;
if (workbenchIdValue !== '' && workbenchIdValue !== undefined && workbenchIdValue !== null) {
queryWhere.workbench_id = Number(workbenchIdValue);
}
}
// 快捷搜索:支持波次号直接模糊匹配 + 运单号通过 express → order → wave 链路解析
if (where.quickWhere) {
const quickValue = where.quickWhere?.value ?? where.quickWhere;
if (quickValue && String(quickValue).trim()) {
const kw = String(quickValue).trim();
const orConditions = [];
// 1. 波次号直接模糊匹配(用户可能直接搜波次号)
orConditions.push({ wave_no: { [Op.like]: `%${kw}%` } });
// 2. 运单号解析:express → order → wave
// 团购波次 → 按 wave_no 查 packing 表;散单 → 按 order_id 查 packing 表
const expressRecords = await ctx.model.OrderExpress.findAll({
where: {
waybill_code: { [Op.like]: `%${kw}%` },
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'order_id' ],
raw: true,
});
if (expressRecords.length > 0) {
const orderIds = [ ...new Set(expressRecords.map(r => r.order_id).filter(Boolean)) ];
if (orderIds.length > 0) {
// 查 order_delivery 获取 wave_id
const orderRecords = await ctx.model.OrderDelivery.findAll({
where: { id: { [Op.in]: orderIds }, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
});
// order_id → wave_id 映射
const orderWaveMap = new Map();
const noWaveOrderIds = [];
orderRecords.forEach(o => {
if (o.wave_id > 0) {
orderWaveMap.set(o.id, o.wave_id);
} else {
noWaveOrderIds.push(o.id);
}
});
// 未匹配到 order_delivery 的 order_id 也按散单处理
const matchedOrderIds = new Set(orderRecords.map(o => o.id));
orderIds.forEach(oid => {
if (!matchedOrderIds.has(oid)) {
noWaveOrderIds.push(oid);
}
});
const waveIds = [ ...new Set(orderWaveMap.values()) ];
if (waveIds.length > 0) {
// 查 wms_wave_batch 获取 wave_type 和 wave_no
const waveRecords = await ctx.model.WaveBatch.findAll({
where: { wave_id: { [Op.in]: waveIds } },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// wave_id → { wave_no, wave_type } 映射
const waveMap = new Map();
waveRecords.forEach(w => {
waveMap.set(w.wave_id, { wave_no: w.wave_no, wave_type: w.wave_type });
});
// 分离:团购波次号 / 散单订单ID
const groupBuyWaveNos = [];
const singleOrderIds = [ ...noWaveOrderIds ];
orderRecords.forEach(o => {
const waveInfo = waveMap.get(o.wave_id);
if (waveInfo) {
if (waveInfo.wave_type === 1) {
// 团购 → 按波次号查 packing 表
if (waveInfo.wave_no) {
groupBuyWaveNos.push(waveInfo.wave_no);
}
} else {
// 散单(wave_type=2) → 按 order_id 查 packing 表
singleOrderIds.push(o.id);
}
} else {
// wave_id 在 wms_wave_batch 中不存在,按散单处理
singleOrderIds.push(o.id);
}
});
if (groupBuyWaveNos.length > 0) {
orConditions.push({ wave_no: { [Op.in]: [ ...new Set(groupBuyWaveNos) ] } });
}
if (singleOrderIds.length > 0) {
orConditions.push({ order_id: { [Op.in]: [ ...new Set(singleOrderIds) ] } });
}
} else {
// 所有订单都没有波次(wave_id = 0),全部按散单处理
orConditions.push({ order_id: { [Op.in]: orderIds } });
}
}
}
queryWhere[Op.or] = orConditions;
}
}
// 开始打包时间范围
if (where.start_time_start) {
const startTimeStart = where.start_time_start?.value ?? where.start_time_start;
if (startTimeStart) {
queryWhere.start_time = { ...(queryWhere.start_time || {}), [Op.gte]: new Date(startTimeStart) };
}
}
if (where.start_time_end) {
const startTimeEnd = where.start_time_end?.value ?? where.start_time_end;
if (startTimeEnd) {
queryWhere.start_time = { ...(queryWhere.start_time || {}), [Op.lte]: new Date(startTimeEnd) };
}
}
// 排序
const sortField = sort.sortField || 'create_time';
const sortOrder = String(sort.sortOrder || 'DESC').toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
const validSortFields = [ 'id', 'order_id', 'warehouse_id', 'workbench_id', 'wave_id', 'pack_quantity', 'pack_mode', 'status', 'start_time', 'end_time', 'create_time', 'update_time' ];
const actualSortField = validSortFields.includes(sortField) ? sortField : 'create_time';
// 查询(含工作台、视频和运单关联)
const { count, rows } = await ctx.model.PackTask.findAndCountAll({
where: queryWhere,
order: [[ actualSortField, sortOrder ]],
limit: pageSize,
offset: (page - 1) * pageSize,
include: [
{
model: ctx.model.Workbench,
as: 'workbench',
attributes: [ 'id', 'name', 'type', 'barcode' ],
},
{
model: ctx.model.PackTaskVideo,
as: 'videos',
attributes: [ 'id', 'video_url', 'camera_id', 'status' ],
where: { status: 1 },
required: false,
include: [
{
model: ctx.model.Camera,
as: 'camera',
attributes: [ 'id', 'custom_name', 'channel_name' ],
},
],
},
{
model: ctx.model.OrderExpress,
as: 'expresses',
attributes: [ 'id', 'waybill_code', 'logistics_code', 'logistics_name', 'logistics_interface_name', 'platform_code', 'status' ],
where: { delete_at: null },
required: false,
},
],
});
// 扁平化输出
const list = rows.map(row => {
const plain = row.get({ plain: true });
return {
...plain,
workbench_name: plain.workbench?.name || null,
workbench_type: plain.workbench?.type || null,
workbench_barcode: plain.workbench?.barcode || null,
videos: (plain.videos || []).map(v => ({
id: v.id,
video_url: v.video_url,
camera_id: v.camera_id,
camera_name: v.camera?.custom_name || v.camera?.channel_name || null,
})),
expresses: (plain.expresses || []).map(e => ({
id: e.id,
waybill_code: e.waybill_code,
logistics_code: e.logistics_code,
logistics_name: e.logistics_name,
logistics_interface_name: e.logistics_interface_name || null,
platform_code: e.platform_code || null,
status: e.status,
})),
workbench: undefined,
};
});
const totalPages = Math.ceil(count / pageSize) || 0;
return {
code: 200,
message: 'ok',
data: {
list,
pagination: {
page,
pageSize,
total: count,
totalPages,
hasPrevious: page > 1,
hasNext: page < totalPages,
},
},
};
}
/**
* 打包任务详情查询。
* 按 id + warehouse_id 查询单条打包任务记录。
*
* @param {Object} options 查询参数
* @param {number} options.id 打包任务ID
* @return {Promise<Object>} 打包任务详情
*/
async get(options = {}) {
const { ctx } = this;
const { id } = options;
if (!id) {
return { code: 400, message: '打包任务ID不能为空', data: null };
}
const warehouseId = Number(ctx.user && ctx.user.store_id);
if (!warehouseId) {
return { code: 400, message: '用户未绑定仓库,无法查询打包任务', data: null };
}
const record = await ctx.model.PackTask.findOne({
where: { id: Number(id), warehouse_id: warehouseId },
include: [
{
model: ctx.model.Workbench,
as: 'workbench',
attributes: [ 'id', 'name', 'type', 'barcode' ],
},
{
model: ctx.model.PackTaskVideo,
as: 'videos',
attributes: [ 'id', 'video_url', 'camera_id', 'status' ],
where: { status: 1 },
required: false,
include: [
{
model: ctx.model.Camera,
as: 'camera',
attributes: [ 'id', 'custom_name', 'channel_name' ],
},
],
},
{
model: ctx.model.OrderExpress,
as: 'expresses',
attributes: [ 'id', 'waybill_code', 'logistics_code', 'logistics_name', 'logistics_interface_name', 'platform_code', 'status' ],
where: { delete_at: null },
required: false,
},
],
});
if (!record) {
return { code: 404, message: '打包任务不存在或无权访问', data: null };
}
const plain = record.get({ plain: true });
const data = {
...plain,
workbench_name: plain.workbench?.name || null,
workbench_type: plain.workbench?.type || null,
workbench_barcode: plain.workbench?.barcode || null,
videos: (plain.videos || []).map(v => ({
id: v.id,
video_url: v.video_url,
camera_id: v.camera_id,
camera_name: v.camera?.custom_name || v.camera?.channel_name || null,
})),
expresses: (plain.expresses || []).map(e => ({
id: e.id,
waybill_code: e.waybill_code,
logistics_code: e.logistics_code,
logistics_name: e.logistics_name,
logistics_interface_name: e.logistics_interface_name || null,
platform_code: e.platform_code || null,
status: e.status,
})),
workbench: undefined,
};
return { code: 200, message: 'ok', data };
}
}
module.exports = OrderPackingService;

View File

@ -252,6 +252,39 @@ class OrderPrintSystemService extends OrderBaseService {
}
}
// 兜底:若 current items 表未命中全部 orderItemId,补查 dispatch items 表
// 配送表订单的 items 可能已迁移到 dispatch items 表,getCurrentModel 查不到
const foundItemIds = new Set([ ...orderItemMap.keys() ]);
const missingItemIds = orderItemIds.filter(id => !foundItemIds.has(id));
const dispatchItemRows = [];
if (missingItemIds.length > 0 && orderItemModelFactory && typeof orderItemModelFactory.getDispatchModel === 'function') {
try {
const dispatchItemModel = await orderItemModelFactory.getDispatchModel(warehouseId);
if (dispatchItemModel && typeof dispatchItemModel.findAll === 'function') {
const dispatchRows = await dispatchItemModel.findAll({
where: {
id: {
[Op.in]: missingItemIds,
},
},
attributes: [ 'id', 'order_id', 'item_code', 'item_name', 'plan_qty', 'item_snapshot', 'stock_id' ],
raw: true,
});
if (Array.isArray(dispatchRows)) {
for (const row of dispatchRows) {
const orderItemId = Number(row && row.id || 0);
if (orderItemId > 0 && !orderItemMap.has(orderItemId)) {
orderItemMap.set(orderItemId, row);
dispatchItemRows.push(row);
}
}
}
}
} catch (err) {
this.ctx.logger.warn('[buildPrintOrderRowMapWithPicking] dispatch items 兜底查询失败:%s', err.message);
}
}
const locationFallbackSpaceIds = Array.from(new Set(normalizedPickingRows
.filter(row => !String(row && row.space_name || '').trim())
.map(row => Number(row && row.space_id || 0))
@ -306,6 +339,15 @@ class OrderPrintSystemService extends OrderBaseService {
}
}
// 1c) 从 dispatch items 兜底收集 stock_id(配送表订单的 items 可能在 dispatch items 表)
for (const row of dispatchItemRows) {
const itemSnapshot = this.normalizeItemSnapshot(row.item_snapshot);
const stockId = Number(row.stock_id || itemSnapshot.stock_id || 0);
if (stockId > 0) {
allStockIds.add(stockId);
}
}
const uniqueStockIds = Array.from(allStockIds);
// 阶段二:批量查询 wms_stock_warehouse 获取商品编码与名称(新增直读路径)
@ -681,7 +723,7 @@ class OrderPrintSystemService extends OrderBaseService {
const orderIds = unlockedOrderRows
.map(row => Number(row && row.id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0);
const orderExpressRows = await this.queryOrderExpressByOrderIds(orderIds);
const orderExpressRows = await this.queryOrderExpressByOrderIds(orderIds, normalizedWarehouseId);
this.assertBusinessWaybillCompleteness(orderIds, orderExpressRows);
const cainiaoEnrichedOrderExpressRows = await this.enrichCainiaoOrderExpressRows(
unlockedOrderRows,
@ -856,7 +898,7 @@ class OrderPrintSystemService extends OrderBaseService {
const orderIdsForExpress = validOrderRows
.map(row => Number(row && row.id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0);
const orderExpressRows = await this.queryOrderExpressByOrderIds(orderIdsForExpress);
const orderExpressRows = await this.queryOrderExpressByOrderIds(orderIdsForExpress, normalizedWarehouseId);
this.assertBusinessWaybillCompleteness(orderIdsForExpress, orderExpressRows);
const cainiaoEnrichedOrderExpressRows = await this.enrichCainiaoOrderExpressRows(
validOrderRows,
@ -1599,7 +1641,7 @@ class OrderPrintSystemService extends OrderBaseService {
* logistics_code、logistics_name、logistics_interface_id、logistics_interface_name、platform_code、
* warehouse_id、printinfo、signature、encryptprintinfo、ver。
*/
async queryOrderExpressByOrderIds(orderIds = []) {
async queryOrderExpressByOrderIds(orderIds = [], warehouseId) {
if (!Array.isArray(orderIds) || orderIds.length === 0) {
return [];
}
@ -1632,6 +1674,7 @@ class OrderPrintSystemService extends OrderBaseService {
order_id: {
[Op.in]: normalizedOrderIds,
},
warehouse_id: warehouseId,
business_key: 1,
},
order: [[ 'order_id', 'ASC' ], [ 'business_key', 'ASC' ], [ 'id', 'ASC' ]],

View File

@ -26,11 +26,16 @@ class WaybillService extends MainService {
this.throwError('运单号不能为空');
}
const userWarehouseId = ctx.user && ctx.user.store_id ? ctx.user.store_id : null;
const expressWhere = {
waybill_code: String(waybillCode).trim(),
status: 1,
};
if (userWarehouseId) {
expressWhere.warehouse_id = userWarehouseId;
}
const record = await ctx.model.OrderExpress.findOne({
where: {
waybill_code: String(waybillCode).trim(),
status: 1,
},
where: expressWhere,
attributes: [ 'order_id', 'warehouse_id' ],
raw: true,
});

View File

@ -0,0 +1,615 @@
'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 || {});
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;
}
/**
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录
* @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: workbenchId,
status: packStatus, pack_time: packTime } = params;
if (!deliveryOrderCode) throw new Error('发货单号不能为空');
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
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 (workbenchId) {
try {
const wb = await ctx.model.Workbench.findByPk(parseInt(workbenchId), {
attributes: ['device_ids'],
raw: true,
});
deviceIds = wb && wb.device_ids ? wb.device_ids : null;
} catch (_err) { /* ignore */ }
}
// 步骤4:同一工作台有新的打包任务时,关闭上一个未结束的任务
if (workbenchId) {
const previousTask = await ctx.model.PackTask.findOne({
where: {
workbench_id: parseInt(workbenchId),
warehouse_id: warehouseId,
order_id: { [ctx.app.Sequelize.Op.ne]: orderId },
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
});
if (previousTask) {
await previousTask.update({ end_time: new Date(packTimeMs), status: 2 });
ctx.logger.info('[Workbench._packOrder] 关闭上一个未结束任务 taskId=%d orderId=%d workbenchId=%d',
previousTask.id, previousTask.order_id, workbenchId);
}
}
// 步骤5:查找是否已有该订单的打包任务
let packTask = await ctx.model.PackTask.findOne({
where: { order_id: orderId, warehouse_id: warehouseId, status: { [ctx.app.Sequelize.Op.lt]: 2 } },
});
const packData = {
order_id: orderId,
warehouse_id: warehouseId,
workbench_id: workbenchId ? parseInt(workbenchId) : null,
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: orderRow.items_total || 0,
start_time: packTask ? packTask.start_time : new Date(packTimeMs),
end_time: packStatus >= 2 ? new Date(packTimeMs) : null,
device_ids: deviceIds,
};
if (packTask) {
// 更新已有任务
await packTask.update(packData);
ctx.logger.info('[Workbench._packOrder] 更新打包任务 taskId=%d orderId=%d', packTask.id, orderId);
} else {
packTask = await ctx.model.PackTask.create(packData);
ctx.logger.info('[Workbench._packOrder] 创建打包任务 taskId=%d orderId=%d', packTask.id, orderId);
}
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;
}
/**
* 条码查订单:条码 → 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_qty', 'stock_id', 'order_line_no',
'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 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_qty: item.actual_qty,
stock_id: stockId,
order_line_no: item.order_line_no || '',
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);
}
const result = {
barcode: normalizedBarcode,
waybill_code: waybillCode,
isSandan,
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;