feat(print): 新增确认打印功能(confirm_print_status + confirmWavePrint/confirmPrintScan 接口)

This commit is contained in:
liufumingren 2026-09-20 16:13:59 +08:00
parent a3ec20098f
commit 17f7e3d87b
9 changed files with 758 additions and 9 deletions

View File

@ -77,6 +77,7 @@ module.exports = {
ORDER_WAVE_AUTO_GROUP: '自动加团',
ORDER_WAVE_STRATEGY_FETCH: '策略抓取波次',
ORDER_WAVE_CLAIM: '领取波次',
ORDER_CONFIRM_PRINT: '确认打印',
ORDER_AUTO_EXPRESS_SKIP: '跳过自动分配快递',
ORDER_PICK_COMPLETE: '拣货完成',
ORDER_RECHECK: '订单复核',

View File

@ -15,6 +15,7 @@ module.exports = app => {
SENDED_STATUS: [ 'none', 'padding', 'fin', 'error' ],
INSPECTION_STATUS: [ 'none', 'padding', 'running', 'fin', 'error' ],
PRINT_STATUS: [ 'none', 'padding', 'fin', 'error' ],
CONFIRM_PRINT_STATUS: [ 'none', 'fin' ],
PRINT_LOCK_STATUS: [ 'none', 'warehouse' ],
CLAIM_STATUS: [ 'none', 'padding', 'fin', 'error' ],
OUTBOUND_STATUS: [ 'none', 'padding', 'fin', 'timeout', 'error' ],
@ -533,6 +534,12 @@ module.exports = app => {
defaultValue: 'none',
comment: '打印状态机',
},
confirm_print_status: {
type: ENUM(...StatusEnum.CONFIRM_PRINT_STATUS),
allowNull: true,
defaultValue: 'none',
comment: '确认打印状态机(打印完成后真实扫描面单确认)',
},
claim_status: {
type: ENUM(...StatusEnum.CLAIM_STATUS),
allowNull: true,

View File

@ -1182,6 +1182,7 @@ module.exports = app => {
inspection_status: [ 'none', 'padding', 'running', 'fin', 'error' ],
step: [ 0, 1 ],
print_status: [ 'none', 'padding', 'fin', 'error' ],
confirm_print_status: [ 'none', 'fin' ],
print_lock_status: [ 'none', 'warehouse' ],
claim_status: [ 'none', 'padding', 'fin', 'error' ],
outbound_status: [ 'none', 'padding', 'fin', 'timeout', 'error' ],

View File

@ -45,7 +45,7 @@ const ORDER_LIST_BASE_ATTRIBUTES = [
'wave_strategy_version',
'wave_scan_result',
'post_status', 'storage_status', 'pick_status', 'pack_status',
'inspection_status', 'print_status', 'claim_status',
'inspection_status', 'print_status', 'confirm_print_status', 'claim_status',
'outbound_status', 'lock_status', 'intercept_status', 'basket_number', 'recheck_status',
'create_channel',
'store_id',

View File

@ -26,6 +26,9 @@ const WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_CACHE_KEY_PREFIX = 'wave:quick-sca
const WAVE_STRATEGY_QUICK_SCAN_WAREHOUSE_LOCK_TTL_SECONDS = 60 * 60 * 2;
const WAVE_STRATEGY_LIST_CACHE_KEY_PREFIX = 'wave:strategy-list:';
const WAVE_STRATEGY_LIST_CACHE_TTL_SECONDS = 60 * 30;
const CONFIRM_PRINT_UNCLAIMED_VERSION_KEY_PREFIX = 'wave:confirm-print:unclaimed:version:';
const CONFIRM_PRINT_UNCLAIMED_POLL_TIMEOUT_MS = 60 * 1000;
const CONFIRM_PRINT_UNCLAIMED_POLL_INTERVAL_MS = 1000;
const BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID = 1;
const BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_IDS = [ BATCH_ALLOCATE_STORAGE_FORCE_BUSINESS_ID ];
const BATCH_ALLOCATE_STORAGE_WAREHOUSE_TASK_LOCK_MAP = new Map();
@ -87,6 +90,17 @@ const BATCH_LIST_ASSIGNMENT_FILTER_SCHEMAS = Object.freeze({
statsColumnPrefix: 'print',
withErrorStatus: false,
}),
confirm_print: Object.freeze({
fieldName: 'confirm_print_assignment_status',
enumMap: Object.freeze({
unconfirmed: 'none',
partially_confirmed: 'partial',
confirmed: 'finished',
}),
caseInsensitive: true,
statsColumnPrefix: 'confirm_print',
withErrorStatus: false,
}),
review: Object.freeze({
fieldName: 'review_assignment_status',
enumMap: Object.freeze({
@ -120,9 +134,9 @@ class WaveService extends OrderBaseService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = '';
const _noNeedRight = 'wavePickTaskCancelSelf,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
const _noNeedLog = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
const _noNeedAuth = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress';
const _noNeedRight = 'wavePickTaskCancelSelf,groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress,confirmPrintUnclaimedWaveCount';
const _noNeedLog = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress,confirmPrintScan,confirmPrintUnclaimedWaveCount';
const _noNeedAuth = 'groupOrderFetchList,singleOrderFetchList,waveStrategyList,waveStrategyFallbackOrderList,waveStrategyFetchPda,waveStrategyFetchAdmin,groupFetch,singleFetch,fetch,fetchTaskProgress,batchList,wavePickTaskList,batchCancel,batchCancelTaskProgress,batchRemoveExceptionOrders,batchRemoveExceptionOrdersTaskProgress,batchAllocateExpress,batchAllocateExpressTaskProgress,batchAllocateStorage,batchAllocateStorageTaskProgress,batchAutoGrouping,batchFinishAutoGrouping,batchRemoveOrders,singleFetchByIds,waveStrategyQuickScan,waveStrategyQuickScanTaskProgress,confirmPrintUnclaimedWaveCount';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
@ -1196,6 +1210,9 @@ class WaveService extends OrderBaseService {
scene: 'fetchSingleStructure',
});
// 抓取波次(source=1/2)会冗余写入领料人/领料时间,递增统计版本号驱动长轮询
await this.bumpConfirmPrintUnclaimedWaveVersion(warehouseId);
const mergedOrderIds = [ ...new Set(allOrderIds) ].sort((a, b) => a - b);
this.enqueueWaveStrategyQuickScanPostOrderChange(warehouseId, mergedOrderIds, {
triggerScan: false,
@ -1406,6 +1423,43 @@ class WaveService extends OrderBaseService {
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'print');
}
/**
* 规范化波次列表确认打印状态筛选值(英文枚举)。
*
* @param {string} value 入参筛选值。
* @return {string} 规范化后的筛选值,未传时返回空字符串。
*/
normalizeBatchListConfirmPrintAssignmentStatusFilter(value) {
return this.normalizeBatchListAssignmentStatusFilterByType(value, 'confirm_print');
}
/**
* 规范化波次列表领料状态筛选值。
*
* 领料状态以波次表 claim_time 为准(二态,无 partial):
* - none = 未领料(claim_time IS NULL);
* - finished = 已领料(claim_time IS NOT NULL)。
*
* @param {string} value 入参筛选值(unclaimed/claimed,兼容中文 未领料/已领料)。
* @return {string} 规范化后的筛选值(none/finished),未传时返回空字符串。
*/
normalizeBatchListClaimAssignmentStatusFilter(value) {
if (value === undefined || value === null || value === '') {
return '';
}
const normalizedValue = String(value).trim().toLowerCase();
if (!normalizedValue) {
return '';
}
if ([ 'unclaimed', 'none', '未领料', '未领单' ].includes(normalizedValue)) {
return 'none';
}
if ([ 'claimed', 'finished', '已领料', '已领单' ].includes(normalizedValue)) {
return 'finished';
}
throw new Error('claim_assignment_status 参数不合法,仅支持: unclaimed / claimed(未领料 / 已领料)');
}
/**
* 规范化波次列表复核状态筛选值(英文枚举)。
*
@ -1429,7 +1483,7 @@ class WaveService extends OrderBaseService {
/**
* 根据类型获取波次分配状态筛选配置。
*
* @param {'storage'|'express'|'print'} type 筛选类型。
* @param {'storage'|'express'|'print'|'confirm_print'} type 筛选类型。
* @return {{ fieldName: string, enumMap: Object, caseInsensitive: boolean, statsColumnPrefix: string, withErrorStatus: boolean }} 筛选配置。
*/
getBatchListAssignmentFilterSchema(type) {
@ -1445,7 +1499,7 @@ class WaveService extends OrderBaseService {
* 按类型规范化波次列表分配状态筛选值。
*
* @param {string} value 入参筛选值。
* @param {'storage'|'express'|'print'} type 筛选类型。
* @param {'storage'|'express'|'print'|'confirm_print'} type 筛选类型。
* @return {string} 规范化后的筛选值,未传时返回空字符串。
*/
normalizeBatchListAssignmentStatusFilterByType(value, type) {
@ -1553,6 +1607,45 @@ class WaveService extends OrderBaseService {
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'print');
}
/**
* 构建波次列表确认打印状态筛选 SQL 条件。
*
* @param {string} statusFilter 确认打印状态筛选值(none/partial/finished)。
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
*/
buildBatchListConfirmPrintAssignmentFilterClause(statusFilter = '') {
return this.buildBatchListAssignmentStatusFilterClauseByType(statusFilter, 'confirm_print');
}
/**
* 构建波次列表领料状态筛选 SQL 条件(波次表 claim_time 口径,二态)。
*
* @param {string} statusFilter 领料状态筛选值(none/finished)。
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
*/
buildBatchListClaimAssignmentFilterClause(statusFilter = '') {
const normalizedStatusFilter = String(statusFilter || '').trim();
if (!normalizedStatusFilter) {
return {
sql: '',
replacements: {},
};
}
if (normalizedStatusFilter === 'none') {
return {
sql: '\n AND wb.claim_time IS NULL',
replacements: {},
};
}
if (normalizedStatusFilter === 'finished') {
return {
sql: '\n AND wb.claim_time IS NOT NULL',
replacements: {},
};
}
throw new Error(`不支持的领料状态筛选值: ${normalizedStatusFilter}`);
}
/**
* 构建波次列表复核状态筛选 SQL 条件。
*
@ -1577,7 +1670,7 @@ class WaveService extends OrderBaseService {
* 按类型构建波次列表分配状态筛选 SQL 条件。
*
* @param {string} statusFilter 分配状态筛选值(none/partial/finished)。
* @param {'storage'|'express'|'print'} type 筛选类型。
* @param {'storage'|'express'|'print'|'confirm_print'} type 筛选类型。
* @return {{ sql: string, replacements: Object }} SQL 条件片段与参数。
*/
buildBatchListAssignmentStatusFilterClauseByType(statusFilter = '', type = 'storage') {
@ -2023,6 +2116,8 @@ class WaveService extends OrderBaseService {
'storage_assignment_status',
'express_assignment_status',
'print_assignment_status',
'confirm_print_assignment_status',
'claim_assignment_status',
'review_assignment_status',
'sync_assignment_status',
'store_id',
@ -2226,6 +2321,14 @@ class WaveService extends OrderBaseService {
'print_assignment_status',
value => this.normalizeBatchListPrintAssignmentStatusFilter(value)
);
const confirmPrintAssignmentStatus = resolveAssignmentStatusFilter(
'confirm_print_assignment_status',
value => this.normalizeBatchListConfirmPrintAssignmentStatusFilter(value)
);
const claimAssignmentStatus = resolveAssignmentStatusFilter(
'claim_assignment_status',
value => this.normalizeBatchListClaimAssignmentStatusFilter(value)
);
const reviewAssignmentStatus = resolveAssignmentStatusFilter(
'review_assignment_status',
value => this.normalizeBatchListReviewAssignmentStatusFilter(value)
@ -2241,6 +2344,8 @@ class WaveService extends OrderBaseService {
storageAssignmentStatus,
expressAssignmentStatus,
printAssignmentStatus,
confirmPrintAssignmentStatus,
claimAssignmentStatus,
reviewAssignmentStatus,
syncAssignmentStatus,
storeIds: storeIdCondition.ids,
@ -5069,6 +5174,8 @@ class WaveService extends OrderBaseService {
const storageAssignmentFilterClause = this.buildBatchListStorageAssignmentFilterClause(whereClause.storageAssignmentStatus);
const expressAssignmentFilterClause = this.buildBatchListExpressAssignmentFilterClause(whereClause.expressAssignmentStatus);
const printAssignmentFilterClause = this.buildBatchListPrintAssignmentFilterClause(whereClause.printAssignmentStatus);
const confirmPrintAssignmentFilterClause = this.buildBatchListConfirmPrintAssignmentFilterClause(whereClause.confirmPrintAssignmentStatus);
const claimAssignmentFilterClause = this.buildBatchListClaimAssignmentFilterClause(whereClause.claimAssignmentStatus);
const reviewAssignmentFilterClause = this.buildBatchListReviewAssignmentFilterClause(whereClause.reviewAssignmentStatus);
const syncAssignmentFilterClause = this.buildBatchListSyncAssignmentFilterClause(whereClause.syncAssignmentStatus);
const onlyTodo = Number(requestData.only_todo || 0);
@ -5115,6 +5222,8 @@ class WaveService extends OrderBaseService {
item_snapshot_key,
warehouse_id,
creator,
claim_operator,
claim_time,
create_time,
update_time
FROM wms_wave_batch
@ -5132,6 +5241,8 @@ class WaveService extends OrderBaseService {
SUM(CASE WHEN od.post_status = 'error' THEN 1 ELSE 0 END) AS post_error_count,
SUM(CASE WHEN od.print_status = 'none' THEN 1 ELSE 0 END) AS print_none_count,
SUM(CASE WHEN od.print_status = 'fin' THEN 1 ELSE 0 END) AS print_fin_count,
SUM(CASE WHEN od.confirm_print_status = 'none' THEN 1 ELSE 0 END) AS confirm_print_none_count,
SUM(CASE WHEN od.confirm_print_status = 'fin' THEN 1 ELSE 0 END) AS confirm_print_fin_count,
SUM(CASE WHEN od.recheck_status = 'fin' THEN 1 ELSE 0 END) AS review_fin_count,
SUM(CASE WHEN od.recheck_status = 'error' THEN 1 ELSE 0 END) AS review_error_count,
SUM(CASE WHEN od.recheck_status NOT IN ('fin', 'error') THEN 1 ELSE 0 END) AS review_none_count,
@ -5159,6 +5270,8 @@ class WaveService extends OrderBaseService {
${storageAssignmentFilterClause.sql}
${expressAssignmentFilterClause.sql}
${printAssignmentFilterClause.sql}
${confirmPrintAssignmentFilterClause.sql}
${claimAssignmentFilterClause.sql}
${reviewAssignmentFilterClause.sql}
${syncAssignmentFilterClause.sql}
${onlyTodo === 1 ? '\n AND COALESCE(wave_order_stats.order_total, 0) - COALESCE(wave_order_stats.review_fin_count, 0) > 0' : ''}
@ -5179,6 +5292,8 @@ class WaveService extends OrderBaseService {
wb.item_snapshot_key,
wb.warehouse_id,
wb.creator,
wb.claim_operator,
wb.claim_time,
wb.create_time,
wb.update_time,
COALESCE(wave_order_stats.order_total, 0) AS order_total,
@ -5190,6 +5305,8 @@ class WaveService extends OrderBaseService {
COALESCE(wave_order_stats.post_error_count, 0) AS post_error_count,
COALESCE(wave_order_stats.print_none_count, 0) AS print_none_count,
COALESCE(wave_order_stats.print_fin_count, 0) AS print_fin_count,
COALESCE(wave_order_stats.confirm_print_none_count, 0) AS confirm_print_none_count,
COALESCE(wave_order_stats.confirm_print_fin_count, 0) AS confirm_print_fin_count,
COALESCE(wave_order_stats.review_fin_count, 0) AS review_fin_count,
COALESCE(wave_order_stats.review_error_count, 0) AS review_error_count,
COALESCE(wave_order_stats.review_none_count, 0) AS review_none_count,
@ -5221,6 +5338,8 @@ class WaveService extends OrderBaseService {
...storageAssignmentFilterClause.replacements,
...expressAssignmentFilterClause.replacements,
...printAssignmentFilterClause.replacements,
...confirmPrintAssignmentFilterClause.replacements,
...claimAssignmentFilterClause.replacements,
...reviewAssignmentFilterClause.replacements,
...syncAssignmentFilterClause.replacements,
...(storeIdFilter.length > 0 ? { whereStoreIds: storeIdFilter } : {}),
@ -5236,6 +5355,8 @@ class WaveService extends OrderBaseService {
...storageAssignmentFilterClause.replacements,
...expressAssignmentFilterClause.replacements,
...printAssignmentFilterClause.replacements,
...confirmPrintAssignmentFilterClause.replacements,
...claimAssignmentFilterClause.replacements,
...reviewAssignmentFilterClause.replacements,
...syncAssignmentFilterClause.replacements,
...(storeIdFilter.length > 0 ? { whereStoreIds: storeIdFilter } : {}),
@ -5275,6 +5396,8 @@ class WaveService extends OrderBaseService {
const expressErrorCount = Number(batch && batch.post_error_count || 0);
const printNoneCount = Number(batch && batch.print_none_count || 0);
const printFinCount = Number(batch && batch.print_fin_count || 0);
const confirmPrintNoneCount = Number(batch && batch.confirm_print_none_count || 0);
const confirmPrintFinCount = Number(batch && batch.confirm_print_fin_count || 0);
const pickNoneCount = Number(batch && batch.pick_none_count || 0);
const pickFinCount = Number(batch && batch.pick_fin_count || 0);
const pickErrorCount = Number(batch && batch.pick_error_count || 0);
@ -5333,6 +5456,14 @@ class WaveService extends OrderBaseService {
partial: '部分打印',
finished: '已打印',
}),
confirm_print_assignment_status: this.resolveAssignmentStatus(orderCount, confirmPrintNoneCount, confirmPrintFinCount, 0, {
none: '未确认打印',
partial: '部分确认打印',
finished: '已确认打印',
}),
claim_assignment_status: batch && batch.claim_time ? '已领料' : '未领料',
claim_time: batch && batch.claim_time || null,
claim_operator: String(batch && batch.claim_operator || '').trim(),
pick_assignment_status: this.resolveAssignmentStatus(orderCount, pickNoneCount, pickFinCount, pickErrorCount, {
none: '未拣货',
partial: '部分拣货',
@ -5364,6 +5495,214 @@ class WaveService extends OrderBaseService {
});
}
/**
* 获取确认打印未领单波次版本号的缓存 key。
*
* @param {number} warehouseId 仓库ID。
* @return {string} 缓存 key。
*/
getConfirmPrintUnclaimedVersionKey(warehouseId) {
return `${CONFIRM_PRINT_UNCLAIMED_VERSION_KEY_PREFIX}${warehouseId}`;
}
/**
* 递增确认打印未领单波次版本号。
*
* 确认打印(print.confirmWavePrint)与领单(pick.waveClaimScan)会改变统计结果,
* 操作成功后调用本方法,驱动 confirmPrintUnclaimedWaveCount 长轮询立即返回新值。
* Redis 不可用或失败仅记录 warn,不影响主流程(长轮询端会降级为轮询 DB)。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<void>} 无返回值。
*/
async bumpConfirmPrintUnclaimedWaveVersion(warehouseId) {
try {
const client = this.app && this.app.redis && typeof this.app.redis.get === 'function'
? this.app.redis.get('cache')
: null;
if (client && typeof client.incr === 'function') {
await client.incr(this.getConfirmPrintUnclaimedVersionKey(warehouseId));
}
} catch (error) {
this.ctx.logger.warn('[wave.confirmPrintVersion] 版本号递增失败', {
warehouseId,
error: error && error.message ? error.message : `${error}`,
});
}
}
/**
* 读取确认打印未领单波次版本号。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<number|null>} 版本号,读取失败或不存在时返回 null。
*/
async getConfirmPrintUnclaimedWaveVersion(warehouseId) {
try {
const client = this.app && this.app.redis && typeof this.app.redis.get === 'function'
? this.app.redis.get('cache')
: null;
if (!client || typeof client.get !== 'function') {
return null;
}
const rawValue = await client.get(this.getConfirmPrintUnclaimedVersionKey(warehouseId));
const value = Number(rawValue);
return Number.isFinite(value) && value > 0 ? value : null;
} catch (error) {
this.ctx.logger.warn('[wave.confirmPrintVersion] 版本号读取失败', {
warehouseId,
error: error && error.message ? error.message : `${error}`,
});
return null;
}
}
/**
* 查询「已确认打印但未领单」的波次数量(波次表驱动口径)。
*
* 口径说明:
* - 未领单:以波次表为准(wb.claim_time IS NULL)。历史领单发生在 wms_wave_batch
* 增加 claim_time 字段之前时,订单维度 claim_status 可能已是 'fin' 但波次表无
* 记录,故不能用订单 claim_status 判断「波次是否领单」。
* - 已确认打印:波次下存在 confirm_print_status='fin' 的非取消订单。
* - 仅统计 wave_status 0/1 的波次(与波次列表一致)。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<number>} 波次数量。
*/
async queryConfirmPrintUnclaimedWaveCount(warehouseId) {
const orderModel = await this.getOrderModel('pendingOrder', warehouseId);
const orderTableName = this.getModelTableSqlName(orderModel);
const rows = await this.ctx.model.query(
`SELECT COUNT(*) AS wave_count
FROM wms_wave_batch wb
WHERE wb.warehouse_id = :warehouseId
AND wb.wave_status IN (0, 1)
AND wb.claim_time IS NULL
AND EXISTS (
SELECT 1
FROM ${orderTableName} od
WHERE od.wave_id = wb.wave_id
AND od.warehouse_id = wb.warehouse_id
AND od.status <> 'cancel'
AND od.confirm_print_status = 'fin'
)`,
{ replacements: { warehouseId } }
);
const rawList = Array.isArray(rows && rows[0]) ? rows[0] : [];
return Number(rawList[0] && rawList[0].wave_count || 0);
}
/**
* 确认打印扫描(与领单 pick.waveClaimScan 操作一致):
* 扫波次内任一订单面单号,将波次下已打印且非拦截的订单批量置
* confirm_print_status='fin' 并写订单操作日志。
*
* 实际复用 print.confirmWavePrint 实现,避免重复维护;
* 成功后递增统计版本号,驱动 confirmPrintUnclaimedWaveCount 长轮询。
*
* @param {Object} data 入参。
* @param {string} data.waybill_no 面单号/运单号(必填)。
* @return {Promise<Object>} 统一返回结构。
*/
async confirmPrintScan(data = {}) {
const printService = this.ctx.service
&& this.ctx.service.systemMethods
&& this.ctx.service.systemMethods.print;
if (!printService || typeof printService.confirmWavePrint !== 'function') {
return this.fail('确认打印服务不可用', {}, 500);
}
return await printService.confirmWavePrint(data);
}
/**
* 快速查询「已确认打印但未领单」的波次数量(波次表驱动口径:
* 未领单以 wms_wave_batch.claim_time IS NULL 为准,已确认打印以波次下存在
* confirm_print_status='fin' 的订单为准)。
*
* 长轮询语义(参考工作台扫码登录):
* - 不传 last_count:立即返回当前值(status=current);
* - 传 last_count 且与当前值不同:立即返回新值(status=changed);
* - 传 last_count 且与当前值相同:进入等待,每 1s 检查一次版本号(确认打印/领单
* 成功会递增版本号),最长等待 60s;期间变化立即返回新值(status=changed),
* 超时未变化则重查一次返回当前值(status=timeout)。
*
* @param {Object} [data={}] 入参。
* @param {number|string} [data.last_count] 上次调用返回的 count(可选基线)。
* @return {Promise<Object>} 统一返回结构,data 含 count / warehouse_id / status。
*/
async confirmPrintUnclaimedWaveCount(data = {}) {
const requestData = this.isPlainObject(data) ? data : {};
const warehouseId = Number(this.getWarehouseId() || 0);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
return this.fail('未识别到当前仓库上下文', {}, 400);
}
const rawLastCount = requestData.last_count === undefined
? requestData.lastCount
: requestData.last_count;
const hasBaseline = rawLastCount !== undefined && rawLastCount !== null && rawLastCount !== '';
const lastCount = hasBaseline ? Number(rawLastCount) : NaN;
let currentCount = await this.queryConfirmPrintUnclaimedWaveCount(warehouseId);
// 未带基线或基线非法:直接返回当前值(快速查询)
if (!hasBaseline || !Number.isFinite(lastCount)) {
return this.success('ok', {
count: currentCount,
warehouse_id: warehouseId,
status: 'current',
});
}
// 已变化:立即返回新值
if (currentCount !== lastCount) {
return this.success('ok', {
count: currentCount,
warehouse_id: warehouseId,
status: 'changed',
});
}
// 等待变化:优先轮询版本号(低成本),版本号不可用时降级为轮询 DB
const baselineVersion = await this.getConfirmPrintUnclaimedWaveVersion(warehouseId);
const startedAt = Date.now();
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
while (Date.now() - startedAt < CONFIRM_PRINT_UNCLAIMED_POLL_TIMEOUT_MS) {
await sleep(CONFIRM_PRINT_UNCLAIMED_POLL_INTERVAL_MS);
const currentVersion = await this.getConfirmPrintUnclaimedWaveVersion(warehouseId);
if (baselineVersion !== null && currentVersion !== null && currentVersion !== baselineVersion) {
currentCount = await this.queryConfirmPrintUnclaimedWaveCount(warehouseId);
return this.success('ok', {
count: currentCount,
warehouse_id: warehouseId,
status: 'changed',
});
}
// 版本号不可用:降级为直接对比 count
if (baselineVersion === null || currentVersion === null) {
currentCount = await this.queryConfirmPrintUnclaimedWaveCount(warehouseId);
if (currentCount !== lastCount) {
return this.success('ok', {
count: currentCount,
warehouse_id: warehouseId,
status: 'changed',
});
}
}
}
// 超时兜底:重查一次返回当前值(若期间恰好变化也返回新值)
currentCount = await this.queryConfirmPrintUnclaimedWaveCount(warehouseId);
return this.success('ok', {
count: currentCount,
warehouse_id: warehouseId,
status: currentCount !== lastCount ? 'changed' : 'timeout',
});
}
/**
* 拣货任务列表查询。
*
@ -11780,6 +12119,9 @@ class WaveService extends OrderBaseService {
transaction,
}
);
// 领料时间写入会改变确认打印未领单统计,递增版本号驱动长轮询
await this.bumpConfirmPrintUnclaimedWaveVersion(warehouseId);
}
await this.rebuildOrderWaveIndex({

View File

@ -2035,6 +2035,20 @@ class PickService extends MainService {
await transaction.commit();
// 驱动确认打印未领单波次统计长轮询:领单会减少未领单波次数量,递增版本号
try {
const waveService = ctx.service
&& ctx.service.systemMethods
&& ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.bumpConfirmPrintUnclaimedWaveVersion === 'function') {
await waveService.bumpConfirmPrintUnclaimedWaveVersion(normalizedWarehouseId);
}
} catch (error) {
ctx.logger.warn('[PickService.waveClaimScan] 统计版本号递增失败: %s',
error && error.message ? error.message : error);
}
return this.success('ok', {
data: {
...baseResponse,

View File

@ -7,7 +7,10 @@ const {
ExpressPrintPayloadBuilder,
RequestScopedPrintIdGenerator,
} = require('../../lib/express_print_payload_builder');
const { INTERCEPT_STATUS_NONE } = require('../../lib/intercept_guard');
const {
INTERCEPT_STATUS_NONE,
isInterceptedOrderStatus,
} = require('../../lib/intercept_guard');
/**
* 打印 Service
@ -1715,6 +1718,222 @@ class PrintService extends MainService {
}
}
/**
* 波次确认打印:扫描波次内任一订单的面单号,将波次下全部已打印且非拦截的订单
* 批量标记 confirm_print_status='fin',记录「打印完成后真实扫描面单确认」。
*
* 约束:
* - 仅当前仓库下的订单可确认(面单定位强制 warehouse_id 隔离);
* - 波次下存在未打印订单(print_status != 'fin',拦截订单除外)时阻断;
* - 拦截订单跳过(不确认、不阻断);
* - 全部已确认时重复扫描返回 already_confirmed,不重复写日志。
*
* @param {Object} data 入参。
* @param {string} data.waybill_no 面单号/运单号(必填)。
* @return {Promise<Object>} 统一返回结构。
*/
async confirmWavePrint(data = {}) {
const { ctx } = this;
const requestData = data && typeof data === 'object' && !Array.isArray(data) ? data : {};
const waybillNo = String(requestData.waybill_no || requestData.waybillNo || '').trim();
if (!waybillNo) {
return this.fail('waybill_no 必填(面单号/运单号)', {}, 400);
}
// --- 仓库上下文 ---
const userWarehouseId = ctx && ctx.user ? ctx.user.store_id : undefined;
const stateWarehouseId = ctx && ctx.state && ctx.state.user ? ctx.state.user.store_id : undefined;
const warehouseId = Number(userWarehouseId || stateWarehouseId || 0);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) {
return this.fail('缺少当前用户仓库上下文 store_id', {}, 400);
}
// --- 1. 面单号定位订单 ---
const orderExpress = await ctx.model.OrderExpress.findOne({
where: {
warehouse_id: warehouseId,
waybill_code: waybillNo,
},
attributes: [ 'order_id' ],
raw: true,
});
const matchedOrderId = Number(orderExpress && orderExpress.order_id || 0);
if (!(matchedOrderId > 0)) {
return this.fail('未查询到该面单号对应的订单,无记录', {}, 404);
}
// --- 2. 订单定位波次 ---
const orderDeliveryFactory = ctx.model && ctx.model.OrderDeliveryFactory;
if (!orderDeliveryFactory || typeof orderDeliveryFactory.getCurrentModel !== 'function') {
return this.fail('OrderDeliveryFactory 不可用', {}, 500);
}
let orderModel = null;
try {
orderModel = await orderDeliveryFactory.getCurrentModel(warehouseId);
} catch (error) {
return this.fail(error && error.message ? error.message : '订单模型不可用', {}, 500);
}
const order = await orderModel.findOne({
where: {
id: matchedOrderId,
warehouse_id: warehouseId,
},
attributes: [ 'id', 'wave_id', 'wave_no' ],
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);
}
// --- 3. 查询波次下全部订单 ---
const waveOrderWhere = { warehouse_id: warehouseId };
if (orderWaveId > 0) {
waveOrderWhere.wave_id = orderWaveId;
} else {
waveOrderWhere.wave_no = orderWaveNo;
}
const waveOrderRows = await orderModel.findAll({
where: waveOrderWhere,
attributes: [ 'id', 'print_status', 'confirm_print_status', 'intercept_status' ],
raw: true,
});
const waveOrders = Array.isArray(waveOrderRows) ? waveOrderRows : [];
if (waveOrders.length === 0) {
return this.fail('波次下无可用订单', {}, 400);
}
// --- 4. 统计与校验(拦截订单跳过,未打印阻断) ---
const interceptedWaveOrderIds = new Set(waveOrders
.filter(item => isInterceptedOrderStatus(item && item.intercept_status))
.map(item => Number(item && item.id || 0))
.filter(id => Number.isInteger(id) && id > 0));
const unprintedOrderIds = [ ...new Set(waveOrders
.filter(item => String(item && item.print_status || '') !== 'fin'
&& !interceptedWaveOrderIds.has(Number(item && item.id || 0)))
.map(item => Number(item && item.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
if (unprintedOrderIds.length > 0) {
return this.fail('波次存在未打印订单,禁止确认打印', {
waybill_no: waybillNo,
matched_order_id: matchedOrderId,
wave_id: orderWaveId,
wave_no: orderWaveNo,
unprinted_order_count: unprintedOrderIds.length,
}, 400);
}
const pendingOrderIds = [ ...new Set(waveOrders
.filter(item => String(item && item.print_status || '') === 'fin'
&& String(item && item.confirm_print_status || '') !== 'fin'
&& !interceptedWaveOrderIds.has(Number(item && item.id || 0)))
.map(item => Number(item && item.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
const confirmedOrderIds = [ ...new Set(waveOrders
.filter(item => String(item && item.confirm_print_status || '') === 'fin'
&& !interceptedWaveOrderIds.has(Number(item && item.id || 0)))
.map(item => Number(item && item.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
const baseResponse = {
waybill_no: waybillNo,
matched_order_id: matchedOrderId,
wave_id: orderWaveId,
wave_no: orderWaveNo,
total_order_count: waveOrders.length,
intercepted_order_count: interceptedWaveOrderIds.size,
};
if (pendingOrderIds.length === 0) {
return this.success('ok', {
code: 200,
data: {
...baseResponse,
confirmed_order_count: confirmedOrderIds.length,
status: 'already_confirmed',
tip: '该波次订单均已确认打印,无需重复确认',
},
});
}
// --- 5. 事务批量确认并写订单操作日志 ---
const operationLogService = ctx.service
&& ctx.service.systems
&& ctx.service.systems.operationLog;
const operator = this.getPrintOrderOperationOperator();
const transaction = await ctx.model.transaction();
try {
const updateResult = await orderModel.update({
confirm_print_status: 'fin',
}, {
where: {
id: { [this.app.Sequelize.Op.in]: pendingOrderIds },
warehouse_id: warehouseId,
print_status: 'fin',
},
transaction,
});
const affectedRows = Number(Array.isArray(updateResult) ? updateResult[0] : updateResult) || 0;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
await operationLogService.createOperationLogs(pendingOrderIds.map(orderId => ({
businessType: 'order',
businessId: `${orderId}`,
operationCode: 'ORDER_CONFIRM_PRINT',
operator,
operationAction: 'UPDATE',
extras: {
warehouseId,
message: `确认打印(扫描面单 ${waybillNo},波次 ${orderWaveNo})`,
},
})), { transaction });
}
await transaction.commit();
// 驱动确认打印未领单波次统计长轮询:递增版本号,等待中的查询立即返回新值
try {
const waveService = ctx.service
&& ctx.service.systemMethods
&& ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.bumpConfirmPrintUnclaimedWaveVersion === 'function') {
await waveService.bumpConfirmPrintUnclaimedWaveVersion(warehouseId);
}
} catch (error) {
this.ctx.logger.warn('[print.confirmWavePrint] 统计版本号递增失败', {
warehouseId,
error: error && error.message ? error.message : `${error}`,
});
}
this.ctx.logger.info('[print.confirmWavePrint] 波次确认打印完成 warehouse_id=%d wave_id=%d affected=%d/%d',
warehouseId, orderWaveId, affectedRows, pendingOrderIds.length);
return this.success('ok', {
code: 200,
data: {
...baseResponse,
confirmed_order_count: confirmedOrderIds.length + affectedRows,
newly_confirmed_order_count: affectedRows,
status: 'confirmed',
tip: `波次确认打印完成,本次确认 ${affectedRows} 个订单`,
},
});
} catch (error) {
await transaction.rollback();
this.ctx.logger.error('[print.confirmWavePrint] 波次确认打印失败 warehouse_id=%d wave_id=%d reason=%s',
warehouseId, orderWaveId, error && error.message ? error.message : `${error}`);
return this.fail('确认打印失败', {}, 500);
}
}
/**
* 在打印发送成功后批量锁定订单。
*

View File

@ -601,7 +601,10 @@ class WorkbenchService extends Service {
}
/**
* 更新订单打包状态字段(散单按订单ID更新单笔,团购按波次批量更新)。
* 更新订单打包状态字段(散单按订单ID更新单笔,团购按波次批量更新),
* 并同步补确认打印状态:扫描打包代表面单已真实存在,确认打印状态未写入
* (confirm_print_status 为 none/null)时补为 fin(团购按波次补、散单按单补),
* 补后递增统计版本号驱动 confirmPrintUnclaimedWaveCount 长轮询。
* 遍历 current + dispatch 分表,异常仅记录日志不影响主流程。
* 团购批量更新时跳过拦截订单(intercept_status 空值按 none 处理)。
*
@ -619,6 +622,12 @@ class WorkbenchService extends Service {
// 任务状态 <2(0待处理/1打包中)或未传一律视为打包中;>=2 视为已完成
const orderPackStatus = (Number.isNaN(statusNum) || statusNum < 2) ? 'padding' : 'fin';
const orderUpdateData = { pack_status: orderPackStatus };
// 扫描打包即代表面单已真实存在:确认打印状态未写入时补上(团购按波次补、散单按单补)
const confirmUpdateData = { confirm_print_status: 'fin' };
const confirmBackfillWhere = {
confirm_print_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
};
let confirmBackfilled = false;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
@ -643,6 +652,21 @@ class WorkbenchService extends Service {
ctx.logger.info('[%s._updateOrderPackStatus] 团购批量更新订单打包状态 waveId=%d pack_status=%s table=%s affected=%d',
caller, waveId, orderPackStatus, entry.label, affected[0]);
}
// 波次补确认打印状态(仅未写入的订单)
const confirmAffected = await model.update(confirmUpdateData, {
where: {
wave_id: waveId,
warehouse_id: warehouseId,
intercept_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
...confirmBackfillWhere,
},
});
if (confirmAffected[0] > 0) {
confirmBackfilled = true;
ctx.logger.info('[%s._updateOrderPackStatus] 团购波次补确认打印状态 waveId=%d table=%s affected=%d',
caller, waveId, entry.label, confirmAffected[0]);
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
}
@ -659,6 +683,25 @@ class WorkbenchService extends Service {
if (affected[0] > 0) {
ctx.logger.info('[%s._updateOrderPackStatus] 更新订单打包状态 orderId=%d pack_status=%s table=%s',
caller, orderId, orderPackStatus, entry.label);
// 按单补确认打印状态(仅未写入时)
try {
const confirmAffected = await model.update(confirmUpdateData, {
where: {
id: orderId,
warehouse_id: warehouseId,
...confirmBackfillWhere,
},
});
if (confirmAffected[0] > 0) {
confirmBackfilled = true;
ctx.logger.info('[%s._updateOrderPackStatus] 散单补确认打印状态 orderId=%d table=%s',
caller, orderId, entry.label);
}
} catch (confirmErr) {
ctx.logger.warn('[%s._updateOrderPackStatus] 补确认打印状态失败 orderId=%d table=%s: %s',
caller, orderId, entry.label, confirmErr.message);
}
break;
}
} catch (err) {
@ -667,6 +710,21 @@ class WorkbenchService extends Service {
}
}
// 补了确认打印后递增统计版本号,驱动 confirmPrintUnclaimedWaveCount 长轮询
if (confirmBackfilled) {
try {
const waveService = ctx.service
&& ctx.service.systemMethods
&& ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.bumpConfirmPrintUnclaimedWaveVersion === 'function') {
await waveService.bumpConfirmPrintUnclaimedWaveVersion(warehouseId);
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 统计版本号递增失败: %s', caller, err.message);
}
}
return orderPackStatus;
}

View File

@ -0,0 +1,107 @@
'use strict';
/**
* 订单表增加 confirm_print_status(确认打印状态)字段。
*
* 背景:订单表已有 print_status(打印状态机,由打印回执/波次标记更新),
* 现增加确认打印状态:打印完成后,操作员真实扫描面单(运单号)进行确认,
* 确认后写入 confirm_print_status='fin',用于记录「面单已实际打印并核对」。
*
* 取值约定:
* - none = 未确认打印(默认);
* - fin = 已确认打印(扫描面单确认)。
*
* 覆盖范围:
* - 全部仓库分表 wms_order_delivery_{wh}(current)及
* _{wh}_history / _{wh}_dispatch / _{wh}_outsourced。
*
* 说明:基表 wms_order_delivery 业务不使用(订单均写入分表),本迁移
* 不对基表加列。基表上仍存在的兜底查询均带 attributes 白名单,不会
* 因模型新增字段触发 Unknown column。
*
* 幂等:列已存在则跳过。分表模型由 app/model/order_delivery_factory.js
* 运行时 drift 同步兜底,本迁移提前补齐避免运行时 ALTER。
*/
const SHARD_PATTERN = /^wms_order_delivery_(\d+)(?:_(history|dispatch|outsourced))?$/;
const COLUMN_NAME = 'confirm_print_status';
/**
* 列举库内全部订单分表。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<string[]>} 分表名列表。
*/
async function listOrderShards(queryInterface) {
const [ rows ] = await queryInterface.sequelize.query(
'SELECT TABLE_NAME AS tableName FROM INFORMATION_SCHEMA.TABLES '
+ 'WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME LIKE \'wms_order_delivery\\_%\' '
+ 'ORDER BY TABLE_NAME'
);
return (rows || [])
.map(row => String(row.tableName || row.TABLE_NAME || ''))
.filter(name => SHARD_PATTERN.test(name));
}
/**
* 判断列是否已存在。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {string} tableName 表名。
* @param {string} columnName 列名。
* @return {Promise<boolean>} 是否存在。
*/
async function columnExists(queryInterface, tableName, columnName) {
const described = await queryInterface.describeTable(tableName);
return Boolean(described && described[columnName]);
}
module.exports = {
/**
* 执行迁移:为基表与全部分表增加 confirm_print_status 列。 * @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {import('sequelize')} Sequelize Sequelize 构造器。
* @return {Promise<void>} 无返回值。
*/
async up(queryInterface, Sequelize) {
const tables = await listOrderShards(queryInterface);
const results = [];
for (const tableName of tables) {
if (await columnExists(queryInterface, tableName, COLUMN_NAME)) {
results.push({ tableName, action: 'skip', reason: 'exists' });
continue;
}
await queryInterface.addColumn(tableName, COLUMN_NAME, {
type: Sequelize.ENUM('none', 'fin'),
allowNull: true,
defaultValue: 'none',
comment: '确认打印状态机(打印完成后真实扫描面单确认)',
});
results.push({ tableName, action: 'added' });
}
console.log('[20260920100000-add-confirm-print-status-to-order-delivery] up results:', JSON.stringify(results));
},
/**
* 回滚迁移:移除基表与全部分表的 confirm_print_status 列。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
async down(queryInterface) {
const tables = await listOrderShards(queryInterface);
const results = [];
for (const tableName of tables) {
if (!await columnExists(queryInterface, tableName, COLUMN_NAME)) {
results.push({ tableName, action: 'skip', reason: 'missing' });
continue;
}
await queryInterface.removeColumn(tableName, COLUMN_NAME);
results.push({ tableName, action: 'removed' });
}
console.log('[20260920100000-add-confirm-print-status-to-order-delivery] down results:', JSON.stringify(results));
},
};