1. pick.query 增加跨波次订单级去重:已拣货完成的订单不再创建新任务,直接返回原有任务 2. cancelWavePickTasksInternal 禁止取消 status 2(待复核)/3(已完成) 的任务,防止库存与订单状态不一致
1476 lines
51 KiB
JavaScript
1476 lines
51 KiB
JavaScript
'use strict';
|
||
|
||
const MainService = require('../main');
|
||
|
||
class PickService extends MainService {
|
||
/**
|
||
* 初始化 pick 模块鉴权配置。
|
||
*
|
||
* @param {Egg.Context} ctx 上下文对象。
|
||
*/
|
||
constructor(ctx) {
|
||
super(ctx);
|
||
const _noNeedLogin = '';
|
||
const _noNeedRight = 'query,wavePickComplete,wavePickTaskDetail,wavePickTaskCurrent,wavePickTaskSubmit,wavePickTaskComplete';
|
||
const _noNeedLog = 'query';
|
||
const _noNeedAuth = 'query,wavePickComplete,wavePickTaskDetail,wavePickTaskCurrent,wavePickTaskSubmit,wavePickTaskComplete';
|
||
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。
|
||
* @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 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' ],
|
||
raw: true,
|
||
});
|
||
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,
|
||
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,
|
||
:pickMode,
|
||
0,
|
||
:source,
|
||
1,
|
||
:orderCount,
|
||
0,
|
||
:operatorId,
|
||
:operatorName,
|
||
:remark,
|
||
NOW(),
|
||
NOW()
|
||
)
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskNo,
|
||
warehouseId,
|
||
waveId,
|
||
pickMode,
|
||
source,
|
||
orderCount: normalizedOrderIds.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 (normalizedOrderIds.length > 0) {
|
||
// 按库位排序并按 stock_id 分组,同 stock_id 的订单共享同一篮号
|
||
const stockGroups = await this.resolveLocationSortedOrderIds(
|
||
normalizedOrderIds,
|
||
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
|
||
await ctx.model.query(
|
||
`UPDATE wms_wave_pick_task
|
||
SET box_count = :boxCount,
|
||
update_time = NOW()
|
||
WHERE id = :taskId`,
|
||
{
|
||
replacements: { taskId, boxCount: 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 = normalizedOrderIds.map(orderId => ({
|
||
businessType: 'order',
|
||
businessId: `${orderId}`,
|
||
operationCode: 'ORDER_WAVE_GRAB',
|
||
operator: {
|
||
id: operatorId ? String(operatorId) : null,
|
||
name: operatorName || 'system',
|
||
},
|
||
extras: {
|
||
message: `订单${orderId}抓取波次成功`,
|
||
warehouseId,
|
||
externalLogType: 'API',
|
||
},
|
||
}));
|
||
await operationLogService.createOperationLogs(logPayloads);
|
||
}
|
||
} catch (e) {
|
||
ctx.logger.warn('[pick.createWavePickTask] 写入 order_operation_log 失败,不影响主流程', {
|
||
error: e && e.message,
|
||
normalizedOrderIds,
|
||
});
|
||
}
|
||
|
||
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 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
|
||
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);
|
||
} else {
|
||
const waveByNoRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, wave_type
|
||
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);
|
||
}
|
||
} else {
|
||
const waveRows = await ctx.model.query(
|
||
`
|
||
SELECT wave_id, wave_no, wave_type
|
||
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);
|
||
}
|
||
|
||
if (!Number.isInteger(targetWaveId) || targetWaveId <= 0 || !targetWaveNo) {
|
||
return this.fail('目标波次信息不完整', {}, 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 ? 1 : (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,
|
||
});
|
||
|
||
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
|
||
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);
|
||
|
||
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 ? 1 : (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,
|
||
});
|
||
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);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
module.exports = PickService;
|