liufumingren 0c3518e65d 1
2026-05-13 03:18:39 +08:00

1122 lines
39 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 REVIEWED_INSPECTION_STATUS = 'fin';
const PICK_MODE_VIEW_META_MAP = {
1: {
mode_code: '1',
mode_name: '团购小波次',
require_box_allocations: true,
},
2: {
mode_code: '2',
mode_name: '散单单品单件',
require_box_allocations: false,
},
3: {
mode_code: '3',
mode_name: '散单先拣后分',
require_box_allocations: true,
},
4: {
mode_code: '4',
mode_name: '边拣边分',
require_box_allocations: true,
},
5: {
mode_code: '5',
mode_name: '团购大波次',
require_box_allocations: false,
},
};
class PickSystemService extends Service {
/**
* 按仓库获取订单分表模型。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<Object|null>} 订单模型对象。
*/
async getOrderModel(warehouseId) {
const factory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!factory || typeof factory.getCurrentModel !== 'function') {
throw this.createBusinessError('订单分表模型工厂不可用', 500);
}
const model = await factory.getCurrentModel(warehouseId);
if (!model || typeof model.findOne !== 'function' || typeof model.findAll !== 'function') {
throw this.createBusinessError('订单分表模型不可用', 500);
}
return model;
}
/**
* 生成带业务状态码的错误对象。
*
* @param {string} message 错误文案。
* @param {number} [code=400] 错误码。
* @return {Error} 错误对象。
*/
createBusinessError(message, code = 400) {
const error = new Error(message);
error.code = code;
return error;
}
/**
* 获取数据表列名集合。
*
* 用于在不确定列是否存在时进行安全查询拼装,避免因列缺失导致 SQL 执行失败。
*
* @param {string} tableName 数据表名。
* @return {Promise<Set<string>>} 列名集合。
*/
async getTableColumnSet(tableName) {
const { ctx } = this;
const normalizedTableName = String(tableName || '').trim();
if (!normalizedTableName) {
return new Set();
}
const escapedTableName = normalizedTableName.replace(/`/g, '``');
try {
const rows = await ctx.model.query(`SHOW COLUMNS FROM \`${escapedTableName}\``, {
type: ctx.model.QueryTypes.SELECT,
});
return new Set((Array.isArray(rows) ? rows : [])
.map(row => String(row && row.Field || '').trim())
.filter(Boolean));
} catch (error) {
ctx.logger.warn(`[pick.wavePickTaskDetail] 获取表字段失败,table=${normalizedTableName},将按兜底处理: ${error.message}`);
return new Set();
}
}
/**
* 读取订单商品分表数据并构建索引。
*
* 优先使用 OrderItemsFactory 当前分表模型;若模型不可用或查询失败,返回空映射而不抛异常。
*
* @param {Object} params 查询参数。
* @param {number} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderItemIds 订单明细ID列表。
* @return {Promise<Map<number, Object>>} 订单明细映射。
*/
async loadOrderItemMap(params = {}) {
const { ctx } = this;
const warehouseId = Number(params && params.warehouseId || 0);
const orderItemIds = Array.isArray(params && params.orderItemIds)
? params.orderItemIds.filter(id => Number.isInteger(id) && id > 0)
: [];
if (!Number.isInteger(warehouseId) || warehouseId <= 0 || orderItemIds.length === 0) {
return new Map();
}
const factory = ctx.model && ctx.model.OrderItemsFactory;
if (!factory || typeof factory.getCurrentModel !== 'function') {
return new Map();
}
try {
const orderItemModel = await factory.getCurrentModel(warehouseId);
if (!orderItemModel || typeof orderItemModel.findAll !== 'function') {
return new Map();
}
const orderItemRows = await orderItemModel.findAll({
where: {
id: {
[this.app.Sequelize.Op.in]: orderItemIds,
},
},
attributes: [ 'id', 'item_code', 'item_name', 'stock_id', 'plan_qty', 'item_snapshot' ],
raw: true,
});
return new Map((Array.isArray(orderItemRows) ? orderItemRows : [])
.map(row => [ Number(row && row.id || 0), row ]));
} catch (error) {
ctx.logger.warn(`[pick.wavePickTaskDetail] 订单商品分表查询失败,将按空字段降级: ${error.message}`);
return new Map();
}
}
/**
* 生成拣货明细汇总信息。
*
* @param {Array<Object>} pickingDetails 拣货明细列表。
* @return {{total_lines: number, total_qty: number, distinct_spaces: number, distinct_items: number}} 汇总结果。
*/
buildPickingSummary(pickingDetails = []) {
const normalizedDetails = Array.isArray(pickingDetails) ? pickingDetails : [];
const distinctSpaceIds = new Set();
const distinctItemKeys = new Set();
for (const detail of normalizedDetails) {
const spaceId = Number(detail && detail.space_id || 0);
if (spaceId > 0) {
distinctSpaceIds.add(spaceId);
}
const itemCode = String(detail && detail.item_code || '').trim();
const orderItemId = Number(detail && detail.order_item_id || 0);
if (itemCode) {
distinctItemKeys.add(`code:${itemCode}`);
} else if (orderItemId > 0) {
distinctItemKeys.add(`order_item_id:${orderItemId}`);
}
}
return {
total_lines: normalizedDetails.length,
total_qty: normalizedDetails.reduce((sum, detail) => sum + Number(detail && detail.quantity || 0), 0),
distinct_spaces: distinctSpaceIds.size,
distinct_items: distinctItemKeys.size,
};
}
/**
* 获取拣货模式视图元信息。
*
* @param {number} pickMode 拣货模式编码。
* @return {{mode_code: number, mode_name: string, require_box_allocations: boolean}} 视图元信息。
*/
getPickModeViewMeta(pickMode) {
const normalizedPickMode = Number(pickMode || 0);
const baseMeta = PICK_MODE_VIEW_META_MAP[normalizedPickMode] || {
mode_code: normalizedPickMode || 0,
mode_name: '未知模式',
require_box_allocations: false,
};
return {
mode_code: Number(baseMeta.mode_code || 0),
mode_name: String(baseMeta.mode_name || '').trim(),
require_box_allocations: Boolean(baseMeta.require_box_allocations),
};
}
/**
* 加载订单与波次映射关系。
*
* @param {Object} params 查询参数。
* @param {number} params.warehouseId 仓库ID。
* @param {Array<number>} params.orderIds 订单ID列表。
* @return {Promise<Map<number, number>>} 订单ID到wave_id映射。
*/
async loadOrderWaveMap(params = {}) {
const { ctx } = this;
const warehouseId = Number(params && params.warehouseId || 0);
const orderIds = Array.isArray(params && params.orderIds)
? params.orderIds.filter(id => Number.isInteger(id) && id > 0)
: [];
if (!Number.isInteger(warehouseId) || warehouseId <= 0 || orderIds.length === 0) {
return new Map();
}
try {
const orderModel = await this.getOrderModel(warehouseId);
const orderRows = await orderModel.findAll({
where: {
id: {
[this.app.Sequelize.Op.in]: orderIds,
},
warehouse_id: warehouseId,
},
attributes: [ 'id', 'wave_id' ],
raw: true,
});
return new Map((Array.isArray(orderRows) ? orderRows : [])
.map(row => [ Number(row && row.id || 0), Number(row && row.wave_id || 0) ])
.filter(([ orderId, waveId ]) => orderId > 0 && waveId > 0));
} catch (error) {
ctx.logger.warn(`[pick.wavePickTaskDetail] 订单wave_id查询失败,将按空映射降级: ${error.message}`);
return new Map();
}
}
/**
* 构建按拣货模式区分的拣货形态视图。
*
* @param {Object} params 构建参数。
* @param {number} params.pickMode 拣货模式。
* @param {number} params.taskId 任务ID。
* @param {number} params.warehouseId 仓库ID。
* @param {Array<Object>} params.pickingDetails 拣货明细。
* @param {Array<Object>} params.boxRows 框明细。
* @param {Array<Object>} params.taskOrderRows 任务订单关联明细。
* @param {Map<number, Object>} params.boxMapByNo 框号到框信息映射。
* @return {Promise<Object>} picking_view 结构。
*/
async buildPickingView(params = {}) {
const { ctx } = this;
const pickMode = Number(params && params.pickMode || 0);
const taskId = Number(params && params.taskId || 0);
const warehouseId = Number(params && params.warehouseId || 0);
const pickingDetails = Array.isArray(params && params.pickingDetails) ? params.pickingDetails : [];
const boxRows = Array.isArray(params && params.boxRows) ? params.boxRows : [];
const taskOrderRows = Array.isArray(params && params.taskOrderRows) ? params.taskOrderRows : [];
const boxMapByNo = params && params.boxMapByNo instanceof Map ? params.boxMapByNo : new Map();
const pickMeta = this.getPickModeViewMeta(pickMode);
const groupMap = new Map();
const buildGroupKey = detail => {
const spaceId = Number(detail && detail.space_id || 0);
const itemCode = String(detail && detail.item_code || '').trim();
const stockId = Number(detail && detail.stock_id || 0);
if (itemCode) {
return `${spaceId}::${itemCode}`;
}
return `${spaceId}::stock_${stockId}`;
};
for (const detail of pickingDetails) {
const groupKey = buildGroupKey(detail);
if (!groupMap.has(groupKey)) {
groupMap.set(groupKey, {
space_id: Number(detail && detail.space_id || 0),
space_name: String(detail && detail.space_name || '').trim(),
location_space: detail && detail.location_space ? detail.location_space : null,
item_code: String(detail && detail.item_code || '').trim(),
item_name: String(detail && detail.item_name || '').trim(),
stock_id: Number(detail && detail.stock_id || 0),
total_qty: 0,
box_allocations: [],
details: [],
});
}
const groupItem = groupMap.get(groupKey);
groupItem.total_qty += Number(detail && detail.quantity || 0);
groupItem.details.push(detail);
}
const allocationMapByGroup = new Map();
const appendAllocation = (groupKey, boxId, allocatedQty) => {
const normalizedBoxId = Number(boxId || 0);
const normalizedQty = Number(allocatedQty || 0);
if (normalizedBoxId <= 0 || normalizedQty <= 0) {
return;
}
if (!allocationMapByGroup.has(groupKey)) {
allocationMapByGroup.set(groupKey, new Map());
}
const groupAllocationMap = allocationMapByGroup.get(groupKey);
groupAllocationMap.set(
normalizedBoxId,
Number(groupAllocationMap.get(normalizedBoxId) || 0) + normalizedQty
);
};
if (pickMeta.require_box_allocations) {
if (pickMode === 4) {
const boxNosByOrderId = new Map();
for (const row of taskOrderRows) {
const orderId = Number(row && row.order_id || 0);
const boxNo = Number(row && row.box_no || 0);
if (orderId <= 0 || boxNo <= 0) {
continue;
}
if (!boxNosByOrderId.has(orderId)) {
boxNosByOrderId.set(orderId, new Set());
}
boxNosByOrderId.get(orderId).add(boxNo);
}
for (const [ groupKey, groupItem ] of groupMap) {
for (const detail of groupItem.details) {
const orderId = Number(detail && detail.order_id || 0);
const quantity = Number(detail && detail.quantity || 0);
const boxNos = boxNosByOrderId.get(orderId);
if (!boxNos || quantity <= 0) {
continue;
}
for (const boxNo of boxNos) {
const boxInfo = boxMapByNo.get(Number(boxNo || 0));
const boxId = Number(boxInfo && boxInfo.box_id || 0);
appendAllocation(groupKey, boxId, quantity);
}
}
}
} else if (pickMode === 1) {
const taskWaveColumnSet = await this.getTableColumnSet('wms_wave_pick_task_wave');
const taskWaveWarehouseFilterSql = taskWaveColumnSet.has('warehouse_id') ? ' AND ptw.warehouse_id = :warehouseId' : '';
const taskWaveRows = await ctx.model.query(`
SELECT
ptw.wave_id,
ptw.box_no
FROM wms_wave_pick_task_wave ptw
WHERE ptw.task_id = :taskId
${taskWaveWarehouseFilterSql}
ORDER BY ptw.id ASC
`, {
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
});
const waveToBoxNosMap = new Map();
for (const row of Array.isArray(taskWaveRows) ? taskWaveRows : []) {
const waveId = Number(row && row.wave_id || 0);
const boxNo = Number(row && row.box_no || 0);
if (waveId <= 0 || boxNo <= 0) {
continue;
}
if (!waveToBoxNosMap.has(waveId)) {
waveToBoxNosMap.set(waveId, new Set());
}
waveToBoxNosMap.get(waveId).add(boxNo);
}
const orderIds = [ ...new Set(pickingDetails
.map(detail => Number(detail && detail.order_id || 0))
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
const orderWaveMap = await this.loadOrderWaveMap({
warehouseId,
orderIds,
});
for (const [ groupKey, groupItem ] of groupMap) {
for (const detail of groupItem.details) {
const orderId = Number(detail && detail.order_id || 0);
const quantity = Number(detail && detail.quantity || 0);
const waveId = Number(orderWaveMap.get(orderId) || 0);
const boxNos = waveToBoxNosMap.get(waveId);
if (!boxNos || quantity <= 0) {
continue;
}
for (const boxNo of boxNos) {
const boxInfo = boxMapByNo.get(Number(boxNo || 0));
const boxId = Number(boxInfo && boxInfo.box_id || 0);
appendAllocation(groupKey, boxId, quantity);
}
}
}
} else if (pickMode === 3) {
const boxMapByRefId = new Map();
for (const row of boxRows) {
const refId = Number(row && row.ref_id || 0);
const boxId = Number(row && row.box_id || 0);
if (refId <= 0 || boxId <= 0) {
continue;
}
if (!boxMapByRefId.has(refId)) {
boxMapByRefId.set(refId, []);
}
boxMapByRefId.get(refId).push(row);
}
for (const [ groupKey, groupItem ] of groupMap) {
const stockId = Number(groupItem && groupItem.stock_id || 0);
const targetBoxes = boxMapByRefId.get(stockId);
if (!Array.isArray(targetBoxes) || targetBoxes.length === 0) {
continue;
}
const groupQty = Number(groupItem && groupItem.total_qty || 0);
if (groupQty <= 0) {
continue;
}
for (const boxInfo of targetBoxes) {
appendAllocation(groupKey, Number(boxInfo && boxInfo.box_id || 0), groupQty);
}
}
}
}
const itemList = Array.from(groupMap.entries()).map(([ groupKey, groupItem ]) => {
const groupAllocationMap = allocationMapByGroup.get(groupKey) || new Map();
const boxAllocations = pickMeta.require_box_allocations
? Array.from(groupAllocationMap.entries())
.map(([ boxId, allocatedQty ]) => {
const boxInfo = boxRows.find(row => Number(row && row.box_id || 0) === Number(boxId || 0)) || {};
return {
box_id: Number(boxInfo && boxInfo.box_id || 0),
box_no: Number(boxInfo && boxInfo.box_no || 0),
box_type: Number(boxInfo && boxInfo.box_type || 0),
required_qty: Number(boxInfo && boxInfo.required_qty || 0),
picked_qty: Number(boxInfo && boxInfo.picked_qty || 0),
allocated_qty: Number(allocatedQty || 0),
};
})
.sort((a, b) => {
const boxNoA = Number(a && a.box_no || 0);
const boxNoB = Number(b && b.box_no || 0);
if (boxNoA !== boxNoB) {
return boxNoA - boxNoB;
}
return Number(a && a.box_id || 0) - Number(b && b.box_id || 0);
})
: [];
return {
space_id: Number(groupItem && groupItem.space_id || 0),
space_name: String(groupItem && groupItem.space_name || '').trim(),
location_space: groupItem && groupItem.location_space ? groupItem.location_space : null,
item_code: String(groupItem && groupItem.item_code || '').trim(),
item_name: String(groupItem && groupItem.item_name || '').trim(),
stock_id: Number(groupItem && groupItem.stock_id || 0),
total_qty: Number(groupItem && groupItem.total_qty || 0),
box_allocations: boxAllocations,
};
});
itemList.sort((a, b) => {
const sequenceA = Number(a && a.location_space && a.location_space.pick_sequence || 0);
const sequenceB = Number(b && b.location_space && b.location_space.pick_sequence || 0);
if (sequenceA !== sequenceB) {
return sequenceA - sequenceB;
}
const priorityA = Number(a && a.location_space && a.location_space.pick_priority || 0);
const priorityB = Number(b && b.location_space && b.location_space.pick_priority || 0);
if (priorityA !== priorityB) {
return priorityA - priorityB;
}
const spaceIdA = Number(a && a.space_id || 0);
const spaceIdB = Number(b && b.space_id || 0);
if (spaceIdA !== spaceIdB) {
return spaceIdA - spaceIdB;
}
const itemCodeA = String(a && a.item_code || '').trim();
const itemCodeB = String(b && b.item_code || '').trim();
return itemCodeA.localeCompare(itemCodeB);
});
return {
mode_code: pickMeta.mode_code,
mode_name: pickMeta.mode_name,
require_box_allocations: pickMeta.require_box_allocations,
group_by: 'space+item',
sort_by: [ 'pick_sequence', 'pick_priority', 'space_id', 'item_code' ],
items: itemList,
};
}
/**
* 解析订单所属波次信息。
*
* @param {Object} order 订单记录。
* @return {{waveId: number, waveNo: string}} 波次信息。
*/
resolveWaveInfo(order = {}) {
const waveId = Number(order.wave_id || 0);
const waveNo = String(order.wave_no || '').trim();
return {
waveId: Number.isFinite(waveId) ? waveId : 0,
waveNo,
};
}
/**
* 判断订单是否已复核。
*
* 当前使用 `inspection_status === "fin"` 作为已复核判定。
*
* @param {Object} order 订单记录。
* @return {boolean} 是否已复核。
*/
isOrderReviewed(order = {}) {
return String(order.inspection_status || '').trim() === REVIEWED_INSPECTION_STATUS;
}
/**
* 根据波次信息构建订单查询条件。
*
* @param {Object} waveInfo 波次信息。
* @param {number} warehouseId 仓库ID。
* @return {Object} Sequelize 查询条件。
*/
buildWaveOrderWhere(waveInfo = {}, warehouseId) {
const { Op } = this.app.Sequelize;
const where = {
warehouse_id: warehouseId,
};
if (waveInfo.waveId > 0 && waveInfo.waveNo) {
where[Op.or] = [
{ wave_id: waveInfo.waveId },
{ wave_no: waveInfo.waveNo },
];
return where;
}
if (waveInfo.waveId > 0) {
where.wave_id = waveInfo.waveId;
return where;
}
where.wave_no = waveInfo.waveNo;
return where;
}
/**
* 按波次信息查询拣货汇总。
*
* @param {Object} params 查询参数。
* @param {number} params.orderId 当前订单ID。
* @param {number} params.warehouseId 仓库ID。
* @param {string} [params.waveNo] 波次号。
* @param {number} [params.waveId] 波次ID。
* @param {number} [params.storeId] 货主ID。
* @param {boolean} params.fullDisplay 是否完整显示。
* @return {Promise<Object>} 波次拣货汇总结果。
*/
async queryPickingInfo(params = {}) {
const { Op } = this.app.Sequelize;
const { ctx } = this;
const {
orderId,
warehouseId,
waveNo,
waveId,
storeId,
fullDisplay,
} = params;
const normalizedOrderId = Number(orderId || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw this.createBusinessError('order_id 参数不合法', 400);
}
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw this.createBusinessError('缺少当前用户仓库上下文 store_id', 400);
}
const waveInfo = {
waveId: Number(waveId || 0),
waveNo: String(waveNo || '').trim(),
};
if (waveInfo.waveId <= 0 && !waveInfo.waveNo) {
throw this.createBusinessError('订单未分配波次号,暂无拣货信息', 400);
}
const orderModel = await this.getOrderModel(normalizedWarehouseId);
const waveOrderRows = await orderModel.findAll({
where: this.buildWaveOrderWhere(waveInfo, normalizedWarehouseId),
attributes: [ 'id', 'inspection_status', 'store_id' ],
raw: true,
});
const orderIds = Array.isArray(waveOrderRows)
? waveOrderRows
.map(item => Number(item && item.id || 0))
.filter(id => id > 0)
: [];
if (orderIds.length === 0) {
throw this.createBusinessError('未找到波次对应订单', 404);
}
const orderStatusMap = new Map();
for (const row of waveOrderRows) {
const id = Number(row && row.id || 0);
if (id <= 0) {
continue;
}
orderStatusMap.set(id, {
inspection_status: String(row && row.inspection_status || '').trim(),
});
}
const pickingRows = await ctx.model.Picking.findAll({
where: {
order_id: {
[Op.in]: orderIds,
},
},
order: [[ 'id', 'ASC' ]],
raw: true,
});
const spaceIds = Array.isArray(pickingRows)
? Array.from(new Set(pickingRows
.map(item => Number(item && item.space_id || 0))
.filter(id => id > 0)))
: [];
const locationRows = spaceIds.length > 0
? await ctx.model.LocationSpace.findAll({
where: {
id: {
[Op.in]: spaceIds,
},
warehouse_id: normalizedWarehouseId,
},
attributes: [
'id',
'space_code',
'custom_name',
'custom_barcode',
'zone_id',
'space_status',
'is_enabled',
'pick_sequence',
'pick_priority',
],
raw: true,
})
: [];
const locationMap = new Map();
for (const location of Array.isArray(locationRows) ? locationRows : []) {
const locationId = Number(location && location.id || 0);
if (locationId > 0) {
locationMap.set(locationId, location);
}
}
const currentStoreId = Number(storeId || (waveOrderRows[0] && waveOrderRows[0].store_id) || 0);
const storeWarehouse = await ctx.model.StoreWarehouse.findOne({
where: {
store_id: currentStoreId,
warehouse_id: normalizedWarehouseId,
},
attributes: [ 'id', 'store_id', 'warehouse_id', 'store_remask', 'warehouse_remask', 'auth_status', 'use_status' ],
raw: true,
});
const fullDisplayFlag = Boolean(fullDisplay);
const allDetails = (Array.isArray(pickingRows) ? pickingRows : []).map(row => {
const currentOrderId = Number(row && row.order_id || 0);
const orderStatus = orderStatusMap.get(currentOrderId) || { inspection_status: 'none' };
const reviewed = this.isOrderReviewed(orderStatus);
const spaceId = Number(row && row.space_id || 0);
return {
id: Number(row && row.id || 0),
order_id: currentOrderId,
order_item_id: Number(row && row.order_item_id || 0),
storage_id: Number(row && row.storage_id || 0),
quantity: Number(row && row.quantity || 0),
space_id: spaceId,
space_name: String(row && row.space_name || ''),
picking_status: String(row && row.status || ''),
inspection_status: orderStatus.inspection_status,
reviewed,
location_space: locationMap.get(spaceId) || null,
store_warehouse: storeWarehouse || null,
};
});
const pendingReviewDetails = allDetails.filter(item => !item.reviewed);
const reviewedDetails = allDetails.filter(item => item.reviewed);
const displayDetails = fullDisplayFlag ? allDetails : pendingReviewDetails;
const sumQuantity = rows => rows.reduce((sum, item) => sum + Number(item && item.quantity || 0), 0);
return {
order_id: normalizedOrderId,
wave_id: waveInfo.waveId,
wave_no: waveInfo.waveNo,
full_display: fullDisplayFlag,
summary: {
total_count: allDetails.length,
pending_review_count: pendingReviewDetails.length,
reviewed_count: reviewedDetails.length,
quantity_total: sumQuantity(allDetails),
display_count: displayDetails.length,
display_quantity_total: sumQuantity(displayDetails),
},
list: displayDetails,
};
}
/**
* 按订单ID查询其波次拣货信息。
*
* @param {Object} params 查询参数。
* @param {number} params.orderId 订单ID。
* @param {number} params.warehouseId 仓库ID。
* @param {boolean} params.fullDisplay 是否完整显示。
* @return {Promise<Object>} 波次拣货汇总结果。
*/
async queryByOrder(params = {}) {
const {
orderId,
warehouseId,
fullDisplay,
} = params;
const normalizedOrderId = Number(orderId || 0);
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
throw this.createBusinessError('order_id 参数不合法', 400);
}
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw this.createBusinessError('缺少当前用户仓库上下文 store_id', 400);
}
const orderModel = await this.getOrderModel(normalizedWarehouseId);
const order = await orderModel.findOne({
where: {
id: normalizedOrderId,
warehouse_id: normalizedWarehouseId,
},
attributes: [ 'id', 'store_id', 'wave_no', 'wave_id' ],
raw: true,
});
if (!order) {
throw this.createBusinessError('订单不存在', 404);
}
const waveInfo = this.resolveWaveInfo(order);
if (waveInfo.waveId <= 0 && !waveInfo.waveNo) {
throw this.createBusinessError('订单未分配波次号,暂无拣货信息', 400);
}
return await this.queryPickingInfo({
orderId: normalizedOrderId,
warehouseId: normalizedWarehouseId,
waveNo: waveInfo.waveNo,
waveId: waveInfo.waveId,
storeId: Number(order.store_id || 0),
fullDisplay,
});
}
/**
* 查询当前登录用户正在处理中的拣货任务。
*
* 仅供 PDA 使用:根据当前登录用户上下文(仓库 + 操作人)查询状态为 0/1/2 的最新任务。
*
* @param {Object} [params={}] 预留参数(当前无需传入)。
* @return {Promise<{task_id: number|null}>} 当前任务ID,无任务则为 null。
*/
async wavePickTaskCurrent(params = {}) {
const { ctx } = this;
void params;
const stateUser = ctx && ctx.state && ctx.state.user && typeof ctx.state.user === 'object'
? ctx.state.user
: null;
const ctxUser = ctx && ctx.user && typeof ctx.user === 'object'
? ctx.user
: null;
const currentUser = stateUser || ctxUser || {};
const warehouseId = Number(
currentUser.store_id
|| currentUser.warehouse_id
|| (ctxUser && (ctxUser.store_id || ctxUser.warehouse_id))
|| 0
);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
throw this.createBusinessError('缺少当前用户仓库上下文 store_id', 400);
}
const pickUserId = Number(
currentUser.employees_id
|| currentUser.operator_id
|| currentUser.id
|| (ctxUser && (ctxUser.employees_id || ctxUser.operator_id || ctxUser.id))
|| 0
);
if (!Number.isInteger(pickUserId) || pickUserId <= 0) {
throw this.createBusinessError('未获取到操作人上下文', 401);
}
const taskRows = await ctx.model.query(`
SELECT
t.id AS task_id
FROM wms_wave_pick_task t
WHERE t.warehouse_id = :warehouseId
AND t.pick_user_id = :pickUserId
AND t.status IN (0, 1, 2)
ORDER BY t.id DESC
LIMIT 1
`, {
replacements: {
warehouseId,
pickUserId,
},
type: ctx.model.QueryTypes.SELECT,
});
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
const taskId = Number(taskRow && taskRow.task_id || 0);
return {
task_id: Number.isInteger(taskId) && taskId > 0 ? taskId : null,
};
}
/**
* 查询拣货任务详情。
*
* 按 task_id 查询任务主信息,并返回与拣货直接相关的框明细与拣货明细;
* 仅允许任务创建人(pick_user_id)查看。
*
* @param {Object} params 查询参数。
* @param {number} params.taskId 任务ID。
* @param {number} params.operatorId 当前操作人ID。
* @return {Promise<{task: Object, boxes: Array<Object>, picking_details: Array<Object>, picking_summary: Object, picking_view: Object}>} 任务详情。
*/
async wavePickTaskDetail(params = {}) {
const { ctx } = this;
const taskId = Number(params && params.taskId || 0);
const operatorId = Number(params && params.operatorId || 0);
if (!Number.isInteger(taskId) || taskId <= 0) {
throw this.createBusinessError('task_id 必填且必须为正整数', 400);
}
if (!Number.isInteger(operatorId) || operatorId <= 0) {
throw this.createBusinessError('未获取到操作人上下文', 401);
}
const taskRows = await ctx.model.query(`
SELECT
t.id AS task_id,
t.task_no,
t.status,
t.pick_mode,
t.pick_user_id,
t.start_time AS start_at,
t.finish_time AS finish_at,
t.batch_no,
t.warehouse_id
FROM wms_wave_pick_task t
WHERE t.id = :taskId
LIMIT 1
`, {
replacements: { taskId },
type: ctx.model.QueryTypes.SELECT,
});
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
if (!taskRow) {
throw this.createBusinessError('拣货任务不存在', 404);
}
const taskPickUserId = Number(taskRow.pick_user_id || 0);
if (!Number.isInteger(taskPickUserId) || taskPickUserId !== operatorId) {
throw this.createBusinessError('当前操作人与任务创建人不一致,无权查看', 403);
}
const warehouseId = Number(taskRow.warehouse_id || 0);
const pickMode = Number(taskRow.pick_mode || 0);
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
const taskWaveColumnSet = await this.getTableColumnSet('wms_wave_pick_task_wave');
const boxColumnSet = await this.getTableColumnSet('wms_wave_pick_task_box');
const taskOrderWarehouseFilterSql = taskOrderColumnSet.has('warehouse_id') ? ' AND pto.warehouse_id = :warehouseId' : '';
const taskWaveWarehouseFilterSql = taskWaveColumnSet.has('warehouse_id') ? ' AND ptw.warehouse_id = :warehouseId' : '';
const boxWarehouseFilterSql = boxColumnSet.has('warehouse_id') ? ' AND b.warehouse_id = :warehouseId' : '';
const boxExtraSelect = [];
if (boxColumnSet.has('ref_label')) {
boxExtraSelect.push('b.ref_label');
}
if (boxColumnSet.has('required_qty')) {
boxExtraSelect.push('b.required_qty');
}
if (boxColumnSet.has('picked_qty')) {
boxExtraSelect.push('b.picked_qty');
}
if (boxColumnSet.has('ref_id')) {
boxExtraSelect.push('b.ref_id');
}
const [ taskOrderRows, boxRows ] = await Promise.all([
ctx.model.query(`
SELECT
pto.order_id,
pto.box_no
FROM wms_wave_pick_task_order pto
WHERE pto.task_id = :taskId
${taskOrderWarehouseFilterSql}
ORDER BY pto.id ASC
`, {
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}),
ctx.model.query(`
SELECT
b.id AS box_id,
b.box_no,
b.box_type,
b.box_status AS status${boxExtraSelect.length > 0 ? `,\n ${boxExtraSelect.join(',\n ')}` : ''}
FROM wms_wave_pick_task_box b
WHERE b.task_id = :taskId
${boxWarehouseFilterSql}
ORDER BY b.id ASC
`, {
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
}),
]);
const normalizedTaskOrderRows = Array.isArray(taskOrderRows) ? taskOrderRows : [];
let orderIds = [ ...new Set(normalizedTaskOrderRows
.map(row => Number(row && row.order_id || 0))
.filter(orderIdItem => Number.isInteger(orderIdItem) && orderIdItem > 0)) ];
let taskWaveCount = 0;
let orderSource = 'task_order';
const derivedWaveIds = [];
if (orderIds.length === 0 && [ 1, 5 ].includes(pickMode)) {
const taskWaveRows = await ctx.model.query(`
SELECT
ptw.wave_id
FROM wms_wave_pick_task_wave ptw
WHERE ptw.task_id = :taskId
${taskWaveWarehouseFilterSql}
ORDER BY ptw.id ASC
`, {
replacements: { taskId, warehouseId },
type: ctx.model.QueryTypes.SELECT,
});
const normalizedTaskWaveRows = Array.isArray(taskWaveRows) ? taskWaveRows : [];
taskWaveCount = normalizedTaskWaveRows.length;
const fallbackWaveIds = [ ...new Set(normalizedTaskWaveRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
derivedWaveIds.push(...fallbackWaveIds.slice(0, 5));
if (fallbackWaveIds.length > 0) {
const orderModel = await this.getOrderModel(warehouseId);
const fallbackOrderRows = await orderModel.findAll({
where: {
wave_id: {
[this.app.Sequelize.Op.in]: fallbackWaveIds,
},
warehouse_id: warehouseId,
},
attributes: [ 'id' ],
raw: true,
});
orderIds = [ ...new Set((Array.isArray(fallbackOrderRows) ? fallbackOrderRows : [])
.map(row => Number(row && row.id || 0))
.filter(orderIdItem => Number.isInteger(orderIdItem) && orderIdItem > 0)) ];
if (orderIds.length > 0) {
orderSource = 'task_wave_fallback';
}
}
}
const pickingRows = orderIds.length > 0
? await ctx.model.Picking.findAll({
where: {
order_id: {
[this.app.Sequelize.Op.in]: orderIds,
},
},
attributes: [ 'id', 'order_id', 'order_item_id', 'quantity', 'storage_id', 'space_id', 'space_name' ],
order: [[ 'id', 'ASC' ]],
raw: true,
})
: [];
ctx.logger.info(
`[pick.wavePickTaskDetail] task_id=${taskId} pick_mode=${pickMode} warehouse_id=${warehouseId} task_order_count=${normalizedTaskOrderRows.length} task_wave_count=${taskWaveCount} derived_order_ids_count=${orderIds.length} picking_rows_count=${Array.isArray(pickingRows) ? pickingRows.length : 0} order_source=${orderSource} order_id_samples=${JSON.stringify(orderIds.slice(0, 5))} wave_id_samples=${JSON.stringify(derivedWaveIds)}`
);
const pickingSpaceIds = [ ...new Set((Array.isArray(pickingRows) ? pickingRows : [])
.map(row => Number(row && row.space_id || 0))
.filter(spaceId => Number.isInteger(spaceId) && spaceId > 0)) ];
const locationRows = pickingSpaceIds.length > 0
? await ctx.model.LocationSpace.findAll({
where: {
id: {
[this.app.Sequelize.Op.in]: pickingSpaceIds,
},
},
attributes: [ 'id', 'space_code', 'custom_name', 'custom_barcode', 'pick_sequence', 'pick_priority' ],
raw: true,
})
: [];
const locationMap = new Map((Array.isArray(locationRows) ? locationRows : [])
.map(row => [ Number(row && row.id || 0), row ]));
const orderItemIds = [ ...new Set((Array.isArray(pickingRows) ? pickingRows : [])
.map(row => Number(row && row.order_item_id || 0))
.filter(orderItemId => Number.isInteger(orderItemId) && orderItemId > 0)) ];
const orderItemMap = await this.loadOrderItemMap({
warehouseId,
orderItemIds,
});
const normalizedBoxRows = Array.isArray(boxRows) ? boxRows : [];
const boxMapByNo = new Map(normalizedBoxRows
.map(row => [ Number(row && row.box_no || 0), row ])
.filter(([ boxNo ]) => boxNo > 0));
const pickingDetails = (Array.isArray(pickingRows) ? pickingRows : []).map(row => {
const orderItemId = Number(row && row.order_item_id || 0);
const currentSpaceId = Number(row && row.space_id || 0);
const locationRow = locationMap.get(currentSpaceId) || {};
const orderItemRow = orderItemMap.get(orderItemId) || {};
return {
order_id: Number(row && row.order_id || 0),
order_item_id: orderItemId,
quantity: Number(row && row.quantity || 0),
storage_id: Number(row && row.storage_id || 0),
space_id: currentSpaceId,
space_name: String(row && row.space_name || '').trim(),
location_space: {
space_code: String(locationRow.space_code || '').trim(),
custom_name: String(locationRow.custom_name || '').trim(),
custom_barcode: String(locationRow.custom_barcode || '').trim(),
pick_sequence: Number(locationRow.pick_sequence || 0),
pick_priority: Number(locationRow.pick_priority || 0),
},
item_code: String(orderItemRow.item_code || '').trim(),
item_name: String(orderItemRow.item_name || '').trim(),
stock_id: Number(orderItemRow.stock_id || 0),
plan_qty: Number(orderItemRow.plan_qty || 0),
item_snapshot: orderItemRow.item_snapshot || null,
};
});
const pickingSummary = this.buildPickingSummary(pickingDetails);
const pickingView = await this.buildPickingView({
pickMode,
taskId,
warehouseId,
pickingDetails,
boxRows: normalizedBoxRows,
taskOrderRows: normalizedTaskOrderRows,
boxMapByNo,
});
return {
task: {
task_id: Number(taskRow.task_id || 0),
task_no: String(taskRow.task_no || '').trim(),
status: Number(taskRow.status || 0),
pick_mode: pickMode,
start_at: taskRow.start_at || null,
finish_at: taskRow.finish_at || null,
batch_no: String(taskRow.batch_no || '').trim(),
},
boxes: normalizedBoxRows.map(row => ({
box_id: Number(row && row.box_id || 0),
box_no: Number(row && row.box_no || 0),
box_type: Number(row && row.box_type || 0),
status: Number(row && row.status || 0),
ref_id: Number(row && row.ref_id || 0),
ref_label: String(row && row.ref_label || '').trim() || null,
required_qty: Number(row && row.required_qty || 0),
picked_qty: Number(row && row.picked_qty || 0),
})),
picking_details: pickingDetails,
picking_summary: pickingSummary,
picking_view: pickingView,
};
}
}
module.exports = PickSystemService;