liufumingren a8200a3a35 feat(order): 订单拦截全链路阻断与作业排除
- 新增 app/lib/intercept_guard 共享守卫:除 none 外所有拦截状态一律视为已拦截
- 分配波次(singleFetchByIds)/抓取波次(createWavePickTask) 排除拦截订单并回传清单
- 分配储位(allocatePicking)/分配快递(createWaybillCodePipeline、batchAllocateExpress) 跳过拦截订单并回报
- 打印组装(getWavePlatformPrintData/getOrderPrintData/getPrintDataByWaybillCodes) 剔除拦截订单,打印回写/波次反查/标记均排除
- 拣货完成(wavePickTaskComplete) 拦截报错;复核(assertOrderCanRecheck/批量快捷复核) 补全拦截状态
- 打包/称重(workbench、order.updateExpressWeighingWeight) 拦截阻断,波次批量操作排除拦截单
- 绑定包材(order_express) 拦截阻断,波次批量绑定排除拦截单
2026-08-17 21:58:43 +08:00

1494 lines
52 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const 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';
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', 'intercept_status' ],
raw: true,
});
// 拦截流程中的订单不允许抓取波次,直接剔除
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(','));
}
}
const activeOrderIds = normalizedOrderIds.filter(id => !interceptedOrderIds.has(id));
if (activeOrderIds.length <= 0) {
throw Object.assign(new Error('波次下订单均已被拦截,无法创建任务'), { code: 400 });
}
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: 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
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 = activeOrderIds.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,
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 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;