1122 lines
39 KiB
JavaScript
1122 lines
39 KiB
JavaScript
'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;
|