WMS_MAIN/app/service/systems/workbench.js
liufumingren 52aa76af60 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 过滤
2026-07-21 20:53:53 +08:00

616 lines
20 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 || {});
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;