682 lines
21 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 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;