2071 lines
75 KiB
JavaScript
2071 lines
75 KiB
JavaScript
'use strict';
|
||
|
||
const { Op } = require('sequelize');
|
||
const MainService = require('../main');
|
||
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
|
||
|
||
class PickService extends MainService {
|
||
/**
|
||
* 初始化 pick 模块鉴权配置。
|
||
*
|
||
* @param {Egg.Context} ctx 上下文对象。
|
||
*/
|
||
constructor(ctx) {
|
||
super(ctx);
|
||
const _noNeedLogin = '';
|
||
const _noNeedRight = 'query,wavePickComplete,wavePickTaskDetail,wavePickTaskCurrent,wavePickTaskSubmit,wavePickTaskComplete,waveClaimScan';
|
||
const _noNeedLog = 'query';
|
||
const _noNeedAuth = 'query,wavePickComplete,wavePickTaskDetail,wavePickTaskCurrent,wavePickTaskSubmit,wavePickTaskComplete,waveClaimScan';
|
||
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
|
||
}
|
||
|
||
/**
|
||
* 将入参标准化为布尔值。
|
||
*
|
||
* 兼容 `true/false`、`1/0`、`yes/no`、`on/off` 以及大小写字符串。
|
||
*
|
||
* @param {*} value 原始值。
|
||
* @param {boolean} defaultValue 默认值。
|
||
* @return {boolean} 解析后的布尔值。
|
||
*/
|
||
normalizeBoolean(value, defaultValue = false) {
|
||
if (value === undefined || value === null || value === '') {
|
||
return defaultValue;
|
||
}
|
||
|
||
if (typeof value === 'boolean') {
|
||
return value;
|
||
}
|
||
|
||
const normalized = String(value).trim().toLowerCase();
|
||
if ([ '1', 'true', 'yes', 'y', 'on' ].includes(normalized)) {
|
||
return true;
|
||
}
|
||
if ([ '0', 'false', 'no', 'n', 'off' ].includes(normalized)) {
|
||
return false;
|
||
}
|
||
|
||
return defaultValue;
|
||
}
|
||
|
||
/**
|
||
* 按仓库上下文获取订单分表模型。
|
||
*
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @return {Promise<Object>} 订单模型。
|
||
*/
|
||
async getOrderModelByWarehouse(warehouseId) {
|
||
const { ctx } = this;
|
||
const factory = ctx.model && ctx.model.OrderDeliveryFactory;
|
||
if (!factory || typeof factory.getCurrentModel !== 'function') {
|
||
throw new Error('订单分表模型工厂不可用');
|
||
}
|
||
|
||
const model = await factory.getCurrentModel(warehouseId);
|
||
if (!model || typeof model.findOne !== 'function') {
|
||
throw new Error('订单分表模型不可用');
|
||
}
|
||
|
||
return model;
|
||
}
|
||
|
||
/**
|
||
* 生成拣货任务编号。
|
||
*
|
||
* @return {string} 任务编号。
|
||
*/
|
||
generatePickTaskNo() {
|
||
const now = new Date();
|
||
const pad2 = value => String(value).padStart(2, '0');
|
||
const datePart = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}`;
|
||
const timePart = `${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
|
||
const randomPart = Math.random().toString(36).slice(2, 6)
|
||
.toUpperCase();
|
||
return `PK${datePart}${timePart}${randomPart}`;
|
||
}
|
||
|
||
/**
|
||
* 创建波次拣货任务及关联关系。
|
||
*
|
||
* @param {Object} params 创建参数。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {number} params.waveId 波次ID。
|
||
* @param {string} params.waveNo 波次号。
|
||
* @param {number} params.pickMode 拣货模式。
|
||
* @param {number} params.operatorId 操作人ID。
|
||
* @param {string} params.operatorName 操作人名称。
|
||
* @param {Array<number>} params.orderIds 波次订单ID集合。
|
||
* @param {string} [params.remark=''] 备注。
|
||
* @param {number} [params.source=2] 任务来源:1-PDA抓取创建,2-扫描进任务/后台抓取,默认为2。
|
||
* @param {boolean} [params.excludeUnclaimed=false] 普通波次(source=0)计算拣货数量时是否剔除未领料
|
||
* (claim_status != fin)订单:true 时未领料订单不写入任务订单/筐,也不计入 order_count。
|
||
* @return {Promise<{task_id: number, task_no: string}>} 创建结果。
|
||
*/
|
||
async createWavePickTask(params = {}) {
|
||
const { ctx } = this;
|
||
const warehouseId = Number(params && params.warehouseId || 0);
|
||
const waveId = Number(params && params.waveId || 0);
|
||
const waveNo = String(params && params.waveNo || '').trim();
|
||
const pickMode = Number(params && params.pickMode || 2);
|
||
const operatorId = Number(params && params.operatorId || 0);
|
||
const operatorName = String(params && params.operatorName || '').trim() || 'system';
|
||
const source = Number(params && params.source !== undefined ? params.source : 2);
|
||
const remark = String(params && params.remark || '').trim();
|
||
const excludeUnclaimed = Boolean(params && params.excludeUnclaimed);
|
||
const normalizedOrderIds = [ ...new Set((Array.isArray(params && params.orderIds) ? params.orderIds : [])
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
|
||
throw Object.assign(new Error('warehouse_id 参数不合法'), { code: 400 });
|
||
}
|
||
if (!Number.isInteger(waveId) || waveId <= 0 || !waveNo) {
|
||
throw Object.assign(new Error('目标波次信息不完整'), { code: 400 });
|
||
}
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
throw Object.assign(new Error('未获取到操作人上下文'), { code: 401 });
|
||
}
|
||
if (normalizedOrderIds.length <= 0) {
|
||
throw Object.assign(new Error('波次下无可用订单,无法创建任务'), { code: 400 });
|
||
}
|
||
|
||
const orderModel = await this.getOrderModelByWarehouse(warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
id: {
|
||
[this.app.Sequelize.Op.in]: normalizedOrderIds,
|
||
},
|
||
},
|
||
attributes: [ 'id', 'intercept_status', 'claim_status', 'claim_operator_id', 'claim_operator' ],
|
||
raw: true,
|
||
});
|
||
|
||
// 拦截流程中的订单不允许抓取波次,直接剔除
|
||
const orderRowMap = new Map((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(row => [ Number(row && row.id || 0), row ]));
|
||
const interceptedOrderIds = new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.filter(row => isInterceptedOrderStatus(row && row.intercept_status))
|
||
.map(row => Number(row && row.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0));
|
||
if (interceptedOrderIds.size > 0) {
|
||
const excludedIds = normalizedOrderIds.filter(id => interceptedOrderIds.has(id));
|
||
if (excludedIds.length > 0) {
|
||
ctx.logger.info('[pick.createWavePickTask] 剔除拦截订单: %s', excludedIds.join(','));
|
||
}
|
||
}
|
||
|
||
// 领料语义(普通波次 source=0):未领料或领料人非本人的订单不参与拣货数量计算,直接剔除
|
||
const unclaimedOrderIds = excludeUnclaimed
|
||
? new Set(normalizedOrderIds.filter(id => {
|
||
const row = orderRowMap.get(id);
|
||
if (!row || String(row && row.claim_status || '') !== 'fin') {
|
||
return true;
|
||
}
|
||
return Number(row && row.claim_operator_id || 0) !== operatorId;
|
||
}))
|
||
: new Set();
|
||
if (unclaimedOrderIds.size > 0) {
|
||
const excludedIds = normalizedOrderIds.filter(id => unclaimedOrderIds.has(id));
|
||
if (excludedIds.length > 0) {
|
||
ctx.logger.info('[pick.createWavePickTask] 剔除未领料订单: %s', excludedIds.join(','));
|
||
}
|
||
}
|
||
|
||
const activeOrderIds = normalizedOrderIds
|
||
.filter(id => !interceptedOrderIds.has(id) && !unclaimedOrderIds.has(id));
|
||
if (activeOrderIds.length <= 0) {
|
||
const emptyReason = unclaimedOrderIds.size > 0
|
||
? '波次下订单均未领料或均被拦截,无法创建任务'
|
||
: '波次下订单均已被拦截,无法创建任务';
|
||
throw Object.assign(new Error(emptyReason), { code: 400 });
|
||
}
|
||
|
||
// 取首个活跃订单的领料人冗余写入任务主表(整波领单同波次领料人一致)
|
||
const firstActiveOrderRow = orderRowMap.get(activeOrderIds[0]) || null;
|
||
const claimOperatorId = Number(firstActiveOrderRow && firstActiveOrderRow.claim_operator_id || 0);
|
||
const claimOperator = String(firstActiveOrderRow && firstActiveOrderRow.claim_operator || '').trim();
|
||
|
||
const orderNoMap = new Map((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(row => [ Number(row && row.id || 0), '' ]));
|
||
|
||
const taskNo = this.generatePickTaskNo();
|
||
const transaction = await ctx.model.transaction();
|
||
try {
|
||
const taskInsertResult = await ctx.model.query(
|
||
`
|
||
INSERT INTO wms_wave_pick_task (
|
||
task_no,
|
||
warehouse_id,
|
||
wave_id,
|
||
claim_operator_id,
|
||
claim_operator,
|
||
batch_no,
|
||
batch_no_array,
|
||
pick_mode,
|
||
status,
|
||
source,
|
||
wave_count,
|
||
order_count,
|
||
box_count,
|
||
pick_user_id,
|
||
pick_user_name,
|
||
remark,
|
||
create_time,
|
||
update_time
|
||
) VALUES (
|
||
:taskNo,
|
||
:warehouseId,
|
||
:waveId,
|
||
:claimOperatorId,
|
||
:claimOperator,
|
||
:batchNo,
|
||
:batchNoArray,
|
||
:pickMode,
|
||
0,
|
||
:source,
|
||
1,
|
||
:orderCount,
|
||
0,
|
||
:operatorId,
|
||
:operatorName,
|
||
:remark,
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskNo,
|
||
warehouseId,
|
||
waveId,
|
||
claimOperatorId: claimOperatorId > 0 ? claimOperatorId : null,
|
||
claimOperator: claimOperator || null,
|
||
batchNo: waveNo,
|
||
batchNoArray: waveNo,
|
||
pickMode,
|
||
source,
|
||
orderCount: activeOrderIds.length,
|
||
operatorId,
|
||
operatorName,
|
||
remark,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const taskInsertHead = Array.isArray(taskInsertResult) ? taskInsertResult[0] : null;
|
||
const taskInsertMeta = Array.isArray(taskInsertResult) ? taskInsertResult[1] : null;
|
||
let taskId = Number(
|
||
(taskInsertMeta && (taskInsertMeta.insertId || taskInsertMeta.lastID || taskInsertMeta.id))
|
||
|| (taskInsertHead && (taskInsertHead.insertId || taskInsertHead.lastID || taskInsertHead.id))
|
||
|| 0
|
||
);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
const taskIdRows = await ctx.model.query(
|
||
`
|
||
SELECT id
|
||
FROM wms_wave_pick_task
|
||
WHERE warehouse_id = :warehouseId
|
||
AND task_no = :taskNo
|
||
ORDER BY id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId,
|
||
taskNo,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
transaction,
|
||
}
|
||
);
|
||
const taskRow = Array.isArray(taskIdRows) && taskIdRows.length > 0 ? taskIdRows[0] : null;
|
||
taskId = Number(taskRow && taskRow.id || 0);
|
||
}
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
throw Object.assign(new Error('任务创建失败(未返回任务ID)'), { code: 500 });
|
||
}
|
||
|
||
await ctx.model.query(
|
||
`
|
||
INSERT INTO wms_wave_pick_task_wave (
|
||
task_id,
|
||
wave_id,
|
||
wave_no,
|
||
status,
|
||
warehouse_id,
|
||
bind_time,
|
||
create_time,
|
||
update_time
|
||
) VALUES (
|
||
:taskId,
|
||
:waveId,
|
||
:waveNo,
|
||
0,
|
||
:warehouseId,
|
||
NOW(),
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskId,
|
||
waveId,
|
||
waveNo,
|
||
warehouseId,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
if (activeOrderIds.length > 0) {
|
||
// 按库位排序并按 stock_id 分组,同 stock_id 的订单共享同一篮号
|
||
const stockGroups = await this.resolveLocationSortedOrderIds(
|
||
activeOrderIds,
|
||
warehouseId,
|
||
transaction
|
||
);
|
||
|
||
// 写入 wms_wave_pick_task_box:每个 stock_id 一个框,记录 stock_id → box_no 映射
|
||
const boxValuesSql = [];
|
||
const boxReplacements = {};
|
||
let boxNo = 0;
|
||
let boxIndex = 0;
|
||
for (const group of stockGroups) {
|
||
boxNo += 1;
|
||
const stockId = group.stock_id > 0 ? group.stock_id : 0;
|
||
const boxNoKey = `boxNo${boxIndex}`;
|
||
const stockIdKey = `stockId${boxIndex}`;
|
||
const boxCodeKey = `boxCode${boxIndex}`;
|
||
boxValuesSql.push(`(
|
||
:taskId,
|
||
NULL,
|
||
:${boxCodeKey},
|
||
:${boxNoKey},
|
||
1,
|
||
:${stockIdKey},
|
||
NULL,
|
||
0,
|
||
0,
|
||
0,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
:warehouseId,
|
||
NOW(),
|
||
NOW()
|
||
)`);
|
||
boxReplacements[boxNoKey] = boxNo;
|
||
boxReplacements[stockIdKey] = stockId;
|
||
boxReplacements[boxCodeKey] = `${taskNo}-S${boxNo}`;
|
||
boxIndex += 1;
|
||
}
|
||
|
||
if (boxValuesSql.length > 0) {
|
||
await ctx.model.query(
|
||
`
|
||
INSERT INTO wms_wave_pick_task_box (
|
||
task_id,
|
||
order_id,
|
||
box_code,
|
||
box_no,
|
||
box_type,
|
||
ref_id,
|
||
ref_label,
|
||
required_qty,
|
||
picked_qty,
|
||
box_status,
|
||
review_result,
|
||
review_user_id,
|
||
review_time,
|
||
warehouse_id,
|
||
create_time,
|
||
update_time
|
||
) VALUES ${boxValuesSql.join(',\n')}
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
...boxReplacements,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
// 更新任务主表的 box_count(大团购固定 1,其余按实际筐数)
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET box_count = :boxCount,
|
||
update_time = NOW()
|
||
WHERE id = :taskId`,
|
||
{
|
||
replacements: { taskId, boxCount: pickMode === 5 ? 1 : boxValuesSql.length },
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
|
||
// 写入 wms_wave_pick_task_order:每个订单写入一次(取该订单所属的最小 box_no)
|
||
const orderBoxMap = new Map();
|
||
boxNo = 0;
|
||
for (const group of stockGroups) {
|
||
boxNo += 1;
|
||
for (const orderId of group.order_ids) {
|
||
if (!orderBoxMap.has(orderId) || orderBoxMap.get(orderId) > boxNo) {
|
||
orderBoxMap.set(orderId, boxNo);
|
||
}
|
||
}
|
||
}
|
||
|
||
const orderValuesSql = [];
|
||
const orderReplacements = {};
|
||
let paramIndex = 0;
|
||
for (const [ orderId, orderBoxNo ] of orderBoxMap) {
|
||
const orderIdKey = `orderId${paramIndex}`;
|
||
const orderNoKey = `orderNo${paramIndex}`;
|
||
const boxNoKey = `oBoxNo${paramIndex}`;
|
||
orderValuesSql.push(`(
|
||
:taskId,
|
||
:waveId,
|
||
:${orderIdKey},
|
||
:${orderNoKey},
|
||
:${boxNoKey},
|
||
:warehouseId,
|
||
0,
|
||
0,
|
||
NOW(),
|
||
NOW()
|
||
)`);
|
||
orderReplacements[orderIdKey] = orderId;
|
||
orderReplacements[orderNoKey] = orderNoMap.get(orderId) || '';
|
||
orderReplacements[boxNoKey] = orderBoxNo;
|
||
paramIndex += 1;
|
||
}
|
||
|
||
await ctx.model.query(
|
||
`
|
||
INSERT INTO wms_wave_pick_task_order (
|
||
task_id,
|
||
wave_id,
|
||
order_id,
|
||
order_no,
|
||
box_no,
|
||
warehouse_id,
|
||
pick_status,
|
||
review_status,
|
||
create_time,
|
||
update_time
|
||
) VALUES ${orderValuesSql.join(',\n')}
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskId,
|
||
waveId,
|
||
warehouseId,
|
||
...orderReplacements,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
}
|
||
|
||
await transaction.commit();
|
||
|
||
// 写入 order_operation_log 开始拣货日志
|
||
try {
|
||
const operationLogService = this.ctx
|
||
&& this.ctx.service
|
||
&& this.ctx.service.systems
|
||
&& this.ctx.service.systems.operationLog;
|
||
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
|
||
const logPayloads = activeOrderIds.map(orderId => ({
|
||
businessType: 'order',
|
||
businessId: `${orderId}`,
|
||
operationCode: 'ORDER_PICKING',
|
||
operator: {
|
||
id: operatorId ? String(operatorId) : null,
|
||
name: operatorName || 'system',
|
||
},
|
||
extras: {
|
||
message: `订单${orderId}开始拣货(波次 ${waveNo})`,
|
||
warehouseId,
|
||
externalLogType: 'API',
|
||
},
|
||
}));
|
||
await operationLogService.createOperationLogs(logPayloads);
|
||
}
|
||
} catch (e) {
|
||
ctx.logger.warn('[pick.createWavePickTask] 写入 order_operation_log 失败,不影响主流程', {
|
||
error: e && e.message,
|
||
activeOrderIds,
|
||
});
|
||
}
|
||
|
||
return {
|
||
task_id: taskId,
|
||
task_no: taskNo,
|
||
};
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 按库位排序并按 stock_id 分组订单,使 box_no 按拣货路径顺序分配。
|
||
*
|
||
* 同 stock_id 的订单归入同一组(同一篮号),组间按 pick_sequence ASC 排序。
|
||
* 若某订单无拣货数据(未分配储位),排到末尾保持原顺序。
|
||
*
|
||
* @param {Array<number>} orderIds 订单ID列表。
|
||
* @param {number} warehouseId 仓库ID。
|
||
* @param {Object} [transaction] Sequelize 事务。
|
||
* @return {Promise<Array<{ stock_id: number, order_ids: number[] }>>} 按库位排序后的分组列表。
|
||
*/
|
||
async resolveLocationSortedOrderIds(orderIds, warehouseId, transaction) {
|
||
const { ctx } = this;
|
||
const normalizedOrderIds = [ ...new Set((Array.isArray(orderIds) ? orderIds : [])
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (normalizedOrderIds.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
if (normalizedOrderIds.length === 1) {
|
||
return [{ stock_id: 0, order_ids: normalizedOrderIds }];
|
||
}
|
||
|
||
try {
|
||
// 查询拣货明细获取 order_item_id 和 space_id
|
||
const pickingRows = await ctx.model.Picking.findAll({
|
||
where: {
|
||
order_id: { [this.app.Sequelize.Op.in]: normalizedOrderIds },
|
||
warehouse_id: warehouseId,
|
||
},
|
||
attributes: [ 'order_id', 'order_item_id', 'space_id' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
|
||
const normalizedPickingRows = Array.isArray(pickingRows) ? pickingRows : [];
|
||
const orderSpaceMap = new Map();
|
||
const orderItemIds = [];
|
||
for (const row of normalizedPickingRows) {
|
||
const oid = Number(row && row.order_id || 0);
|
||
const sid = Number(row && row.space_id || 0);
|
||
const oiid = Number(row && row.order_item_id || 0);
|
||
if (oid > 0 && !orderSpaceMap.has(oid)) {
|
||
orderSpaceMap.set(oid, sid);
|
||
}
|
||
if (oiid > 0) {
|
||
orderItemIds.push(oiid);
|
||
}
|
||
}
|
||
|
||
// 查询订单商品明细获取 stock_id,收集每个订单的所有 stock_id
|
||
const orderStockIdSet = new Map();
|
||
if (orderItemIds.length > 0) {
|
||
const factory = ctx.model && ctx.model.OrderItemsFactory;
|
||
if (factory && typeof factory.getCurrentModel === 'function') {
|
||
const orderItemModel = await factory.getCurrentModel(warehouseId);
|
||
if (orderItemModel && typeof orderItemModel.findAll === 'function') {
|
||
const itemRows = await orderItemModel.findAll({
|
||
where: {
|
||
id: { [this.app.Sequelize.Op.in]: [ ...new Set(orderItemIds) ] },
|
||
},
|
||
attributes: [ 'id', 'order_id', 'stock_id' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
for (const row of (Array.isArray(itemRows) ? itemRows : [])) {
|
||
const oid = Number(row && row.order_id || 0);
|
||
const stockId = Number(row && row.stock_id || 0);
|
||
if (oid > 0 && stockId > 0) {
|
||
if (!orderStockIdSet.has(oid)) {
|
||
orderStockIdSet.set(oid, new Set());
|
||
}
|
||
orderStockIdSet.get(oid).add(stockId);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 按 stock_id 分组:每个 stock_id 一个组,订单可出现在多个组(多商品订单)
|
||
const groupMap = new Map();
|
||
for (const oid of normalizedOrderIds) {
|
||
const stockIds = orderStockIdSet.get(oid);
|
||
if (stockIds && stockIds.size > 0) {
|
||
for (const stockId of stockIds) {
|
||
if (!groupMap.has(stockId)) {
|
||
groupMap.set(stockId, { stock_id: stockId, order_ids: [] });
|
||
}
|
||
groupMap.get(stockId).order_ids.push(oid);
|
||
}
|
||
} else {
|
||
const key = -oid; // 无 stock_id 的订单各自成组
|
||
if (!groupMap.has(key)) {
|
||
groupMap.set(key, { stock_id: 0, order_ids: [] });
|
||
}
|
||
groupMap.get(key).order_ids.push(oid);
|
||
}
|
||
}
|
||
|
||
const spaceIds = [ ...new Set([ ...orderSpaceMap.values() ].filter(sid => sid > 0)) ];
|
||
const sequenceMap = new Map();
|
||
if (spaceIds.length > 0) {
|
||
const locationRows = await ctx.model.LocationSpace.findAll({
|
||
where: { id: { [this.app.Sequelize.Op.in]: spaceIds } },
|
||
attributes: [ 'id', 'pick_sequence' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
for (const row of (Array.isArray(locationRows) ? locationRows : [])) {
|
||
const lid = Number(row && row.id || 0);
|
||
if (lid > 0 && !sequenceMap.has(lid)) {
|
||
sequenceMap.set(lid, Number(row.pick_sequence || 0));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 每组取最小 pick_sequence 排序
|
||
const groups = [ ...groupMap.values() ];
|
||
groups.sort((a, b) => {
|
||
const seqA = Math.min(...a.order_ids.map(oid => sequenceMap.get(orderSpaceMap.get(oid)) ?? Number.MAX_SAFE_INTEGER));
|
||
const seqB = Math.min(...b.order_ids.map(oid => sequenceMap.get(orderSpaceMap.get(oid)) ?? Number.MAX_SAFE_INTEGER));
|
||
if (seqA !== seqB) return seqA - seqB;
|
||
return a.order_ids[0] - b.order_ids[0];
|
||
});
|
||
|
||
return groups;
|
||
} catch (error) {
|
||
ctx.logger.warn('[pick.resolveLocationSortedOrderIds] 按库位排序失败,退回原顺序', {
|
||
error: error && error.message,
|
||
warehouseId,
|
||
orderCount: normalizedOrderIds.length,
|
||
});
|
||
return [{ stock_id: 0, order_ids: normalizedOrderIds }];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 按关键字获取或创建波次拣货任务。
|
||
*
|
||
* 关键字支持两种命中方式:
|
||
* - 命中运单号:先定位订单并强校验订单已入波次。
|
||
* - 命中波次号:直接按波次定位。
|
||
*
|
||
* 去重策略(按优先级):
|
||
* 1. 波次级去重:同一 warehouse_id + 同一 wave_id 且存在活动任务(status IN 0,1)时不再创建。
|
||
* 2. keyword 级去重:同一 warehouse_id + 同一 keyword(remark 字段)在 30 分钟内已有任务时不再创建。
|
||
* - 已完成(status IN 2,3):直接返回已有任务结果。
|
||
* - 进行中(status IN 0,1):返回冲突提示。
|
||
*
|
||
* 命中目标波次后按以下规则处理:
|
||
* - 若波次存在活动任务且创建人为当前用户:直接返回任务ID。
|
||
* - 若波次存在活动任务但创建人非当前用户:返回冲突失败信息。
|
||
* - 若波次不存在活动任务:按波次类型创建任务并返回任务ID。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {string} data.keyword 运单号或波次号关键字。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async query(data = {}) {
|
||
const { ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { keyword } = requestData;
|
||
|
||
const normalizedKeyword = String(keyword || '').trim();
|
||
if (!normalizedKeyword) {
|
||
return this.fail('请传入关键字 keyword', {}, 400);
|
||
}
|
||
|
||
const userWarehouseId = ctx && ctx.user ? ctx.user.store_id : undefined;
|
||
const stateWarehouseId = ctx && ctx.state && ctx.state.user ? ctx.state.user.store_id : undefined;
|
||
const normalizedWarehouseId = Number(userWarehouseId || stateWarehouseId || 0);
|
||
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return this.fail('缺少当前用户仓库上下文 store_id', {}, 400);
|
||
}
|
||
|
||
const stateUser = this.isPlainObject(ctx && ctx.state && ctx.state.user) ? ctx.state.user : null;
|
||
const ctxUser = this.isPlainObject(ctx && ctx.user) ? ctx.user : null;
|
||
const operatorSource = stateUser || ctxUser || {};
|
||
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
|
||
const operatorId = Number(rawOperatorId || 0);
|
||
const operatorName = String(
|
||
operatorSource.operator_name
|
||
|| operatorSource.employees_name
|
||
|| operatorSource.name
|
||
|| ''
|
||
).trim() || 'system';
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 401);
|
||
}
|
||
|
||
const orderExpress = await ctx.model.OrderExpress.findOne({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
waybill_code: normalizedKeyword,
|
||
},
|
||
attributes: [ 'order_id' ],
|
||
raw: true,
|
||
});
|
||
|
||
let targetWaveId = 0;
|
||
let targetWaveNo = '';
|
||
let targetWaveType = 2;
|
||
let targetWaveSource = 0;
|
||
let selectedOrderIds = [];
|
||
|
||
const orderId = Number(orderExpress && orderExpress.order_id || 0);
|
||
if (orderExpress && orderId > 0) {
|
||
let orderModel = null;
|
||
try {
|
||
orderModel = await this.getOrderModelByWarehouse(normalizedWarehouseId);
|
||
} catch (error) {
|
||
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
|
||
}
|
||
|
||
const order = await orderModel.findOne({
|
||
where: {
|
||
id: orderId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
},
|
||
attributes: [ 'id', 'wave_no', 'wave_id' ],
|
||
raw: true,
|
||
});
|
||
if (!order) {
|
||
return this.fail('运单对应订单不存在', {}, 404);
|
||
}
|
||
|
||
const orderWaveId = Number(order.wave_id || 0);
|
||
const orderWaveNo = String(order.wave_no || '').trim();
|
||
if (!(orderWaveId > 0 || orderWaveNo)) {
|
||
return this.fail('运单对应订单未进入波次,无法创建拣货任务', {}, 400);
|
||
}
|
||
|
||
if (orderWaveId > 0) {
|
||
const waveByIdRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id = :waveId
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveId: orderWaveId,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const waveRow = Array.isArray(waveByIdRows) && waveByIdRows.length > 0 ? waveByIdRows[0] : null;
|
||
if (!waveRow) {
|
||
return this.fail('运单对应波次不存在或不属于当前仓库', {}, 404);
|
||
}
|
||
|
||
targetWaveId = Number(waveRow.wave_id || 0);
|
||
targetWaveNo = String(waveRow.wave_no || '').trim();
|
||
targetWaveType = Number(waveRow.wave_type || 2);
|
||
targetWaveSource = Number(waveRow.source || 0);
|
||
} else {
|
||
const waveByNoRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_no = :waveNo
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveNo: orderWaveNo,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const waveRow = Array.isArray(waveByNoRows) && waveByNoRows.length > 0 ? waveByNoRows[0] : null;
|
||
if (!waveRow) {
|
||
return this.fail('运单对应波次不存在或不属于当前仓库', {}, 404);
|
||
}
|
||
|
||
targetWaveId = Number(waveRow.wave_id || 0);
|
||
targetWaveNo = String(waveRow.wave_no || '').trim();
|
||
targetWaveType = Number(waveRow.wave_type || 2);
|
||
targetWaveSource = Number(waveRow.source || 0);
|
||
}
|
||
} else {
|
||
const waveRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_no = :waveNo
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveNo: normalizedKeyword,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
|
||
if (!waveRow) {
|
||
return this.fail('关键字未命中运单号或波次号', {}, 404);
|
||
}
|
||
|
||
targetWaveId = Number(waveRow.wave_id || 0);
|
||
targetWaveNo = String(waveRow.wave_no || '').trim();
|
||
targetWaveType = Number(waveRow.wave_type || 2);
|
||
targetWaveSource = Number(waveRow.source || 0);
|
||
}
|
||
|
||
if (!Number.isInteger(targetWaveId) || targetWaveId <= 0 || !targetWaveNo) {
|
||
return this.fail('目标波次信息不完整', {}, 400);
|
||
}
|
||
|
||
// 领料前置校验:source=0 普通波次需整波领料,未领料阻隔创建拣货任务
|
||
// (拦截订单未领料不阻隔拣货,拦截订单将在任务创建时被剔除)
|
||
if (targetWaveSource === 0) {
|
||
const claimGatePickMode = await this.getWavePickModeByWaveId(targetWaveId);
|
||
let claimGateOrderModel = null;
|
||
try {
|
||
claimGateOrderModel = await this.getOrderModelByWarehouse(normalizedWarehouseId);
|
||
} catch (error) {
|
||
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
|
||
}
|
||
|
||
const claimGateStats = await this.getWaveClaimGateStats({
|
||
orderModel: claimGateOrderModel,
|
||
warehouseId: normalizedWarehouseId,
|
||
waveId: targetWaveId,
|
||
waveNo: targetWaveNo,
|
||
claimOperatorId: operatorId,
|
||
});
|
||
if (claimGateStats.total_order_count > 0 && claimGateStats.unclaimed_order_count > 0) {
|
||
return this.fail('订单未领料或领料人不是本人,请先领料后再拣货', {
|
||
action: 'wave_claim',
|
||
wave_id: targetWaveId,
|
||
wave_no: targetWaveNo,
|
||
wave_type: targetWaveType,
|
||
wave_source: targetWaveSource,
|
||
pick_mode: claimGatePickMode,
|
||
unclaimed_order_count: claimGateStats.unclaimed_order_count,
|
||
intercepted_order_count: claimGateStats.intercepted_order_count,
|
||
total_order_count: claimGateStats.total_order_count,
|
||
}, 400);
|
||
}
|
||
}
|
||
|
||
const activeTaskRows = await ctx.model.query(
|
||
`
|
||
SELECT t.id AS task_id, t.pick_user_id, t.pick_user_name
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.status IN (0, 1)
|
||
AND (
|
||
t.wave_id = :waveId
|
||
OR EXISTS (
|
||
SELECT 1
|
||
FROM wms_wave_pick_task_wave tw
|
||
WHERE tw.task_id = t.id
|
||
AND tw.wave_id = :waveId
|
||
)
|
||
)
|
||
ORDER BY t.id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
waveId: targetWaveId,
|
||
warehouseId: normalizedWarehouseId,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const activeTask = Array.isArray(activeTaskRows) && activeTaskRows.length > 0 ? activeTaskRows[0] : null;
|
||
if (activeTask) {
|
||
const activeTaskId = Number(activeTask.task_id || 0);
|
||
const taskOwnerId = Number(activeTask.pick_user_id || 0);
|
||
const taskOwnerName = String(activeTask.pick_user_name || '').trim() || `${taskOwnerId}`;
|
||
if (taskOwnerId > 0 && taskOwnerId === operatorId) {
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: activeTaskId,
|
||
status: 'existing',
|
||
tip: '当前波次已有您创建的活动任务,可直接继续',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
|
||
return this.fail(
|
||
`当前波次已由其他人创建活动任务,请移交任务创建人处理(创建人: ${taskOwnerName},任务ID: ${activeTaskId})`,
|
||
{
|
||
task_id: activeTaskId,
|
||
task_owner_id: taskOwnerId,
|
||
task_owner_name: taskOwnerName,
|
||
},
|
||
409
|
||
);
|
||
}
|
||
|
||
// 波次级已完成任务去重:同一 warehouse_id + 同一 wave_id 已有完成任务时不再创建
|
||
const completedTaskRows = await ctx.model.query(
|
||
`
|
||
SELECT t.id AS task_id, t.status, t.pick_user_id, t.pick_user_name
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.status IN (2, 3)
|
||
AND (
|
||
t.wave_id = :waveId
|
||
OR EXISTS (
|
||
SELECT 1
|
||
FROM wms_wave_pick_task_wave tw
|
||
WHERE tw.task_id = t.id
|
||
AND tw.wave_id = :waveId
|
||
)
|
||
)
|
||
ORDER BY t.id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
waveId: targetWaveId,
|
||
warehouseId: normalizedWarehouseId,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const completedTask = Array.isArray(completedTaskRows) && completedTaskRows.length > 0 ? completedTaskRows[0] : null;
|
||
if (completedTask) {
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: Number(completedTask.task_id),
|
||
status: 'existing_completed',
|
||
tip: '该波次已完成拣货任务,无需重复创建',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
|
||
// keyword 级别去重:同一 warehouse_id + 同一 keyword(remark)在 30 分钟内已有任务则不再创建
|
||
const keywordRemark = `pick.query keyword=${normalizedKeyword}`;
|
||
const keywordDedupRows = await ctx.model.query(
|
||
`
|
||
SELECT t.id AS task_id, t.status, t.pick_user_id, t.pick_user_name
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.remark = :remark
|
||
AND t.create_time >= DATE_SUB(NOW(), INTERVAL 30 MINUTE)
|
||
ORDER BY t.id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
remark: keywordRemark,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const keywordDedupTask = Array.isArray(keywordDedupRows) && keywordDedupRows.length > 0 ? keywordDedupRows[0] : null;
|
||
if (keywordDedupTask) {
|
||
const existingTaskId = Number(keywordDedupTask.task_id || 0);
|
||
const existingStatus = Number(keywordDedupTask.status ?? -1);
|
||
|
||
// 已完成(status=2 待复核 / status=3 已完成):直接返回已有结果,不创建新任务
|
||
if (existingStatus === 2 || existingStatus === 3) {
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: existingTaskId,
|
||
status: 'existing_completed',
|
||
tip: '该关键字近期已有完成任务,无需重复创建',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
|
||
// 进行中(status=0 待开始 / status=1 拣货中):返回已有任务ID,提示任务进行中
|
||
if (existingStatus === 0 || existingStatus === 1) {
|
||
const taskOwnerId = Number(keywordDedupTask.pick_user_id || 0);
|
||
const taskOwnerName = String(keywordDedupTask.pick_user_name || '').trim() || `${taskOwnerId}`;
|
||
return this.fail(
|
||
`该关键字近期已有进行中任务(创建人: ${taskOwnerName},任务ID: ${existingTaskId}),请稍后再试`,
|
||
{
|
||
task_id: existingTaskId,
|
||
task_owner_id: taskOwnerId,
|
||
task_owner_name: taskOwnerName,
|
||
},
|
||
409
|
||
);
|
||
}
|
||
}
|
||
|
||
const normalizedWaveType = Number(targetWaveType || 2);
|
||
const isGroupWave = normalizedWaveType === 1;
|
||
// 检查是否为 singleFetchByIds 创建的波次(item_part_type='manual_ids'),使用先拣后分模式
|
||
let isManualIdsWave = false;
|
||
try {
|
||
const waveInfoRows = await ctx.model.query(
|
||
`SELECT item_part_type
|
||
FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: targetWaveId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const waveInfo = Array.isArray(waveInfoRows) && waveInfoRows.length > 0 ? waveInfoRows[0] : null;
|
||
isManualIdsWave = String(waveInfo && waveInfo.item_part_type || '').trim() === 'manual_ids';
|
||
} catch (e) {
|
||
// 查询失败不影响主流程,退回默认拣货模式
|
||
}
|
||
const pickMode = isGroupWave ? 5 : (isManualIdsWave ? 3 : 2);
|
||
|
||
if (selectedOrderIds.length === 0) {
|
||
let orderModel = null;
|
||
try {
|
||
orderModel = await this.getOrderModelByWarehouse(normalizedWarehouseId);
|
||
} catch (error) {
|
||
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
|
||
}
|
||
|
||
const orderRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
wave_id: targetWaveId,
|
||
},
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
});
|
||
selectedOrderIds = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (selectedOrderIds.length <= 0) {
|
||
const fallbackRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
wave_no: targetWaveNo,
|
||
},
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
});
|
||
selectedOrderIds = [ ...new Set((Array.isArray(fallbackRows) ? fallbackRows : [])
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
}
|
||
|
||
if (selectedOrderIds.length <= 0) {
|
||
return this.fail('波次下无可用订单,无法创建任务', {}, 400);
|
||
}
|
||
}
|
||
|
||
// 跨波次订单级去重:检查这批订单是否已有已完成(status 2/3)的拣货任务
|
||
if (selectedOrderIds.length > 0) {
|
||
const crossWaveDedupRows = await ctx.model.query(
|
||
`
|
||
SELECT t.id AS task_id, t.task_no, t.status, t.pick_user_id, t.pick_user_name
|
||
FROM wms_wave_pick_task t
|
||
INNER JOIN wms_wave_pick_task_order pto
|
||
ON pto.task_id = t.id
|
||
AND pto.warehouse_id = t.warehouse_id
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.status IN (2, 3)
|
||
AND pto.order_id IN (:orderIds)
|
||
AND pto.pick_status = 1
|
||
ORDER BY t.id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
orderIds: selectedOrderIds,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const crossWaveDedupTask = Array.isArray(crossWaveDedupRows) && crossWaveDedupRows.length > 0
|
||
? crossWaveDedupRows[0]
|
||
: null;
|
||
if (crossWaveDedupTask) {
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: Number(crossWaveDedupTask.task_id),
|
||
status: 'existing_completed',
|
||
tip: '该批订单已有完成拣货任务,无需重复创建',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
}
|
||
|
||
try {
|
||
const createdTask = await this.createWavePickTask({
|
||
warehouseId: normalizedWarehouseId,
|
||
waveId: targetWaveId,
|
||
waveNo: targetWaveNo,
|
||
pickMode,
|
||
operatorId,
|
||
operatorName,
|
||
orderIds: selectedOrderIds,
|
||
remark: `pick.query keyword=${normalizedKeyword}`,
|
||
source: 2,
|
||
// 普通波次(source=0):计算拣货数量时剔除未领料(claim_status != fin)订单
|
||
excludeUnclaimed: targetWaveSource === 0,
|
||
});
|
||
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: createdTask.task_id,
|
||
status: 'created',
|
||
tip: '任务创建成功',
|
||
},
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isFinite(code) && code >= 400 && code < 600) {
|
||
return this.fail(error.message || '任务创建失败', {}, code);
|
||
}
|
||
|
||
ctx.logger.error('[PickService.query] 获取或创建波次任务失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('任务创建失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询拣货任务详情。
|
||
*
|
||
* 仅允许任务创建人查看任务详情,包含主任务、波次、订单与框信息。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {number|string} data.task_id 拣货任务ID。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async wavePickTaskDetail(data = {}) {
|
||
const { service, ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const { task_id } = requestData;
|
||
|
||
const taskId = Number(task_id);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return this.fail('task_id 必填且必须为正整数', {}, 400);
|
||
}
|
||
|
||
const stateUser = this.isPlainObject(ctx && ctx.state && ctx.state.user) ? ctx.state.user : null;
|
||
const ctxUser = this.isPlainObject(ctx && ctx.user) ? ctx.user : null;
|
||
const operatorSource = stateUser || ctxUser || {};
|
||
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
|
||
const operatorId = Number(rawOperatorId || 0);
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 401);
|
||
}
|
||
|
||
try {
|
||
const result = await service.systems.pick.wavePickTaskDetail({
|
||
taskId,
|
||
operatorId,
|
||
});
|
||
|
||
return this.success('ok', {
|
||
data: result,
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isInteger(code) && code >= 400 && code < 600) {
|
||
const errorData = this.isPlainObject(error && error.data) ? error.data : {};
|
||
return this.fail(error.message || '查询失败', errorData, code);
|
||
}
|
||
|
||
ctx.logger.error('[PickService.wavePickTaskDetail] 查询拣货任务详情失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('查询失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询当前登录用户正在处理中的拣货任务。
|
||
*
|
||
* 仅供 PDA 使用,无需入参;按当前登录用户与仓库上下文返回最新任务ID。
|
||
*
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async wavePickTaskCurrent() {
|
||
const { service, ctx } = this;
|
||
|
||
try {
|
||
const result = await service.systems.pick.wavePickTaskCurrent();
|
||
return this.success('ok', {
|
||
data: result,
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isInteger(code) && code >= 400 && code < 600) {
|
||
return this.fail(error.message || '查询失败', {}, code);
|
||
}
|
||
|
||
ctx.logger.error('[PickService.wavePickTaskCurrent] 查询当前拣货任务失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('查询失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 提交拣货任务中间态。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {number|string} data.task_id 拣货任务ID。
|
||
* @param {Object} [data.payload] 中间态业务数据。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async wavePickTaskSubmit(data = {}) {
|
||
const { service, ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const taskId = Number(requestData.task_id || requestData.taskId || 0);
|
||
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return this.fail('task_id 必填且必须为正整数', {}, 400);
|
||
}
|
||
|
||
try {
|
||
const result = await service.systems.pick.wavePickTaskSubmit({
|
||
taskId,
|
||
payload: this.isPlainObject(requestData.payload) ? requestData.payload : {},
|
||
});
|
||
|
||
return this.success('ok', {
|
||
data: result,
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isInteger(code) && code >= 400 && code < 600) {
|
||
const errorData = this.isPlainObject(error && error.data) ? error.data : {};
|
||
return this.fail(error.message || '提交失败', errorData, code);
|
||
}
|
||
|
||
ctx.logger.error('[PickService.wavePickTaskSubmit] 提交拣货任务中间态失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('提交失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 按波次号一键完成拣货。
|
||
*
|
||
* 内部复用 query 的去重与任务创建逻辑:
|
||
* - 若波次已有当前用户的活动任务 → 直接复用并完成。
|
||
* - 若波次已有他人活动任务 → 返回 409 冲突。
|
||
* - 若波次已完成 → 返回 already_completed。
|
||
* - 否则新建任务(source=2,后台抓取),创建成功后在内部调用 wavePickTaskComplete(mode=1 全部确认)完成拣货。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {number|string} data.wave_id 波次ID。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async wavePickComplete(data = {}) {
|
||
const { service, ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const waveId = Number(requestData.wave_id || requestData.waveId || 0);
|
||
|
||
if (!Number.isInteger(waveId) || waveId <= 0) {
|
||
return this.fail('wave_id 必填且必须为正整数', {}, 400);
|
||
}
|
||
|
||
// --- 解析操作人上下文(与 query 保持一致)---
|
||
const userWarehouseId = ctx && ctx.user ? ctx.user.store_id : undefined;
|
||
const stateWarehouseId = ctx && ctx.state && ctx.state.user ? ctx.state.user.store_id : undefined;
|
||
const normalizedWarehouseId = Number(userWarehouseId || stateWarehouseId || 0);
|
||
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return this.fail('缺少当前用户仓库上下文 store_id', {}, 400);
|
||
}
|
||
|
||
const stateUser = this.isPlainObject(ctx && ctx.state && ctx.state.user) ? ctx.state.user : null;
|
||
const ctxUser = this.isPlainObject(ctx && ctx.user) ? ctx.user : null;
|
||
const operatorSource = stateUser || ctxUser || {};
|
||
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
|
||
const operatorId = Number(rawOperatorId || 0);
|
||
const operatorName = String(
|
||
operatorSource.operator_name
|
||
|| operatorSource.employees_name
|
||
|| operatorSource.name
|
||
|| ''
|
||
).trim() || 'system';
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 401);
|
||
}
|
||
|
||
// --- 按 wave_id 直接查波次 ---
|
||
const waveRows = await ctx.model.query(
|
||
`SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id = :waveId
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { warehouseId: normalizedWarehouseId, waveId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
|
||
if (!waveRow) {
|
||
return this.fail('波次不存在或不属于当前仓库', {}, 404);
|
||
}
|
||
|
||
const targetWaveId = Number(waveRow.wave_id || 0);
|
||
const targetWaveNo = String(waveRow.wave_no || '').trim();
|
||
const targetWaveType = Number(waveRow.wave_type || 2);
|
||
const targetWaveSource = Number(waveRow.source || 0);
|
||
|
||
if (!Number.isInteger(targetWaveId) || targetWaveId <= 0 || !targetWaveNo) {
|
||
return this.fail('目标波次信息不完整', {}, 400);
|
||
}
|
||
|
||
// --- 去重:活动任务检查(与 query 一致)---
|
||
const activeTaskRows = await ctx.model.query(
|
||
`SELECT t.id AS task_id, t.pick_user_id, t.pick_user_name
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.status IN (0, 1)
|
||
AND (
|
||
t.wave_id = :waveId
|
||
OR EXISTS (
|
||
SELECT 1
|
||
FROM wms_wave_pick_task_wave tw
|
||
WHERE tw.task_id = t.id
|
||
AND tw.wave_id = :waveId
|
||
)
|
||
)
|
||
ORDER BY t.id DESC
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: targetWaveId, warehouseId: normalizedWarehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const activeTask = Array.isArray(activeTaskRows) && activeTaskRows.length > 0 ? activeTaskRows[0] : null;
|
||
|
||
let taskId = 0;
|
||
|
||
if (activeTask) {
|
||
const activeTaskId = Number(activeTask.task_id || 0);
|
||
const taskOwnerId = Number(activeTask.pick_user_id || 0);
|
||
const taskOwnerName = String(activeTask.pick_user_name || '').trim() || `${taskOwnerId}`;
|
||
if (taskOwnerId > 0 && taskOwnerId !== operatorId) {
|
||
return this.fail(
|
||
`当前波次已由其他人创建活动任务,请移交任务创建人处理(创建人: ${taskOwnerName},任务ID: ${activeTaskId})`,
|
||
{ task_id: activeTaskId, task_owner_id: taskOwnerId, task_owner_name: taskOwnerName },
|
||
409
|
||
);
|
||
}
|
||
// 当前用户的活动任务,直接复用
|
||
taskId = activeTaskId;
|
||
}
|
||
|
||
// --- 去重:已完成任务检查(与 query 一致)---
|
||
if (taskId <= 0) {
|
||
const completedTaskRows = await ctx.model.query(
|
||
`SELECT t.id AS task_id
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND t.status IN (2, 3)
|
||
AND (
|
||
t.wave_id = :waveId
|
||
OR EXISTS (
|
||
SELECT 1
|
||
FROM wms_wave_pick_task_wave tw
|
||
WHERE tw.task_id = t.id
|
||
AND tw.wave_id = :waveId
|
||
)
|
||
)
|
||
ORDER BY t.id DESC
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: targetWaveId, warehouseId: normalizedWarehouseId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const completedTask = Array.isArray(completedTaskRows) && completedTaskRows.length > 0 ? completedTaskRows[0] : null;
|
||
if (completedTask) {
|
||
return this.success('ok', {
|
||
data: {
|
||
task_id: Number(completedTask.task_id),
|
||
status: 'already_completed',
|
||
tip: '该波次已完成拣货任务,无需重复操作',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
}
|
||
|
||
// --- 无已有任务则创建新任务(与 query 一致)---
|
||
if (taskId <= 0) {
|
||
let orderModel = null;
|
||
try {
|
||
orderModel = await this.getOrderModelByWarehouse(normalizedWarehouseId);
|
||
} catch (error) {
|
||
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
|
||
}
|
||
|
||
const orderRows = await orderModel.findAll({
|
||
where: { warehouse_id: normalizedWarehouseId, wave_id: targetWaveId },
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
});
|
||
let selectedOrderIds = [ ...new Set((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (selectedOrderIds.length <= 0) {
|
||
const fallbackRows = await orderModel.findAll({
|
||
where: { warehouse_id: normalizedWarehouseId, wave_no: targetWaveNo },
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
});
|
||
selectedOrderIds = [ ...new Set((Array.isArray(fallbackRows) ? fallbackRows : [])
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
}
|
||
|
||
if (selectedOrderIds.length <= 0) {
|
||
return this.fail('波次下无可用订单,无法创建任务', {}, 400);
|
||
}
|
||
|
||
const normalizedWaveType = Number(targetWaveType || 2);
|
||
const isGroupWave = normalizedWaveType === 1;
|
||
// 检查是否为 singleFetchByIds 创建的波次(item_part_type='manual_ids'),使用先拣后分模式
|
||
let isManualIdsWaveWP = false;
|
||
try {
|
||
const waveInfoRowsWP = await ctx.model.query(
|
||
`SELECT item_part_type
|
||
FROM wms_wave_batch
|
||
WHERE wave_id = :waveId
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: targetWaveId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const waveInfoWP = Array.isArray(waveInfoRowsWP) && waveInfoRowsWP.length > 0 ? waveInfoRowsWP[0] : null;
|
||
isManualIdsWaveWP = String(waveInfoWP && waveInfoWP.item_part_type || '').trim() === 'manual_ids';
|
||
} catch (e) {
|
||
// 查询失败不影响主流程,退回默认拣货模式
|
||
}
|
||
const pickMode = isGroupWave ? 5 : (isManualIdsWaveWP ? 3 : 2);
|
||
|
||
try {
|
||
const createdTask = await this.createWavePickTask({
|
||
warehouseId: normalizedWarehouseId,
|
||
waveId: targetWaveId,
|
||
waveNo: targetWaveNo,
|
||
pickMode,
|
||
operatorId,
|
||
operatorName,
|
||
orderIds: selectedOrderIds,
|
||
remark: `pick.wavePickComplete wave_id=${waveId}`,
|
||
source: 2,
|
||
// 普通波次(source=0):计算拣货数量时剔除未领料(claim_status != fin)订单
|
||
excludeUnclaimed: targetWaveSource === 0,
|
||
});
|
||
taskId = createdTask.task_id;
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isFinite(code) && code >= 400 && code < 600) {
|
||
return this.fail(error.message || '任务创建失败', {}, code);
|
||
}
|
||
ctx.logger.error('[PickService.wavePickComplete] 创建波次任务失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('任务创建失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
// --- 任务已就绪,调用内部 wavePickTaskComplete 全部确认完成 ---
|
||
try {
|
||
const result = await service.systems.pick.wavePickTaskComplete({
|
||
taskId,
|
||
mode: 1,
|
||
orderIds: [],
|
||
});
|
||
|
||
return this.success('ok', {
|
||
data: {
|
||
...result,
|
||
status: 'completed',
|
||
tip: '波次拣货已完成',
|
||
},
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isInteger(code) && code >= 400 && code < 600) {
|
||
const errorData = this.isPlainObject(error && error.data) ? error.data : {};
|
||
return this.fail(error.message || '拣货完成失败', errorData, code);
|
||
}
|
||
ctx.logger.error('[PickService.wavePickComplete] 完成拣货失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('拣货完成失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 完全提交拣货任务。
|
||
*
|
||
* mode: 1=全部确认,2=部分确认(需传 order_ids)。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {number|string} data.task_id 拣货任务ID。
|
||
* @param {number|string} [data.mode=1] 提交模式。
|
||
* @param {Array<number|string>|number|string} [data.order_ids] 部分确认时的订单ID集合。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async wavePickTaskComplete(data = {}) {
|
||
const { service, ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const taskId = Number(requestData.task_id || requestData.taskId || 0);
|
||
const mode = Number(requestData.mode || 1);
|
||
const rawOrderIds = requestData.order_ids !== undefined
|
||
? requestData.order_ids
|
||
: requestData.orderIds;
|
||
let orderIds = [];
|
||
if (Array.isArray(rawOrderIds)) {
|
||
orderIds = rawOrderIds;
|
||
} else if (typeof rawOrderIds === 'string') {
|
||
orderIds = rawOrderIds.split(',');
|
||
} else if (typeof rawOrderIds === 'number') {
|
||
orderIds = [ rawOrderIds ];
|
||
}
|
||
const normalizedOrderIds = [ ...new Set(orderIds
|
||
.map(id => Number(id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return this.fail('task_id 必填且必须为正整数', {}, 400);
|
||
}
|
||
|
||
try {
|
||
const result = await service.systems.pick.wavePickTaskComplete({
|
||
taskId,
|
||
mode,
|
||
orderIds: normalizedOrderIds,
|
||
});
|
||
|
||
return this.success('ok', {
|
||
data: result,
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
const code = Number(error && error.code);
|
||
if (Number.isInteger(code) && code >= 400 && code < 600) {
|
||
const errorData = this.isPlainObject(error && error.data) ? error.data : {};
|
||
return this.fail(error.message || '提交失败', errorData, code);
|
||
}
|
||
|
||
ctx.logger.error('[PickService.wavePickTaskComplete] 完全提交拣货任务失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('提交失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询波次关联的拣货模式。
|
||
*
|
||
* 优先按拣货任务主表(wms_wave_pick_task.wave_id)直接关联查询,
|
||
* 未命中时回退到任务与波次关联表(wms_wave_pick_task_wave)查询。
|
||
*
|
||
* @param {number|string} waveId 波次ID。
|
||
* @return {Promise<number>} 拣货模式:1-团购小波次 2-散单单品单件 3-先拣后分 4-边拣边分 5-团购大波次(0 表示无关联拣货任务)。
|
||
*/
|
||
async getWavePickModeByWaveId(waveId) {
|
||
const { ctx } = this;
|
||
const normalizedWaveId = Number(waveId || 0);
|
||
if (!Number.isInteger(normalizedWaveId) || normalizedWaveId <= 0) {
|
||
return 0;
|
||
}
|
||
|
||
const directRows = await ctx.model.query(
|
||
`SELECT pick_mode
|
||
FROM wms_wave_pick_task
|
||
WHERE wave_id = :waveId
|
||
ORDER BY id DESC
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const directRow = Array.isArray(directRows) && directRows.length > 0 ? directRows[0] : null;
|
||
if (directRow) {
|
||
return Number(directRow.pick_mode || 0);
|
||
}
|
||
|
||
const linkRows = await ctx.model.query(
|
||
`SELECT t.pick_mode
|
||
FROM wms_wave_pick_task_wave tw
|
||
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
|
||
WHERE tw.wave_id = :waveId
|
||
ORDER BY t.id DESC
|
||
LIMIT 1`,
|
||
{
|
||
replacements: { waveId: normalizedWaveId },
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
const linkRow = Array.isArray(linkRows) && linkRows.length > 0 ? linkRows[0] : null;
|
||
return linkRow ? Number(linkRow.pick_mode || 0) : 0;
|
||
}
|
||
|
||
/**
|
||
* 统计波次下领料门禁相关数量(普通波次 source=0 领料前置校验)。
|
||
*
|
||
* 统计口径:
|
||
* - total_order_count:波次下全部订单数(含拦截订单);
|
||
* - intercepted_order_count:拦截订单数(intercept_status != none);
|
||
* - unclaimed_order_count:非拦截且需要领料的订单数,包括未领料
|
||
* (claim_status != fin)与已领料但领料人非本人(claim_operator_id != 操作人)两种;
|
||
* 拦截订单不阻隔拣货,不计入该数量。
|
||
*
|
||
* @param {Object} params 统计参数。
|
||
* @param {Object} params.orderModel 订单分表模型。
|
||
* @param {number} params.warehouseId 仓库ID。
|
||
* @param {number} params.waveId 波次ID。
|
||
* @param {string} [params.waveNo=''] 波次编码(wave_id 未命中时回退按 wave_no 统计)。
|
||
* @param {number} [params.claimOperatorId=0] 当前操作人工号(判断领料人是否本人)。
|
||
* @return {Promise<{total_order_count: number, intercepted_order_count: number, unclaimed_order_count: number}>}
|
||
* 统计结果。
|
||
*/
|
||
async getWaveClaimGateStats(params = {}) {
|
||
const { ctx } = this;
|
||
const orderModel = params && params.orderModel;
|
||
const warehouseId = Number(params && params.warehouseId || 0);
|
||
const waveId = Number(params && params.waveId || 0);
|
||
const waveNo = String(params && params.waveNo || '').trim();
|
||
const claimOperatorId = Number(params && params.claimOperatorId || 0);
|
||
if (!orderModel || typeof orderModel.findAll !== 'function') {
|
||
ctx.logger.warn('[pick.getWaveClaimGateStats] 订单模型不可用,返回空统计');
|
||
return { total_order_count: 0, intercepted_order_count: 0, unclaimed_order_count: 0 };
|
||
}
|
||
|
||
let rows = [];
|
||
if (Number.isInteger(waveId) && waveId > 0) {
|
||
rows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
wave_id: waveId,
|
||
},
|
||
attributes: [ 'id', 'claim_status', 'intercept_status', 'claim_operator_id' ],
|
||
raw: true,
|
||
});
|
||
rows = Array.isArray(rows) ? rows : [];
|
||
}
|
||
if (rows.length === 0 && waveNo) {
|
||
const fallbackRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: warehouseId,
|
||
wave_no: waveNo,
|
||
},
|
||
attributes: [ 'id', 'claim_status', 'intercept_status', 'claim_operator_id' ],
|
||
raw: true,
|
||
});
|
||
rows = Array.isArray(fallbackRows) ? fallbackRows : [];
|
||
}
|
||
|
||
const orderIds = [ ...new Set(rows
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
const interceptedOrderIds = new Set(rows
|
||
.filter(item => isInterceptedOrderStatus(item && item.intercept_status))
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0));
|
||
const unclaimedOrderCount = rows
|
||
.filter(item => {
|
||
const orderIdItem = Number(item && item.id || 0);
|
||
if (!orderIds.includes(orderIdItem) || interceptedOrderIds.has(orderIdItem)) {
|
||
return false;
|
||
}
|
||
if (String(item && item.claim_status || '') !== 'fin') {
|
||
return true;
|
||
}
|
||
// 已领料但领料人不是本人:仍视为需要领料
|
||
return claimOperatorId > 0 && Number(item && item.claim_operator_id || 0) !== claimOperatorId;
|
||
})
|
||
.length;
|
||
|
||
return {
|
||
total_order_count: orderIds.length,
|
||
intercepted_order_count: interceptedOrderIds.size,
|
||
unclaimed_order_count: unclaimedOrderCount,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 扫描面单号领取整波(领料)。
|
||
*
|
||
* 按面单号(运单号,wms_order_express.waybill_code)定位待处理订单表中的订单后反查订单所在波次,
|
||
* 仅对普通波次(wms_wave_batch.source=0,含团购/散单)支持整波领料:
|
||
* 命中后将该波次下全部未领单订单 claim_status 置为 fin(领单完成),
|
||
* 并写入 ORDER_WAVE_CLAIM 订单操作日志,返回波次ID(wave_id)与波次编码(wave_no);
|
||
* 策略抓取波次(source=1/2)无需领料,返回 400 并提示「该波次为抓取波次,无需领料」
|
||
* (失败 data 含 no_claim_needed=true、wave_id、wave_no);
|
||
* 波次下存在未打印订单(print_status != fin,拦截订单除外)时禁止领料,
|
||
* 返回 400 并提示「波次未打印,禁止领料」(失败 data 含 wave_id、wave_no、unprinted_order_count、
|
||
* intercepted_order_count,拦截订单未打印不阻隔领料);
|
||
* 拦截订单整体跳过领料:既不置为领料完成,其未打印状态也不阻隔整波领料。
|
||
* 其余未知类型返回通用不支持提示。
|
||
* 波次内订单已全部领单时返回 already_claimed 幂等结果并提示已领料。
|
||
*
|
||
* @param {Object} data 请求参数。
|
||
* @param {string} data.waybill_no 面单号(运单号,wms_order_express.waybill_code)。
|
||
* @return {Promise<Object>} 统一 success/fail 包装结果。
|
||
*/
|
||
async waveClaimScan(data = {}) {
|
||
const { ctx } = this;
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const waybillNo = String(requestData.waybill_no || requestData.waybillNo || '').trim();
|
||
if (!waybillNo) {
|
||
return this.fail('waybill_no 必填(面单号/运单号)', {}, 400);
|
||
}
|
||
|
||
// --- 仓库上下文与操作人 ---
|
||
const userWarehouseId = ctx && ctx.user ? ctx.user.store_id : undefined;
|
||
const stateWarehouseId = ctx && ctx.state && ctx.state.user ? ctx.state.user.store_id : undefined;
|
||
const normalizedWarehouseId = Number(userWarehouseId || stateWarehouseId || 0);
|
||
if (!Number.isFinite(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
|
||
return this.fail('缺少当前用户仓库上下文 store_id', {}, 400);
|
||
}
|
||
|
||
const stateUser = this.isPlainObject(ctx && ctx.state && ctx.state.user) ? ctx.state.user : null;
|
||
const ctxUser = this.isPlainObject(ctx && ctx.user) ? ctx.user : null;
|
||
const operatorSource = stateUser || ctxUser || {};
|
||
const rawOperatorId = operatorSource.employees_id ?? operatorSource.operator_id ?? operatorSource.id;
|
||
const operatorId = Number(rawOperatorId || 0);
|
||
const operatorName = String(
|
||
operatorSource.operator_name
|
||
|| operatorSource.employees_name
|
||
|| operatorSource.name
|
||
|| ''
|
||
).trim() || 'system';
|
||
if (!Number.isInteger(operatorId) || operatorId <= 0) {
|
||
return this.fail('未获取到操作人上下文', {}, 401);
|
||
}
|
||
|
||
// --- 1. 面单号定位订单 ---
|
||
const orderExpress = await ctx.model.OrderExpress.findOne({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
waybill_code: waybillNo,
|
||
},
|
||
attributes: [ 'order_id' ],
|
||
raw: true,
|
||
});
|
||
const matchedOrderId = Number(orderExpress && orderExpress.order_id || 0);
|
||
if (!(matchedOrderId > 0)) {
|
||
return this.fail('未查询到该面单号对应的订单,无记录', {}, 404);
|
||
}
|
||
|
||
// --- 2. 待处理订单表定位订单 ---
|
||
let orderModel = null;
|
||
try {
|
||
orderModel = await this.getOrderModelByWarehouse(normalizedWarehouseId);
|
||
} catch (error) {
|
||
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
|
||
}
|
||
const order = await orderModel.findOne({
|
||
where: {
|
||
id: matchedOrderId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
},
|
||
attributes: [ 'id', 'wave_id', 'wave_no' ],
|
||
raw: true,
|
||
});
|
||
if (!order) {
|
||
return this.fail('订单不在待处理订单表,无记录', {}, 404);
|
||
}
|
||
|
||
// --- 3. 订单定位波次 ---
|
||
const orderWaveId = Number(order.wave_id || 0);
|
||
const orderWaveNo = String(order.wave_no || '').trim();
|
||
if (!(orderWaveId > 0 || orderWaveNo)) {
|
||
return this.fail('运单对应订单未分配波次', {}, 400);
|
||
}
|
||
|
||
let waveRows = [];
|
||
if (orderWaveId > 0) {
|
||
waveRows = await ctx.model.query(
|
||
`SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_id = :waveId
|
||
LIMIT 1`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveId: orderWaveId,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
} else {
|
||
waveRows = await ctx.model.query(
|
||
`SELECT wave_id, wave_no, wave_type, source
|
||
FROM wms_wave_batch
|
||
WHERE warehouse_id = :warehouseId
|
||
AND wave_no = :waveNo
|
||
LIMIT 1`,
|
||
{
|
||
replacements: {
|
||
warehouseId: normalizedWarehouseId,
|
||
waveNo: orderWaveNo,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
}
|
||
const waveRow = Array.isArray(waveRows) && waveRows.length > 0 ? waveRows[0] : null;
|
||
if (!waveRow) {
|
||
return this.fail('运单对应波次不存在或不属于当前仓库', {}, 404);
|
||
}
|
||
|
||
const targetWaveId = Number(waveRow.wave_id || 0);
|
||
const targetWaveNo = String(waveRow.wave_no || '').trim();
|
||
const targetWaveType = Number(waveRow.wave_type || 0);
|
||
const targetWaveSource = Number(waveRow.source || 0);
|
||
if (!(targetWaveId > 0) || !targetWaveNo) {
|
||
return this.fail('目标波次信息不完整', {}, 400);
|
||
}
|
||
|
||
// --- 4. 波次关联拣货模式与领料资格判定(仅普通波次 source=0 支持整波领料)---
|
||
const pickMode = await this.getWavePickModeByWaveId(targetWaveId);
|
||
|
||
const isFetchedWave = targetWaveSource === 1 || targetWaveSource === 2;
|
||
if (isFetchedWave) {
|
||
return this.fail('该波次为抓取波次,无需领料', {
|
||
no_claim_needed: true,
|
||
wave_id: targetWaveId,
|
||
wave_no: targetWaveNo,
|
||
wave_type: targetWaveType,
|
||
wave_source: targetWaveSource,
|
||
pick_mode: pickMode,
|
||
matched_order_id: matchedOrderId,
|
||
waybill_no: waybillNo,
|
||
}, 400);
|
||
}
|
||
if (targetWaveSource !== 0) {
|
||
return this.fail('当前波次类型不支持整波领单', {
|
||
wave_id: targetWaveId,
|
||
wave_no: targetWaveNo,
|
||
wave_type: targetWaveType,
|
||
wave_source: targetWaveSource,
|
||
}, 400);
|
||
}
|
||
|
||
// --- 5. 查询波次下全部订单 ---
|
||
const waveOrderRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
wave_id: targetWaveId,
|
||
},
|
||
attributes: [ 'id', 'claim_status', 'print_status', 'intercept_status', 'claim_operator_id' ],
|
||
raw: true,
|
||
});
|
||
let waveOrders = Array.isArray(waveOrderRows) ? waveOrderRows : [];
|
||
if (waveOrders.length === 0) {
|
||
const fallbackRows = await orderModel.findAll({
|
||
where: {
|
||
warehouse_id: normalizedWarehouseId,
|
||
wave_no: targetWaveNo,
|
||
},
|
||
attributes: [ 'id', 'claim_status', 'print_status', 'intercept_status', 'claim_operator_id' ],
|
||
raw: true,
|
||
});
|
||
waveOrders = Array.isArray(fallbackRows) ? fallbackRows : [];
|
||
}
|
||
const waveOrderIds = [ ...new Set(waveOrders
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
if (waveOrderIds.length === 0) {
|
||
return this.fail('波次下无可用订单', {}, 400);
|
||
}
|
||
|
||
const totalOrderCount = waveOrderIds.length;
|
||
// 拦截订单整体跳过领料:不参与领取(保持未领料),其未打印/未领料状态也不阻隔领料与拣货
|
||
const interceptedWaveOrderIds = new Set(waveOrders
|
||
.filter(item => isInterceptedOrderStatus(item && item.intercept_status))
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0));
|
||
|
||
const unclaimedOrderIds = [ ...new Set(waveOrders
|
||
.filter(item => {
|
||
const orderIdItem = Number(item && item.id || 0);
|
||
if (interceptedWaveOrderIds.has(orderIdItem)) {
|
||
return false;
|
||
}
|
||
if (String(item && item.claim_status || '') !== 'fin') {
|
||
return true;
|
||
}
|
||
// 已领料但领料人不是本人:重新领料并覆盖领料人
|
||
return Number(item && item.claim_operator_id || 0) !== operatorId;
|
||
})
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
const ownClaimedOrderIds = [ ...new Set(waveOrders
|
||
.filter(item => String(item && item.claim_status || '') === 'fin'
|
||
&& Number(item && item.claim_operator_id || 0) === operatorId
|
||
&& !interceptedWaveOrderIds.has(Number(item && item.id || 0)))
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
const baseResponse = {
|
||
wave_id: targetWaveId,
|
||
wave_no: targetWaveNo,
|
||
wave_type: targetWaveType,
|
||
wave_source: targetWaveSource,
|
||
pick_mode: pickMode,
|
||
matched_order_id: matchedOrderId,
|
||
waybill_no: waybillNo,
|
||
total_order_count: totalOrderCount,
|
||
intercepted_order_count: interceptedWaveOrderIds.size,
|
||
};
|
||
|
||
if (unclaimedOrderIds.length === 0) {
|
||
return this.success('ok', {
|
||
data: {
|
||
...baseResponse,
|
||
claimed_order_count: ownClaimedOrderIds.length,
|
||
status: 'already_claimed',
|
||
tip: '该波次订单已领料(本人),无需重复领取',
|
||
},
|
||
code: 200,
|
||
});
|
||
}
|
||
|
||
// 波次打印校验:存在未打印订单(print_status != fin)时禁止整波领料
|
||
// (拦截订单的未打印状态不阻隔领料)
|
||
const unprintedOrderIds = [ ...new Set(waveOrders
|
||
.filter(item => String(item && item.print_status || '') !== 'fin'
|
||
&& !interceptedWaveOrderIds.has(Number(item && item.id || 0)))
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
if (unprintedOrderIds.length > 0) {
|
||
return this.fail('波次未打印,禁止领料', {
|
||
...baseResponse,
|
||
unprinted_order_count: unprintedOrderIds.length,
|
||
}, 400);
|
||
}
|
||
|
||
// --- 6. 事务更新领单状态并写订单日志 ---
|
||
const operationLogService = ctx.service
|
||
&& ctx.service.systems
|
||
&& ctx.service.systems.operationLog;
|
||
const transaction = await ctx.model.transaction();
|
||
try {
|
||
await orderModel.update(
|
||
{
|
||
claim_status: 'fin',
|
||
claim_operator_id: operatorId > 0 ? operatorId : null,
|
||
claim_operator: operatorName,
|
||
},
|
||
{
|
||
where: {
|
||
id: { [Op.in]: unclaimedOrderIds },
|
||
warehouse_id: normalizedWarehouseId,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
const claimedRows = await orderModel.findAll({
|
||
where: {
|
||
id: { [Op.in]: unclaimedOrderIds },
|
||
warehouse_id: normalizedWarehouseId,
|
||
claim_status: 'fin',
|
||
},
|
||
attributes: [ 'id' ],
|
||
raw: true,
|
||
transaction,
|
||
});
|
||
const claimedOrderIds = [ ...new Set((Array.isArray(claimedRows) ? claimedRows : [])
|
||
.map(item => Number(item && item.id || 0))
|
||
.filter(id => Number.isInteger(id) && id > 0)) ];
|
||
|
||
if (claimedOrderIds.length > 0) {
|
||
// 回写波次表领料人、领料时间
|
||
await ctx.model.WaveBatch.update(
|
||
{
|
||
claim_operator: operatorName,
|
||
claim_time: new Date(),
|
||
},
|
||
{
|
||
where: {
|
||
wave_id: targetWaveId,
|
||
warehouse_id: normalizedWarehouseId,
|
||
},
|
||
transaction,
|
||
}
|
||
);
|
||
|
||
if (operationLogService
|
||
&& typeof operationLogService.createOperationLogs === 'function') {
|
||
await operationLogService.createOperationLogs(claimedOrderIds.map(orderId => ({
|
||
businessType: 'order',
|
||
businessId: `${orderId}`,
|
||
operationCode: 'ORDER_WAVE_CLAIM',
|
||
operator: {
|
||
id: operatorId ? String(operatorId) : null,
|
||
name: operatorName || 'system',
|
||
},
|
||
operationAction: 'UPDATE',
|
||
extras: {
|
||
message: `整波领单完成(波次 ${targetWaveNo})`,
|
||
warehouseId: normalizedWarehouseId,
|
||
externalLogType: 'API',
|
||
},
|
||
})), { transaction });
|
||
}
|
||
}
|
||
|
||
await transaction.commit();
|
||
|
||
// 驱动确认打印未领单波次统计长轮询:领单会减少未领单波次数量,递增版本号
|
||
try {
|
||
const waveService = ctx.service
|
||
&& ctx.service.systemMethods
|
||
&& ctx.service.systemMethods.order
|
||
&& ctx.service.systemMethods.order.wave;
|
||
if (waveService && typeof waveService.bumpConfirmPrintUnclaimedWaveVersion === 'function') {
|
||
await waveService.bumpConfirmPrintUnclaimedWaveVersion(normalizedWarehouseId);
|
||
}
|
||
} catch (error) {
|
||
ctx.logger.warn('[PickService.waveClaimScan] 统计版本号递增失败: %s',
|
||
error && error.message ? error.message : error);
|
||
}
|
||
|
||
return this.success('ok', {
|
||
data: {
|
||
...baseResponse,
|
||
claimed_order_count: claimedOrderIds.length,
|
||
status: 'claimed',
|
||
tip: `整波领单完成,本次领取 ${claimedOrderIds.length} 个订单`,
|
||
},
|
||
code: 200,
|
||
});
|
||
} catch (error) {
|
||
await transaction.rollback();
|
||
ctx.logger.error('[PickService.waveClaimScan] 整波领单失败: %s', error && error.message ? error.message : error);
|
||
return this.fail('领单失败', {}, 500);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
module.exports = PickService;
|