682 lines
21 KiB
JavaScript
682 lines
21 KiB
JavaScript
'use strict';
|
||
|
||
const OrderBaseService = require('./base');
|
||
|
||
class RecheckOrderService extends OrderBaseService {
|
||
/**
|
||
* 初始化复核订单系统方法免登录、免权限、免日志与免鉴权配置。
|
||
* @param {Egg.Context} ctx 请求上下文。
|
||
*/
|
||
constructor(ctx) {
|
||
super(ctx);
|
||
const _noNeedLogin = '';
|
||
const _noNeedRight = 'scanOrder,scanWaybill,confirmRecheck';
|
||
const _noNeedLog = 'scanOrder,scanWaybill,confirmRecheck';
|
||
const _noNeedAuth = 'scanOrder,scanWaybill,confirmRecheck';
|
||
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
|
||
}
|
||
|
||
/**
|
||
* 扫描关键词并返回订单头与商品明细。
|
||
* @param {Object} data 请求体。
|
||
* @param {string} [data.keyword] 通用扫描关键词。
|
||
* @param {string} [data.value] 通用扫描关键词别名。
|
||
* @param {string} [data.waybill_no] 运单号。
|
||
* @param {string} [data.waybillCode] 运单号别名。
|
||
* @param {string} [data.waybill_code] 运单号别名。
|
||
* @param {string} [data.cart_code] 车号。
|
||
* @param {string} [data.cartCode] 车号别名。
|
||
* @return {Promise<Object>} 扫描结果。
|
||
*/
|
||
async scanOrder(data = {}) {
|
||
const warehouseId = this.getWarehouseId();
|
||
const keyword = this.resolveScanKeyword(data);
|
||
const matchedResult = await this.pickOrderMatchByKeyword(keyword);
|
||
const { orderId, matchType, cartMatchContext } = matchedResult;
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
|
||
const order = await orderModel.findOne({
|
||
where: orderWhere,
|
||
raw: true,
|
||
});
|
||
|
||
if (!order) {
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
this.assertOrderCanRecheck(order);
|
||
|
||
const detailResult = await this.detail({
|
||
id: orderId,
|
||
});
|
||
const expresses = Array.isArray(detailResult.expresses) ? detailResult.expresses : [];
|
||
const resolvedWaybillNo = matchType === 'waybill'
|
||
? keyword
|
||
: String(expresses?.[0]?.waybill_code || '').trim();
|
||
const cartMatchView = matchType === 'cart'
|
||
? await this.buildCartMatchView(cartMatchContext)
|
||
: null;
|
||
|
||
return {
|
||
match_type: matchType,
|
||
cart_match_view: cartMatchView,
|
||
order_id: orderId,
|
||
waybill_no: resolvedWaybillNo,
|
||
order: detailResult.detail || {},
|
||
items: Array.isArray(detailResult.items) ? detailResult.items : [],
|
||
expresses,
|
||
logs: Array.isArray(detailResult.logs) ? detailResult.logs : [],
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 兼容旧方法名,内部统一转发到 scanOrder。
|
||
* @param {Object} data 请求体。
|
||
* @return {Promise<Object>} 扫描结果。
|
||
*/
|
||
async scanWaybill(data = {}) {
|
||
return await this.scanOrder(data);
|
||
}
|
||
|
||
/**
|
||
* 确认订单已复核,并写入复核任务记录。
|
||
* @param {Object} data 请求体。
|
||
* @param {number|string} [data.order_id] 订单ID。
|
||
* @param {number|string} [data.id] 订单ID别名。
|
||
* @param {number|string} [data.orderId] 订单ID别名。
|
||
* @return {Promise<Object>} 复核确认结果。
|
||
*/
|
||
async confirmRecheck(data = {}) {
|
||
const { ctx } = this;
|
||
const warehouseId = this.getWarehouseId();
|
||
const orderId = this.resolveOrderId(data);
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
|
||
const order = await orderModel.findOne({
|
||
where: orderWhere,
|
||
raw: true,
|
||
});
|
||
|
||
if (!order) {
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
this.assertOrderCanRecheck(order);
|
||
|
||
const expresses = await this.getOrderExpressesByOrderId(orderId);
|
||
const waybillNo = String(expresses?.[0]?.waybill_code || '').trim();
|
||
|
||
const now = new Date();
|
||
const updateValues = {
|
||
recheck_status: 'fin',
|
||
recheck_time: now,
|
||
updated_at: now,
|
||
};
|
||
const updateResult = await orderModel.update(updateValues, {
|
||
where: orderWhere,
|
||
});
|
||
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
|
||
|
||
if (affectedRows <= 0) {
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
const operator = this.getOrderLogOperator();
|
||
const reviewNo = this.buildRecheckReviewNo(orderId, now);
|
||
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
|
||
const operatorNo = String(operator.id || '').trim();
|
||
const operatorName = String(operator.name || '').trim();
|
||
|
||
await ctx.model.query(
|
||
`
|
||
INSERT INTO wms_recheck_task (
|
||
review_no,
|
||
warehouse_id,
|
||
order_id,
|
||
order_no,
|
||
waybill_no,
|
||
task_status,
|
||
scan_status,
|
||
review_emp_no,
|
||
review_emp_name,
|
||
scan_emp_no,
|
||
scan_emp_name,
|
||
scan_time,
|
||
finish_time,
|
||
remark
|
||
)
|
||
VALUES (
|
||
:reviewNo,
|
||
:warehouseId,
|
||
:orderId,
|
||
:orderNo,
|
||
:waybillNo,
|
||
:taskStatus,
|
||
:scanStatus,
|
||
:reviewEmpNo,
|
||
:reviewEmpName,
|
||
:scanEmpNo,
|
||
:scanEmpName,
|
||
:scanTime,
|
||
:finishTime,
|
||
:remark
|
||
)
|
||
`,
|
||
{
|
||
replacements: {
|
||
reviewNo,
|
||
warehouseId,
|
||
orderId,
|
||
orderNo,
|
||
waybillNo,
|
||
taskStatus: 2,
|
||
scanStatus: 1,
|
||
reviewEmpNo: operatorNo,
|
||
reviewEmpName: operatorName,
|
||
scanEmpNo: operatorNo,
|
||
scanEmpName: operatorName,
|
||
scanTime: now,
|
||
finishTime: now,
|
||
remark: '系统复核完成',
|
||
},
|
||
type: ctx.model.QueryTypes.INSERT,
|
||
}
|
||
);
|
||
|
||
return {
|
||
order_id: orderId,
|
||
waybill_no: waybillNo,
|
||
recheck_status: 'fin',
|
||
recheck_time: now,
|
||
review_no: reviewNo,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 从多种兼容字段中解析订单ID。
|
||
* @param {Object} data 请求体。
|
||
* @return {number} 规范化后的订单ID。
|
||
*/
|
||
resolveOrderId(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const {
|
||
order_id: orderId,
|
||
id,
|
||
orderId: orderIdAlias,
|
||
} = requestData;
|
||
const normalizedOrderId = Number(orderId || id || orderIdAlias || 0);
|
||
|
||
if (!Number.isFinite(normalizedOrderId) || normalizedOrderId <= 0) {
|
||
throw new Error('订单ID不能为空');
|
||
}
|
||
|
||
return normalizedOrderId;
|
||
}
|
||
|
||
/**
|
||
* 从多种兼容字段中解析扫描关键词。
|
||
* @param {Object} data 请求体。
|
||
* @return {string} 规范化后的扫描关键词。
|
||
*/
|
||
resolveScanKeyword(data = {}) {
|
||
const requestData = this.isPlainObject(data) ? data : {};
|
||
const {
|
||
keyword,
|
||
value,
|
||
waybill_no: waybillNo,
|
||
waybillCode,
|
||
waybill_code: waybillCodeAlias,
|
||
cart_code: cartCode,
|
||
cartCode: cartCodeAlias,
|
||
} = requestData;
|
||
const normalizedKeyword = String(
|
||
keyword || value || waybillNo || waybillCode || waybillCodeAlias || cartCode || cartCodeAlias || ''
|
||
).trim();
|
||
|
||
if (!normalizedKeyword) {
|
||
throw new Error('扫描关键词不能为空');
|
||
}
|
||
|
||
return normalizedKeyword;
|
||
}
|
||
|
||
/**
|
||
* 根据扫描关键词解析订单ID。
|
||
* 优先按运单号匹配,未命中时回退到车号匹配。
|
||
* @param {string} keyword 扫描关键词。
|
||
* @return {Promise<{ orderId: number, matchType: string, cartMatchContext?: Object }>} 命中结果。
|
||
*/
|
||
async pickOrderMatchByKeyword(keyword) {
|
||
const waybillOrderId = await this.pickOrderIdByWaybill(keyword);
|
||
|
||
if (Number.isFinite(waybillOrderId) && waybillOrderId > 0) {
|
||
return {
|
||
orderId: waybillOrderId,
|
||
matchType: 'waybill',
|
||
};
|
||
}
|
||
|
||
const cartMatchContext = await this.pickCartMatchContextByCartCode(keyword);
|
||
const cartOrderId = Number(cartMatchContext?.order_id || 0);
|
||
|
||
if (Number.isFinite(cartOrderId) && cartOrderId > 0) {
|
||
return {
|
||
orderId: cartOrderId,
|
||
matchType: 'cart',
|
||
cartMatchContext,
|
||
};
|
||
}
|
||
|
||
throw new Error('未找到对应订单');
|
||
}
|
||
|
||
/**
|
||
* 根据运单号解析唯一订单ID。
|
||
* @param {string} waybillNo 运单号。
|
||
* @return {Promise<number>} 订单ID,未命中返回 0。
|
||
*/
|
||
async pickOrderIdByWaybill(waybillNo) {
|
||
const warehouseId = this.getWarehouseId();
|
||
const orderIds = await this.findOrderIdsByExpressNumbers([ waybillNo ], warehouseId);
|
||
|
||
if (!Array.isArray(orderIds) || orderIds.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
const normalizedOrderIds = orderIds
|
||
.map(item => Number(item))
|
||
.filter(orderId => Number.isFinite(orderId) && orderId > 0)
|
||
.sort((a, b) => a - b);
|
||
|
||
if (normalizedOrderIds.length === 0) {
|
||
return 0;
|
||
}
|
||
|
||
return normalizedOrderIds[0];
|
||
}
|
||
|
||
/**
|
||
* 根据车号在波次拣货任务维度反查订单ID。
|
||
* 匹配字段:任务主表当前车号快照与任务订单行车号快照。
|
||
* @param {string} cartCode 车号。
|
||
* @return {Promise<number>} 订单ID,未命中返回 0。
|
||
*/
|
||
async pickOrderIdByCartCode(cartCode) {
|
||
const cartMatchContext = await this.pickCartMatchContextByCartCode(cartCode);
|
||
const orderId = Number(cartMatchContext?.order_id || 0);
|
||
|
||
return Number.isFinite(orderId) && orderId > 0 ? orderId : 0;
|
||
}
|
||
|
||
/**
|
||
* 根据车号读取任务上下文及任务订单行。
|
||
* @param {string} cartCode 车号。
|
||
* @return {Promise<{order_id:number, task:Object, task_orders:Array<Object>, matched_order_ids:Array<number>}>} 命中上下文。
|
||
*/
|
||
async pickCartMatchContextByCartCode(cartCode) {
|
||
const { ctx } = this;
|
||
const warehouseId = this.getWarehouseId();
|
||
const taskOrderColumnSet = await this.getTableColumnSet('wms_wave_pick_task_order');
|
||
const taskRows = await ctx.model.query(
|
||
`
|
||
SELECT
|
||
t.id AS task_id,
|
||
t.task_no,
|
||
t.pick_mode,
|
||
t.status,
|
||
t.review_status,
|
||
t.current_cart_code_snapshot
|
||
FROM wms_wave_pick_task t
|
||
WHERE t.warehouse_id = :warehouseId
|
||
AND (
|
||
t.current_cart_code_snapshot = :cartCode
|
||
OR EXISTS (
|
||
SELECT 1
|
||
FROM wms_wave_pick_task_order pto
|
||
WHERE pto.task_id = t.id
|
||
AND pto.cart_code_snapshot = :cartCode
|
||
)
|
||
)
|
||
ORDER BY t.create_time DESC, t.id DESC
|
||
LIMIT 1
|
||
`,
|
||
{
|
||
replacements: {
|
||
warehouseId,
|
||
cartCode,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const taskRow = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
|
||
const taskId = Number(taskRow && taskRow.task_id || 0);
|
||
if (!Number.isInteger(taskId) || taskId <= 0) {
|
||
return {
|
||
order_id: 0,
|
||
task: null,
|
||
task_orders: [],
|
||
matched_order_ids: [],
|
||
};
|
||
}
|
||
|
||
const pickStatusSelect = taskOrderColumnSet.has('pick_status')
|
||
? 'pto.pick_status'
|
||
: 'NULL AS pick_status';
|
||
const waveIdSelect = taskOrderColumnSet.has('wave_id')
|
||
? 'pto.wave_id'
|
||
: 'NULL AS wave_id';
|
||
const boxNoSelect = taskOrderColumnSet.has('box_no')
|
||
? 'pto.box_no'
|
||
: 'NULL AS box_no';
|
||
const cartCodeSnapshotSelect = taskOrderColumnSet.has('cart_code_snapshot')
|
||
? 'pto.cart_code_snapshot'
|
||
: 'NULL AS cart_code_snapshot';
|
||
const taskOrderWarehouseFilterSql = taskOrderColumnSet.has('warehouse_id')
|
||
? ' AND pto.warehouse_id = :warehouseId'
|
||
: '';
|
||
const taskOrderRowsRaw = await ctx.model.query(
|
||
`
|
||
SELECT
|
||
pto.id AS task_order_id,
|
||
pto.order_id,
|
||
${pickStatusSelect},
|
||
${waveIdSelect},
|
||
${boxNoSelect},
|
||
${cartCodeSnapshotSelect}
|
||
FROM wms_wave_pick_task_order pto
|
||
WHERE pto.task_id = :taskId
|
||
${taskOrderWarehouseFilterSql}
|
||
ORDER BY pto.id ASC
|
||
`,
|
||
{
|
||
replacements: {
|
||
taskId,
|
||
warehouseId,
|
||
},
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
}
|
||
);
|
||
|
||
const task = {
|
||
task_id: Number(taskRow.task_id || 0),
|
||
task_no: String(taskRow.task_no || '').trim(),
|
||
pick_mode: Number(taskRow.pick_mode || 0),
|
||
status: Number(taskRow.status || 0),
|
||
review_status: Number(taskRow.review_status || 0),
|
||
current_cart_code_snapshot: String(taskRow.current_cart_code_snapshot || '').trim(),
|
||
};
|
||
const taskOrderRows = (Array.isArray(taskOrderRowsRaw) ? taskOrderRowsRaw : []).map(row => ({
|
||
task_order_id: Number(row && row.task_order_id || 0),
|
||
order_id: Number(row && row.order_id || 0),
|
||
pick_status: String(row && row.pick_status || '').trim(),
|
||
wave_id: Number(row && row.wave_id || 0),
|
||
box_no: Number(row && row.box_no || 0),
|
||
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
|
||
}));
|
||
const matchedOrderIds = [ ...new Set(taskOrderRows
|
||
.map(row => Number(row && row.order_id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
|
||
const primaryOrderId = Number(matchedOrderIds[0] || 0);
|
||
|
||
return {
|
||
order_id: Number.isFinite(primaryOrderId) && primaryOrderId > 0 ? primaryOrderId : 0,
|
||
task,
|
||
task_orders: taskOrderRows,
|
||
matched_order_ids: matchedOrderIds,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 读取数据表字段集合。
|
||
* @param {string} tableName 数据表名。
|
||
* @return {Promise<Set<string>>} 字段名集合。
|
||
*/
|
||
async getTableColumnSet(tableName) {
|
||
const { ctx } = this;
|
||
const normalizedTableName = String(tableName || '').trim();
|
||
|
||
if (!normalizedTableName) {
|
||
return new Set();
|
||
}
|
||
|
||
const escapedTableName = normalizedTableName.replace(/`/g, '``');
|
||
|
||
try {
|
||
const rows = await ctx.model.query(`SHOW COLUMNS FROM \`${escapedTableName}\``, {
|
||
type: ctx.model.QueryTypes.SELECT,
|
||
});
|
||
|
||
return new Set((Array.isArray(rows) ? rows : [])
|
||
.map(row => String(row && row.Field || '').trim())
|
||
.filter(Boolean));
|
||
} catch (error) {
|
||
ctx.logger.warn(`[recheckOrder.getTableColumnSet] 获取字段失败, table=${normalizedTableName}, error=${error.message}`);
|
||
return new Set();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解析拣货模式名称。
|
||
* @param {number|string} pickMode 拣货模式编码。
|
||
* @return {string} 拣货模式名称。
|
||
*/
|
||
resolvePickModeName(pickMode) {
|
||
const pickModeMap = {
|
||
1: '团购小波次',
|
||
2: '散单单品单件',
|
||
3: '散单先拣后分',
|
||
4: '边拣边分',
|
||
5: '团购大波次',
|
||
};
|
||
const normalizedPickMode = Number(pickMode || 0);
|
||
|
||
return pickModeMap[normalizedPickMode] || '未知模式';
|
||
}
|
||
|
||
/**
|
||
* 构建车号命中语义化视图。
|
||
* @param {Object} cartMatchContext 车号命中上下文。
|
||
* @return {Promise<Object>} 语义化视图。
|
||
*/
|
||
async buildCartMatchView(cartMatchContext = {}) {
|
||
const context = this.isPlainObject(cartMatchContext) ? cartMatchContext : {};
|
||
const task = this.isPlainObject(context.task) ? context.task : {};
|
||
const taskOrders = Array.isArray(context.task_orders) ? context.task_orders : [];
|
||
const pickMode = Number(task.pick_mode || 0);
|
||
const modeName = this.resolvePickModeName(pickMode);
|
||
const enrichedTaskOrders = await this.enrichTaskOrderRows(taskOrders);
|
||
const taskSummary = {
|
||
task_id: Number(task.task_id || 0),
|
||
task_no: String(task.task_no || '').trim(),
|
||
pick_mode: pickMode,
|
||
status: Number(task.status || 0),
|
||
review_status: Number(task.review_status || 0),
|
||
current_cart_code_snapshot: String(task.current_cart_code_snapshot || '').trim(),
|
||
order_count: enrichedTaskOrders.length,
|
||
};
|
||
|
||
const baseView = {
|
||
mode_code: pickMode,
|
||
mode_name: modeName,
|
||
view_type: 'orders',
|
||
task: taskSummary,
|
||
};
|
||
|
||
if ([ 1, 5 ].includes(pickMode)) {
|
||
return {
|
||
...baseView,
|
||
view_type: 'groups',
|
||
groups: this.groupTaskOrdersByWaveId(enrichedTaskOrders),
|
||
};
|
||
}
|
||
if (pickMode === 2) {
|
||
return {
|
||
...baseView,
|
||
view_type: 'orders',
|
||
orders: enrichedTaskOrders,
|
||
};
|
||
}
|
||
if (pickMode === 3) {
|
||
return {
|
||
...baseView,
|
||
view_type: 'pick_groups',
|
||
pick_groups: this.groupTaskOrdersByPickStatus(enrichedTaskOrders),
|
||
};
|
||
}
|
||
if (pickMode === 4) {
|
||
return {
|
||
...baseView,
|
||
view_type: 'box_groups',
|
||
box_groups: this.groupTaskOrdersByBoxNo(enrichedTaskOrders),
|
||
};
|
||
}
|
||
|
||
return {
|
||
...baseView,
|
||
view_type: 'orders',
|
||
orders: enrichedTaskOrders,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 追加任务订单行的订单维度字段。
|
||
* @param {Array<Object>} taskOrders 任务订单行。
|
||
* @return {Promise<Array<Object>>} 扩展后的任务订单行。
|
||
*/
|
||
async enrichTaskOrderRows(taskOrders = []) {
|
||
const warehouseId = this.getWarehouseId();
|
||
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
|
||
const orderIds = [ ...new Set(normalizedTaskOrders
|
||
.map(row => Number(row && row.order_id || 0))
|
||
.filter(orderId => Number.isInteger(orderId) && orderId > 0)) ];
|
||
|
||
if (orderIds.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
|
||
const orderRows = await orderModel.findAll({
|
||
where: this.buildOrderWhere(orderIds, warehouseId),
|
||
attributes: [ 'id', 'wave_id', 'pick_status' ],
|
||
raw: true,
|
||
});
|
||
const orderMap = new Map((Array.isArray(orderRows) ? orderRows : [])
|
||
.map(row => [
|
||
Number(row && row.id || 0),
|
||
{
|
||
wave_id: Number(row && row.wave_id || 0),
|
||
pick_status: String(row && row.pick_status || '').trim(),
|
||
},
|
||
])
|
||
.filter(item => Number(item[0]) > 0));
|
||
|
||
return normalizedTaskOrders.map(row => {
|
||
const orderId = Number(row && row.order_id || 0);
|
||
const orderInfo = orderMap.get(orderId) || {};
|
||
const waveId = Number(row && row.wave_id || 0) > 0
|
||
? Number(row && row.wave_id || 0)
|
||
: Number(orderInfo.wave_id || 0);
|
||
const pickStatus = String(row && row.pick_status || '').trim() || String(orderInfo.pick_status || '').trim() || 'unknown';
|
||
|
||
return {
|
||
task_order_id: Number(row && row.task_order_id || 0),
|
||
order_id: orderId,
|
||
wave_id: Number.isInteger(waveId) && waveId > 0 ? waveId : 0,
|
||
pick_status: pickStatus,
|
||
box_no: Number(row && row.box_no || 0),
|
||
cart_code_snapshot: String(row && row.cart_code_snapshot || '').trim(),
|
||
};
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 按 wave_id 分组。
|
||
* @param {Array<Object>} taskOrders 任务订单行。
|
||
* @return {Array<Object>} wave 分组结果。
|
||
*/
|
||
groupTaskOrdersByWaveId(taskOrders = []) {
|
||
return this.groupTaskOrders(taskOrders, row => `wave_${Number(row && row.wave_id || 0)}`, row => ({
|
||
wave_id: Number(row && row.wave_id || 0),
|
||
orders: [],
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 按 pick_status 分组。
|
||
* @param {Array<Object>} taskOrders 任务订单行。
|
||
* @return {Array<Object>} pick_status 分组结果。
|
||
*/
|
||
groupTaskOrdersByPickStatus(taskOrders = []) {
|
||
return this.groupTaskOrders(taskOrders, row => `pick_status_${String(row && row.pick_status || 'unknown').trim() || 'unknown'}`, row => ({
|
||
pick_status: String(row && row.pick_status || 'unknown').trim() || 'unknown',
|
||
orders: [],
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 按 box_no 分组。
|
||
* @param {Array<Object>} taskOrders 任务订单行。
|
||
* @return {Array<Object>} box_no 分组结果。
|
||
*/
|
||
groupTaskOrdersByBoxNo(taskOrders = []) {
|
||
return this.groupTaskOrders(taskOrders, row => `box_${Number(row && row.box_no || 0)}`, row => ({
|
||
box_no: Number(row && row.box_no || 0),
|
||
orders: [],
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 通用任务订单分组。
|
||
* @param {Array<Object>} taskOrders 任务订单行。
|
||
* @param {Function} keyGetter 分组键生成器。
|
||
* @param {Function} initGroup 分组初始化函数。
|
||
* @return {Array<Object>} 分组列表。
|
||
*/
|
||
groupTaskOrders(taskOrders = [], keyGetter, initGroup) {
|
||
const normalizedTaskOrders = Array.isArray(taskOrders) ? taskOrders : [];
|
||
const groupMap = new Map();
|
||
|
||
normalizedTaskOrders.forEach(row => {
|
||
const groupKey = String(keyGetter(row));
|
||
|
||
if (!groupMap.has(groupKey)) {
|
||
groupMap.set(groupKey, initGroup(row));
|
||
}
|
||
|
||
const group = groupMap.get(groupKey);
|
||
group.orders.push({ ...row });
|
||
});
|
||
|
||
return Array.from(groupMap.values()).map(group => ({
|
||
...group,
|
||
order_count: Array.isArray(group.orders) ? group.orders.length : 0,
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 生成复核单号。
|
||
* @param {number} orderId 订单ID。
|
||
* @param {Date} now 当前时间。
|
||
* @return {string} 复核单号。
|
||
*/
|
||
buildRecheckReviewNo(orderId, now = new Date()) {
|
||
const timestamp = Number(now.getTime());
|
||
const paddedOrderId = String(orderId).padStart(6, '0');
|
||
|
||
return `RC${timestamp}${paddedOrderId}`;
|
||
}
|
||
|
||
/**
|
||
* 校验订单是否允许复核,仅未拣货订单可执行复核。
|
||
* @param {Object} order 订单信息。
|
||
*/
|
||
assertOrderCanRecheck(order = {}) {
|
||
if (String(order.pick_status || '') !== 'none') {
|
||
throw new Error('订单未拣货,不允许复核。');
|
||
}
|
||
}
|
||
}
|
||
|
||
module.exports = RecheckOrderService;
|