feat: 拦截链路完善与车绑定修复

- 订单表新增 intercept_time 拦截时间字段(迁移覆盖基表与全部分表),全拦截链路写入拦截时间、解除拦截清空

- 新增自动库内拦截确定定时任务(1h 间隔,扫描 requested+未打印订单,超时自动库内拦截确定)

- 复核链路自动移除波次内未打印拦截订单回池,拦截解除后可重新抓取发货

- 打印解绑车判定排除拦截订单,修复波次含拦截订单时车无法解锁

- 同步 methods 文档与变更记录;含 wave_scope 回填、workbench token 过期等前序迁移
This commit is contained in:
liufumingren 2026-09-07 03:48:43 +08:00
parent 1d65d26500
commit 6939d9600a
28 changed files with 3841 additions and 434 deletions

File diff suppressed because one or more lines are too long

View File

@ -429,7 +429,7 @@ module.exports = app => {
type: TINYINT(4),
allowNull: false,
defaultValue: 0,
comment: '波次范围:0未分配波次 1大团购 2散单 3小团购',
comment: '波次范围:0未分配波次 1大团购 2散单 3小团购 4单品单件',
},
grab_operator_id: {
type: BIGINT(20),
@ -557,6 +557,12 @@ module.exports = app => {
defaultValue: 'none',
comment: '拦截状态机',
},
intercept_time: {
type: DATE,
allowNull: true,
defaultValue: null,
comment: '拦截时间(进入拦截流程/库内拦截确认时写入)',
},
};
// 主表模型

View File

@ -52,6 +52,11 @@ module.exports = app => {
allowNull: true,
comment: '工作台令牌(随机64位,绑定后生成)',
},
token_updated_at: {
type: DATE,
allowNull: true,
comment: '工作台 token 最后更新时间(无 token 时为 NULL)',
},
created_at: {
type: DATE,
allowNull: false,

View File

@ -0,0 +1,116 @@
// app/schedule/intercept_auto_confirm.js
'use strict';
const EXECUTION_LOG_CACHE_KEY = 'schedule:intercept_auto_confirm:last_execution';
const EXECUTION_LOG_CACHE_TTL = 900; // 15 分钟
const EXECUTION_LOG_HISTORY_CACHE_KEY = 'schedule:intercept_auto_confirm:history';
const EXECUTION_LOG_HISTORY_MAX = 20; // 保留最近 20 次执行记录
const EXECUTION_LOG_HISTORY_TTL = 86400; // 1 天
/**
* 将本次执行日志写入缓存。
*
* @param {Object} ctx Egg 上下文。
* @param {Object} logEntry 日志条目。
* @return {Promise<void>} 无返回值。
*/
async function writeExecutionLogToCache(ctx, logEntry) {
try {
if (ctx.app && typeof ctx.app.setCacheAsync === 'function') {
await ctx.app.setCacheAsync(EXECUTION_LOG_CACHE_KEY, logEntry, EXECUTION_LOG_CACHE_TTL);
}
} catch (err) {
ctx.logger.warn(`[intercept-auto-confirm] 写入执行日志缓存失败: ${err.message}`);
}
}
/**
* 将本次执行日志追加到历史记录缓存(保留最近 N 次)。
*
* @param {Object} ctx Egg 上下文。
* @param {Object} logEntry 日志条目。
* @return {Promise<void>} 无返回值。
*/
async function appendExecutionHistory(ctx, logEntry) {
try {
if (typeof ctx.app.getCacheAsync !== 'function' || typeof ctx.app.setCacheAsync !== 'function') {
return;
}
const rawHistory = await ctx.app.getCacheAsync(EXECUTION_LOG_HISTORY_CACHE_KEY);
const history = Array.isArray(rawHistory) ? rawHistory : [];
history.unshift(logEntry);
await ctx.app.setCacheAsync(
EXECUTION_LOG_HISTORY_CACHE_KEY,
history.slice(0, EXECUTION_LOG_HISTORY_MAX),
EXECUTION_LOG_HISTORY_TTL
);
} catch (err) {
ctx.logger.warn(`[intercept-auto-confirm] 写入执行历史缓存失败: ${err.message}`);
}
}
/**
* 每 1 小时在单 worker 中执行一次自动库内拦截确定。
*
* 扫描待处理表(current 分表)中「拦截状态为请求拦截(intercept_status='requested')
* 且面单未打印(print_status='none')」的订单,满足拦截时间超 12 小时或
* 创建时间超 36 小时任一条件时,自动执行库内拦截确定。
*/
module.exports = {
schedule: {
interval: '1h',
type: 'worker',
immediate: false,
disable: false,
},
/**
* 执行自动库内拦截确定任务。
*
* @param {Object} ctx Egg 上下文。
* @return {Promise<void>} 无返回值。
*/
async task(ctx) {
if (ctx.app._interceptAutoConfirmRunning) {
return;
}
ctx.app._interceptAutoConfirmRunning = true;
const startedAt = Date.now();
let status = 'success';
let errorMessage = '';
let result = null;
try {
result = await ctx.service.systems.interceptAutoConfirm.runAutoConfirm();
} catch (error) {
status = 'error';
errorMessage = error.message;
ctx.logger.error(`[intercept-auto-confirm] 执行失败: ${error.message}`);
} finally {
ctx.app._interceptAutoConfirmRunning = false;
}
const logEntry = {
executed_at: new Date().toISOString(),
duration_ms: Date.now() - startedAt,
status,
error_message: errorMessage,
warehouse_count: result ? result.warehouse_count : 0,
candidate_count: result ? result.candidate_count : 0,
confirmed_count: result ? result.confirmed_count : 0,
failed_count: result ? result.failed_count : 0,
warehouse_ids: result ? result.warehouse_ids : [],
};
await writeExecutionLogToCache(ctx, logEntry);
await appendExecutionHistory(ctx, logEntry);
ctx.logger.info(
`[intercept-auto-confirm] 本轮完成 warehouses=${logEntry.warehouse_count}`
+ ` candidate=${logEntry.candidate_count} confirmed=${logEntry.confirmed_count}`
+ ` failed=${logEntry.failed_count} duration=${logEntry.duration_ms}ms`
);
},
};

View File

@ -0,0 +1,69 @@
'use strict';
/** @type {number} 扫描间隔兜底默认值(毫秒):1 小时,配置缺失时使用 */
const DEFAULT_SCAN_INTERVAL_MS = 60 * 60 * 1000;
/** @type {number} token 有效期兜底默认值(毫秒):3 个月(按 30 天/月折算),配置缺失时使用 */
const DEFAULT_MAX_AGE_MS = 3 * 30 * 24 * 60 * 60 * 1000;
/** @type {number} 批处理兜底默认值(条) */
const DEFAULT_BATCH_SIZE = 50;
/**
* 工作台 token 超期强制下线定时任务。
* 由 config.workbenchTokenExpire 控制:
* - enable=false 时不注册本任务;
* - scanIntervalMs 控制扫描间隔(毫秒),开发环境可覆盖为短循环便于测试;
* - maxAgeMs 控制 token 有效期阈值,token_updated_at 距今超过该时长即强制下线;
* - batchSize 控制单批处理条数。
* 实际清理逻辑收敛在 service.systems.workbench.clearExpiredWorkbenchTokens。
* @param {Object} app Egg 应用实例
* @return {Object} 定时任务定义(含 schedule 与 task)
*/
module.exports = app => {
const workbenchTokenExpire = (app.config && app.config.workbenchTokenExpire) || {};
const scanIntervalMs = Number(workbenchTokenExpire.scanIntervalMs) > 0
? Number(workbenchTokenExpire.scanIntervalMs)
: DEFAULT_SCAN_INTERVAL_MS;
return {
schedule: {
interval: scanIntervalMs,
type: 'worker',
immediate: false,
disable: workbenchTokenExpire.enable === false,
},
/**
* 扫描并清理 token 超期未更新的工作台,使其强制下线。
* 采用单 worker 防重入:上一轮未结束时跳过本轮。
* @param {Object} ctx Egg 上下文
* @return {Promise<void>} 无返回值
*/
async task(ctx) {
const scheduleName = 'workbench_token_expire';
const config = ctx.app.config.workbenchTokenExpire || {};
if (ctx.app._workbenchTokenExpireRunning) {
ctx.logger.info(`[${scheduleName}] 本轮任务跳过,上一轮尚未结束`);
return;
}
ctx.app._workbenchTokenExpireRunning = true;
try {
const maxAgeMs = Number(config.maxAgeMs) > 0 ? Number(config.maxAgeMs) : DEFAULT_MAX_AGE_MS;
const batchSize = Number(config.batchSize) > 0 ? Math.floor(Number(config.batchSize)) : DEFAULT_BATCH_SIZE;
const expiredBefore = new Date(Date.now() - maxAgeMs);
const summary = await ctx.service.systems.workbench.clearExpiredWorkbenchTokens({
expiredBefore,
batchSize,
});
ctx.logger.info(`[${scheduleName}] 本轮扫描完成:maxAgeMs=${maxAgeMs} expiredBefore=${expiredBefore.toISOString()} scanned=${summary.total_scanned} cleared=${summary.total_cleared} failed=${summary.total_failed}`);
} catch (error) {
ctx.logger.error(`[${scheduleName}] 执行失败: ${error.message}`);
} finally {
ctx.app._workbenchTokenExpireRunning = false;
}
},
};
};

View File

@ -834,6 +834,12 @@ class InboxFunctionsService extends Service {
reason: { type: 'string', required: false, description: '拦截原因' },
},
groups: [ GROUP.BOUND_WAREHOUSE_CUSTOMER_SERVICE, GROUP.BOUND_STORE_AFTER_SALES ],
/**
* 拦截运单处理器:批量创建售后工单,并按波次规则写入订单拦截状态
* intercept_status='requested' 与拦截时间 intercept_time。
* @param {Object} params 入参,包含 keyword(运单号)与 reason(拦截原因)。
* @return {Promise<Object>} 处理结果,包含 success 与 data/error。
*/
handler: async (params = {}) => {
const { ctx } = this;
const raw = String(params.keyword || '').trim();
@ -1060,10 +1066,10 @@ class InboxFunctionsService extends Service {
}
}
// 执行拦截状态设置(订单表 + 运单表)
// 执行拦截状态设置(订单表 + 运单表,同步写入拦截时间)
if (interceptOrderIds.length > 0) {
await orderModel.update(
{ intercept_status: 'requested' },
{ intercept_status: 'requested', intercept_time: new Date() },
{ where: { id: { [ctx.app.Sequelize.Op.in]: interceptOrderIds } } }
);
// 同步更新运单表拦截标记
@ -1635,6 +1641,12 @@ class InboxFunctionsService extends Service {
reason: { type: 'string', required: false, description: '取消拦截原因' },
},
groups: [ GROUP.BOUND_WAREHOUSE_CUSTOMER_SERVICE, GROUP.BOUND_STORE_AFTER_SALES ],
/**
* 取消拦截处理器:为运单创建/追加取消拦截工单,并按波次规则重新写入
* 订单拦截状态 intercept_status='requested' 与拦截时间 intercept_time。
* @param {Object} params 入参,包含 keyword(运单号)与 reason(取消拦截原因)。
* @return {Promise<Object>} 处理结果,包含 success 与 data/error。
*/
handler: async (params = {}) => {
const { ctx } = this;
const raw = String(params.keyword || '').trim();
@ -1821,7 +1833,7 @@ class InboxFunctionsService extends Service {
}
if (interceptOrderIds.length > 0) {
await orderModel.update(
{ intercept_status: 'requested' },
{ intercept_status: 'requested', intercept_time: new Date() },
{ where: { id: { [ctx.app.Sequelize.Op.in]: interceptOrderIds } } }
);
await ctx.model.OrderExpress.update(

View File

@ -9,6 +9,7 @@ class OpenapiOrderService extends MainService {
* 取消发货单。
* 上下文(storeId/warehouseId/appKey)已由 dispatchOpenapiMethod 统一注入。
* 当前仅支持出库单类型(JYCK/HHCK/BFCK → ORDER),非出库单类型返回不支持。
* 触发拦截时同步写入订单拦截时间 intercept_time(当前时间)。
* @param {Object} payload 调用参数。
* @param {Object} payload.body 请求体数据,包含 orderCode、orderType。
* @param {Object} payload.query 请求 query 数据。
@ -72,6 +73,7 @@ class OpenapiOrderService extends MainService {
if (!blockReason) {
await existingOrder.update({
intercept_status: 'intercepting',
intercept_time: new Date(),
updated_at: new Date(),
}, {
transaction,

View File

@ -155,6 +155,14 @@ class orderServer extends MainService {
}
}
/**
* 取消奇门订单。
* 订单未同步且未开始拣货/打印时直接取消;已同步或已开始拣货/打印时转入拦截处理:
* 写入订单拦截状态 intercept_status(intercepting/requested)并同步写入拦截时间 intercept_time。
* @param {Object} data 奇门请求数据。
* @param {Object} data.request 请求体,包含 orderCode、orderType 等字段。
* @return {Promise<Object>} 取消结果,成功时返回成功消息,失败时返回错误信息。
*/
async cancel(data) {
const { ctx } = this;
const info = this.getInfo();
@ -230,6 +238,7 @@ class orderServer extends MainService {
if (!blockReason) {
await existingOrder.update({
intercept_status: 'intercepting',
intercept_time: new Date(),
updated_at: new Date(),
}, {
transaction,
@ -323,6 +332,7 @@ class orderServer extends MainService {
if (!syncBlockReason) {
await existingOrder.update({
intercept_status: 'requested',
intercept_time: new Date(),
updated_at: new Date(),
}, {
transaction,

View File

@ -1052,10 +1052,10 @@ class indexService extends MainService {
*/
constructor(ctx) {
super(ctx);
const _noNeedLogin = 'getI18nMessage,putI18nCollect,test,getCainiaoStfTemplates,polyapiAuthorizeUrl,getWorkbenchBindCode,LoginWorkbenchByCode';
const _noNeedRight = 'loginToIm,getI18nMessage,putI18nCollect,fastWhereTree,loadStores,loadWarehouses,loadExpressInterfaces,getImages,getCOSUploadConfig,uploadSuccessNotify,getMessageDetail,searchSpace,searchSpaces,listInterfaceTypes,getLocationTypeList,getQimenAppList,getExpressList,getExpressProductTypeList,getPlatformList,getPrintPlatformList,getPlatformOauthLink,listenPlatformOauthBind,recognizeLicensePlate,getCainiaoStfTemplates,getPrintPlatformTemplateList,polyapiAuthorizeUrl,toOrder,getWorkbenchBindCode,LoginWorkbenchByCode';
const _noNeedLogin = 'getI18nMessage,putI18nCollect,test,getCainiaoStfTemplates,polyapiAuthorizeUrl,getWorkbenchBindCode,LoginWorkbenchByCode,queryUserByToken';
const _noNeedRight = 'loginToIm,getI18nMessage,putI18nCollect,fastWhereTree,loadStores,loadWarehouses,loadExpressInterfaces,getImages,getCOSUploadConfig,uploadSuccessNotify,getMessageDetail,searchSpace,searchSpaces,listInterfaceTypes,getLocationTypeList,getQimenAppList,getExpressList,getExpressProductTypeList,getPlatformList,getPrintPlatformList,getPlatformOauthLink,listenPlatformOauthBind,recognizeLicensePlate,getCainiaoStfTemplates,getPrintPlatformTemplateList,polyapiAuthorizeUrl,toOrder,getWorkbenchBindCode,LoginWorkbenchByCode,queryUserByToken';
const _noNeedLog = '*';
const _noNeedAuth = 'loginToIm,getI18nMessage,putI18nCollect,fastWhereTree,loadStores,loadWarehouses,loadExpressInterfaces,getImages,getMessageDetail,searchSpace,searchSpaces,listInterfaceTypes,getLocationTypeList,getQimenAppList,getExpressList,getExpressProductTypeList,getPlatformList,getPrintPlatformList,getPlatformOauthLink,listenPlatformOauthBind,recognizeLicensePlate,test,getCainiaoStfTemplates,getPrintPlatformTemplateList,polyapiAuthorizeUrl,toOrder,getWorkbenchBindCode,LoginWorkbenchByCode';
const _noNeedAuth = 'loginToIm,getI18nMessage,putI18nCollect,fastWhereTree,loadStores,loadWarehouses,loadExpressInterfaces,getImages,getMessageDetail,searchSpace,searchSpaces,listInterfaceTypes,getLocationTypeList,getQimenAppList,getExpressList,getExpressProductTypeList,getPlatformList,getPrintPlatformList,getPlatformOauthLink,listenPlatformOauthBind,recognizeLicensePlate,test,getCainiaoStfTemplates,getPrintPlatformTemplateList,polyapiAuthorizeUrl,toOrder,getWorkbenchBindCode,LoginWorkbenchByCode,queryUserByToken';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
async fastWhereTree(data) {
@ -3397,5 +3397,46 @@ class indexService extends MainService {
return this.fail(error.message);
}
}
/**
* 根据 token(ye4s 登录临时码 tmp_code)查询用户信息。
*
* @param {Object} data 请求参数
* @param {string} data.token ye4s 登录临时码(对应 ye4s_user.tmp_code)
* @return {Promise<Object>} 统一响应结构;命中时返回 real_name 与 wms_account_id,未命中时返回失败响应(code=404)
*/
async queryUserByToken(data = {}) {
const { ctx } = this;
const { token } = data || {};
if (!token || !String(token).trim()) {
return this.fail('token 不能为空', { code: 400 });
}
try {
const ye4sClient = ctx.app.mysql.get('ye4s');
const rows = await ye4sClient.select('ye4s_user', {
where: {
tmp_code: String(token).trim(),
},
columns: [ 'real_name', 'wms_account_id' ],
limit: 1,
});
if (!rows || rows.length === 0) {
return this.fail('用户不存在', { code: 404 });
}
const userRecord = rows[0];
return this.success('查询成功', {
real_name: userRecord.real_name ?? '',
wms_account_id: userRecord.wms_account_id ?? null,
code: 200,
});
} catch (error) {
ctx.logger.error('查询用户失败:', error);
return this.fail(error.message || '查询用户失败', { code: 500 });
}
}
}
module.exports = indexService;

View File

@ -1131,7 +1131,7 @@ class OrderBaseService extends MainService {
/**
* 提取 wave_scope(波次范围)虚拟筛选条件。
* 将其从 where 中移除并解析为波次范围值集合,后续直接生成订单表 wave_scope 字段过滤。
* 取值约定:0=未分配波次,1=大团购,2=散单,3=小团购;value 支持单个值或数组(多选)。
* 取值约定:0=未分配波次,1=大团购,2=散单,3=小团购,4=单品单件;value 支持单个值或数组(多选)。
* @param {Object} whereInput 标准化后的 where 条件。
* @return {{ where: Object, waveScope: number[]|null }} 清洗后的 where 与波次范围值集合。
*/
@ -1163,8 +1163,8 @@ class OrderBaseService extends MainService {
));
for (const scope of normalizedScopes) {
if (!Number.isInteger(scope) || scope < 0 || scope > 3) {
throw new Error('wave_scope 参数不合法,仅支持 0(未分配波次)/1(大团购)/2(散单)/3(小团购)');
if (!Number.isInteger(scope) || scope < 0 || scope > 4) {
throw new Error('wave_scope 参数不合法,仅支持 0(未分配波次)/1(大团购)/2(散单)/3(小团购)/4(单品单件)');
}
}
@ -1243,7 +1243,7 @@ class OrderBaseService extends MainService {
* 根据波次范围(wave_scope)构建订单表 wave_scope 字段过滤条件。
* 订单表已冗余 wave_scope 字段(写入波次时维护),直接按字段过滤,
* 无需再反查 wms_wave_batch。
* @param {Array<number>} waveScopes 波次范围值集合(0/1/2/3)。
* @param {Array<number>} waveScopes 波次范围值集合(0/1/2/3/4)。
* @return {Object|null} Sequelize 条件,无有效范围时返回 null。
*/
buildWaveScopeFilterCondition(waveScopes = []) {
@ -1252,7 +1252,7 @@ class OrderBaseService extends MainService {
(Array.isArray(waveScopes) ? waveScopes : [ waveScopes ])
.filter(scope => scope !== undefined && scope !== null && scope !== '')
.map(scope => Number(scope))
)).filter(scope => Number.isInteger(scope) && scope >= 0 && scope <= 3);
)).filter(scope => Number.isInteger(scope) && scope >= 0 && scope <= 4);
if (normalizedScopes.length === 0) {
return null;

View File

@ -2405,6 +2405,7 @@ class PendingOrderService extends OrderBaseService {
/**
* 将待处理订单取消,并关闭到已取消状态。
* 仅允许取消当前仓库内处于待审核、待处理、待处理异常语义的订单。
* 已同步订单取消时转为拦截处理:写入 intercept_status='requested' 并同步写入拦截时间 intercept_time。
*
* 取消、波次清理、储位释放与创建锁释放在同一事务内完成:
* 任一环节失败整体回滚,避免"已取消但库存锁定未释放"的中间态。
@ -2492,6 +2493,7 @@ class PendingOrderService extends OrderBaseService {
await model.update(
{
intercept_status: 'requested',
intercept_time: syncNow,
updated_at: syncNow,
},
{
@ -2873,6 +2875,8 @@ class PendingOrderService extends OrderBaseService {
* 用 code 查找 wms_platform 表中对应的平台记录,若存在则将订单的
* sys_platform_code 和 sys_platform_name 更新为该平台的 code 和 name;
* 若不存在则返回错误。只操作当前仓库的当前订单表,不处理其他订单表。
* 正在分配快递(wms_order_express 存在 status=0 的取号中占位记录)的订单跳过处理,
* 不影响其余订单,跳过明细通过 skipped_order_ids 透出。
*
* @param {Object} data 请求体。
* @param {number[]} data.order_ids 订单ID 数组。
@ -2912,14 +2916,46 @@ class PendingOrderService extends OrderBaseService {
throw new Error(`平台编码 ${code} 不存在`);
}
// 正在分配快递的订单(order_express 存在 status=0 占位记录)跳过处理,不影响其余订单
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
const allocatingIdSet = new Set();
if (orderExpressModel && typeof orderExpressModel.findAll === 'function') {
const allocatingRows = await orderExpressModel.findAll({
attributes: [ 'order_id' ],
where: {
order_id: orderIds,
warehouse_id: warehouseId,
status: 0,
},
raw: true,
});
for (const row of Array.isArray(allocatingRows) ? allocatingRows : []) {
const orderId = Number(row && row.order_id);
if (Number.isFinite(orderId) && orderId > 0) {
allocatingIdSet.add(orderId);
}
}
}
const skippedOrderIds = orderIds.filter(orderId => allocatingIdSet.has(orderId));
const updatableOrderIds = orderIds.filter(orderId => !allocatingIdSet.has(orderId));
const model = await this.getOrderModel('order', warehouseId);
const where = {
...this.buildOrderWhere(orderIds, warehouseId),
...this.buildOrderWhere(updatableOrderIds, warehouseId),
post_status: 'none',
};
const platformName = String(platform.name || '').trim();
if (updatableOrderIds.length === 0) {
return this.success('ok', {
updated_count: 0,
skipped_order_ids: skippedOrderIds,
sys_platform_code: platform.code,
sys_platform_name: platformName,
});
}
// 更新前查询候选订单,筛出平台实际发生变化的订单,用于逐单写入订单日志
const candidateOrders = await model.findAll({
where,
@ -2952,7 +2988,7 @@ class PendingOrderService extends OrderBaseService {
sys_platform_code: platform.code,
sys_platform_name: platformName,
updated_count: count,
message: `批量修改订单平台:订单ID [${orderIds.join(', ')}],平台 ${platform.code}(${platformName}),共更新 ${count} 条`,
message: `批量修改订单平台:订单ID [${orderIds.join(', ')}],平台 ${platform.code}(${platformName}),共更新 ${count} 条${skippedOrderIds.length > 0 ? `,跳过取号中 ${skippedOrderIds.length} 条` : ''}`,
},
beforeChanges: null,
});
@ -2995,6 +3031,7 @@ class PendingOrderService extends OrderBaseService {
return this.success('ok', {
updated_count: count,
skipped_order_ids: skippedOrderIds,
sys_platform_code: platform.code,
sys_platform_name: String(platform.name || '').trim(),
});
@ -3010,6 +3047,10 @@ class PendingOrderService extends OrderBaseService {
* logistics_code/logistics_name 均写系统快递的 code/name;
* - 未找到则报错。
* 只操作当前仓库的当前订单表,不处理其他订单表。
* 操作日志逐单写入(business_id 为订单 ID),确保订单详情页可查询;
* 未满足更新条件(post_status 不为 none)的订单写入"未生效"日志。
* 正在分配快递(wms_order_express 存在 status=0 的取号中占位记录)的订单跳过处理,
* 不影响其余订单,跳过明细通过 skipped_order_ids 透出。
*
* @param {Object} data 请求体。
* @param {number[]} data.order_ids 订单ID 数组。
@ -3071,12 +3112,58 @@ class PendingOrderService extends OrderBaseService {
logisticsName = sysLogisticsName;
}
// 正在分配快递的订单(order_express 存在 status=0 占位记录)跳过处理,不影响其余订单
const orderExpressModel = this.ctx.model && this.ctx.model.OrderExpress;
const allocatingIdSet = new Set();
if (orderExpressModel && typeof orderExpressModel.findAll === 'function') {
const allocatingRows = await orderExpressModel.findAll({
attributes: [ 'order_id' ],
where: {
order_id: orderIds,
warehouse_id: warehouseId,
status: 0,
},
raw: true,
});
for (const row of Array.isArray(allocatingRows) ? allocatingRows : []) {
const orderId = Number(row && row.order_id);
if (Number.isFinite(orderId) && orderId > 0) {
allocatingIdSet.add(orderId);
}
}
}
const skippedOrderIds = orderIds.filter(orderId => allocatingIdSet.has(orderId));
const updatableOrderIds = orderIds.filter(orderId => !allocatingIdSet.has(orderId));
const model = await this.getOrderModel('order', warehouseId);
const where = {
...this.buildOrderWhere(orderIds, warehouseId),
...this.buildOrderWhere(updatableOrderIds, warehouseId),
post_status: 'none',
};
if (updatableOrderIds.length === 0) {
return this.success('ok', {
updated_count: 0,
skipped_order_ids: skippedOrderIds,
sys_logistics_code: sysLogisticsCode,
sys_logistics_name: sysLogisticsName,
logistics_code: logisticsCode,
logistics_name: logisticsName,
});
}
// 更新前先确定实际可修改的订单集合,用于逐单写订单维度日志
const updatableRows = await model.findAll({
attributes: [ 'id' ],
where,
raw: true,
});
const updatableIdSet = new Set(
(Array.isArray(updatableRows) ? updatableRows : [])
.map(row => Number(row && row.id))
.filter(v => Number.isFinite(v) && v > 0)
);
const [ affectedRows ] = await model.update({
sys_logistics_code: sysLogisticsCode,
sys_logistics_name: sysLogisticsName,
@ -3087,32 +3174,44 @@ class PendingOrderService extends OrderBaseService {
const count = Number(affectedRows || 0);
// 记录操作日志
try {
await this.ctx.service.systems.operationLog.createOperationLog({
// 记录操作日志:逐单写入(business_id 为订单 ID),订单详情页可查询
const logPayloads = updatableOrderIds.map(orderId => {
const isUpdated = updatableIdSet.has(orderId);
return {
businessType: 'order',
businessId: logWarehouseId,
businessId: String(orderId),
operationCode: 'ORDER_UPDATE_EXPRESS',
operator,
extras: {
warehouseId: logWarehouseId,
orderIds,
orderIds: [ orderId ],
express_code: expressCode,
sys_logistics_code: sysLogisticsCode,
sys_logistics_name: sysLogisticsName,
logistics_code: logisticsCode,
logistics_name: logisticsName,
updated_count: count,
message: `批量修改订单快递:订单ID [${orderIds.join(', ')}],快递 ${logisticsCode}(${logisticsName}),系统快递 ${sysLogisticsCode}(${sysLogisticsName}),共更新 ${count} 条`,
updated_count: isUpdated ? 1 : 0,
message: isUpdated
? `修改订单快递:快递 ${logisticsCode}(${logisticsName}),系统快递 ${sysLogisticsCode}(${sysLogisticsName})`
: `修改订单快递未生效(订单已分配快递或状态不允许):快递 ${logisticsCode}(${logisticsName})`,
},
beforeChanges: null,
});
};
});
try {
if (logPayloads.length === 1) {
await this.ctx.service.systems.operationLog.createOperationLog(logPayloads[0]);
} else {
await this.ctx.service.systems.operationLog.createOperationLogs(logPayloads);
}
} catch (logErr) {
this.ctx.logger.warn('[PendingOrderService.updateOrderExpress] 写入操作日志失败,不影响业务', logErr);
}
return this.success('ok', {
updated_count: count,
skipped_order_ids: skippedOrderIds,
sys_logistics_code: sysLogisticsCode,
sys_logistics_name: sysLogisticsName,
logistics_code: logisticsCode,
@ -3443,7 +3542,7 @@ class PendingOrderService extends OrderBaseService {
'delivery_type', 'weight_type', 'is_urgency', 'invoice_flag',
'name', 'zip_code', 'tel', 'mobile', 'email',
'country_code', 'province', 'city', 'area', 'town', 'detail_address',
'id_type', 'id_number', 'oaid',
'id_type', 'id_number', 'oaid', 'extend_props',
'items', 'items_count', 'items_total', 'items_weight', 'items_hash', 'items_crc',
];
@ -4517,8 +4616,8 @@ ${numbered}`;
/**
* 执行批量拦截后台任务。
*
* 直接对给定订单ID数组,将 intercept_status 更新为 'requested',并写入操作日志。
* 仅处理当前仓库上下文内的订单。
* 直接对给定订单ID数组,将 intercept_status 更新为 'requested' 并同步写入拦截时间 intercept_time,
* 同时写入操作日志。仅处理当前仓库上下文内的订单。
*
* @param {Object} params 任务参数。
* @param {string} params.taskId 任务ID。
@ -4688,6 +4787,7 @@ ${numbered}`;
const now = new Date();
const updateValues = {
intercept_status: 'requested',
intercept_time: now,
updated_at: now,
};
@ -6103,7 +6203,8 @@ ${numbered}`;
/**
* 执行批量解除拦截后台任务。
*
* 直接对给定订单ID数组,将 intercept_status 更新为 'none',并写入操作日志 ORDER_INTERCEPT_CANCEL。
* 直接对给定订单ID数组,将 intercept_status 更新为 'none' 并同步清空拦截时间 intercept_time(置为 null),
* 同时写入操作日志 ORDER_INTERCEPT_CANCEL。
* 同时释放订单对应的拦截锁定库存(intercept_locked_quantity 回落到可用数量,失败不阻断主流程)。
* 仅处理当前仓库上下文内的订单。
*
@ -6249,6 +6350,7 @@ ${numbered}`;
const now = new Date();
const updateValues = {
intercept_status: 'none',
intercept_time: null,
updated_at: now,
};

View File

@ -2,14 +2,6 @@
const OrderBaseService = require('./base');
/**
* 允许确认拦截(更新为 intercepted_at_warehouse)的前置拦截状态:
* 拦截发起中(requested/requesting/intercepting)与历史遗留值 intercepted。
* 其余状态(none/空、intercepted_at_warehouse、intercepted_in_transit、returning、returned、
* delivered_by_mistake、timeout、cancelled、failed、exception)一律不允许确认拦截。
*/
const CONFIRMABLE_INTERCEPT_STATUSES = [ 'requested', 'requesting', 'intercepting', 'intercepted' ];
class RecheckOrderService extends OrderBaseService {
/**
* 初始化复核订单系统方法免登录、免权限、免日志与免鉴权配置。
@ -2150,6 +2142,7 @@ class RecheckOrderService extends OrderBaseService {
/**
* 更新波次拣货任务订单的复核状态,若任务下所有订单均已复核完成则自动解绑车任务。
* 复核状态更新后,会先清理波次内「已拦截且未打印」的订单(回池),避免其卡住任务完成判定。
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
@ -2194,6 +2187,26 @@ class RecheckOrderService extends OrderBaseService {
}
);
// 复核时同步清理波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务/波次完成判定
try {
const currentOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const currentOrder = await currentOrderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
});
const currentWaveId = Number(currentOrder && currentOrder.wave_id || 0);
if (currentWaveId > 0) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: currentWaveId,
warehouseId,
operator,
});
}
} catch (removeErr) {
ctx.logger.warn(`[confirmRecheck] 清理波次未打印拦截订单失败,不影响复核主流程, orderId=${orderId}, error=${removeErr.message}`);
}
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
@ -2398,6 +2411,8 @@ class RecheckOrderService extends OrderBaseService {
* 批量更新波次拣货任务订单的复核状态,并按任务维度检查是否需要解绑车任务。
* 与单订单版本不同,本方法一次性更新所有相关任务订单的 review_status,
* 再按去重后的 task_id 逐任务判断是否所有订单均已复核完成。
* 复核状态更新后,会先清理受影响波次内「已拦截且未打印」的订单(回池),
* 避免其卡住任务完成判定。
* @param {number[]} orderIds 订单ID列表。
* @param {number} warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} operator 操作人信息。
@ -2441,6 +2456,31 @@ class RecheckOrderService extends OrderBaseService {
}
);
// 复核时同步清理受影响波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务完成判定
try {
const cleanupOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const cleanupWaveRows = await cleanupOrderModel.findAll({
where: {
id: { [this.app.Sequelize.Op.in]: orderIds },
warehouse_id: warehouseId,
},
attributes: [ 'wave_id' ],
raw: true,
});
const cleanupWaveIds = [ ...new Set((Array.isArray(cleanupWaveRows) ? cleanupWaveRows : [])
.map(r => Number(r && r.wave_id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
for (const cleanupWaveId of cleanupWaveIds) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: cleanupWaveId,
warehouseId,
operator,
});
}
} catch (removeErr) {
ctx.logger.warn(`[confirmRecheck] 批量复核-清理波次未打印拦截订单失败,不影响主流程, error=${removeErr.message}`);
}
// 查询受影响的去重 task_id
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id
@ -3750,13 +3790,18 @@ class RecheckOrderService extends OrderBaseService {
* 仅拦截当前指定订单(不波及波次内其他订单),支持部分失败:未找到的订单与处理失败的
* 订单记录在 failed 列表并返回失败原因,其余订单继续处理。
*
* 本方法为 method 出口包装层:解析仓库上下文与订单ID后,复用 systems 层
* interceptAutoConfirm.confirmInterceptForOrderIds 完成实际拦截确认动作,
* 与定时任务「自动库内拦截确定」共用同一内部实现,保证两条链路行为一致。
*
* 前置条件:订单必须处于拦截发起中状态(requested/requesting/intercepting,历史值 intercepted 兼容)。
* 未发起拦截(none/空)的订单直接静默跳过不参与处理;已确认拦截(intercepted_at_warehouse)及其它
* 非可确认状态(intercepted_in_transit/returning/returned/delivered_by_mistake/timeout/cancelled/failed/
* exception)的订单一律跳过并记录失败原因;更新 SQL 的 where 同时限定拦截状态,防止并发修改导致误更新。
*
* 每个订单的拦截处理:
* 1. 更新 wms_order_delivery:intercept_status = intercepted_at_warehouse、step=4、outbound_status=fin
* 1. 更新 wms_order_delivery:intercept_status = intercepted_at_warehouse、step=4、outbound_status=fin,
* 并同步写入拦截时间 intercept_time(当前时间)
* 2. 同步更新运单表:is_intercept='Y'、is_back='Y'(库内拦截确认,货物在库内需退回)
* 3. 释放储位分配(cancelAllocateStorage 拦截模式:库存不归还可用,移入拦截锁定字段 intercept_locked_quantity)
* 4. 释放订单锁(lock_status='none')
@ -3769,7 +3814,6 @@ class RecheckOrderService extends OrderBaseService {
* @return {Promise<Object>} 批量拦截结果,包含 success/failed 列表与 success_count/failed_count 计数。
*/
async confirmIntercept(data = {}) {
const { ctx } = this;
const warehouseId = this.getWarehouseId();
const orderIds = this.normalizeOrderIds(data);
@ -3777,183 +3821,13 @@ class RecheckOrderService extends OrderBaseService {
this.ctx.throw(400, '订单ID列表不能为空');
}
const orderModel = await this.getOrderModelByTableType('current', warehouseId);
const orderRows = await orderModel.findAll({
where: this.buildOrderWhere(orderIds, warehouseId),
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'intercept_status', 'wave_no' ],
raw: true,
// method 出口仅做入参解构与包装,拦截确认动作统一由 systems 层内部方法执行
const operator = this.getOrderLogOperator();
return await this.ctx.service.systems.interceptAutoConfirm.confirmInterceptForOrderIds({
orderIds,
warehouseId,
operator,
});
const orderMap = new Map();
for (const row of orderRows) {
orderMap.set(Number(row.id), row);
}
const successOrders = [];
const failedOrders = [];
const successOrderIds = [];
for (const orderId of orderIds) {
const order = orderMap.get(orderId);
if (!order) {
failedOrders.push({ order_id: orderId, reason: '未找到对应订单' });
continue;
}
const orderWhere = this.buildOrderWhere([ orderId ], warehouseId);
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const interceptStatus = String(order.intercept_status || '').trim();
// 未发起拦截(none/空)的订单直接跳过,不参与确认拦截处理
if (interceptStatus === '' || interceptStatus === 'none') {
continue;
}
// 已确认拦截的订单跳过,避免重复执行副作用(释放储位/工单/日志等)
if (interceptStatus === 'intercepted_at_warehouse') {
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: '订单已确认拦截',
});
continue;
}
// 仅拦截发起中(requested/requesting/intercepting)与历史值 intercepted 允许确认,
// 其余状态(intercepted_in_transit/returning/returned/delivered_by_mistake/timeout/
// cancelled/failed/exception)不允许确认拦截
if (!CONFIRMABLE_INTERCEPT_STATUSES.includes(interceptStatus)) {
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: `订单拦截状态不允许确认拦截: ${interceptStatus}`,
});
continue;
}
try {
const now = new Date();
const updateValues = {
intercept_status: 'intercepted_at_warehouse',
step: 4,
outbound_status: 'fin',
updated_at: now,
};
const updateResult = await orderModel.update(updateValues, {
where: {
...orderWhere,
// 数据库层再次限定拦截状态,防止查询后状态被并发修改导致误更新
intercept_status: { [ctx.app.Sequelize.Op.in]: CONFIRMABLE_INTERCEPT_STATUSES },
},
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
if (affectedRows <= 0) {
throw new Error('拦截状态更新失败,请稍后重试');
}
// 同步更新运单表:标记拦截 + 退回(库内拦截确认,货物在库内需退回)
try {
await ctx.model.OrderExpress.update(
{ is_intercept: 'Y', is_back: 'Y' },
{ where: { order_id: orderId, warehouse_id: warehouseId } }
);
} catch (expressErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 更新运单拦截/退回标记失败, orderId=${orderId}, error=${expressErr.message}`
);
}
// 拦截成功后释放储位分配(拦截模式:库存移入拦截锁定,不归还可用)
try {
await this.service.systems.orderStorageAllocation.cancelAllocateStorage({
order_ids: [ orderId ],
interceptMode: true,
});
} catch (allocErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 释放储位分配失败,不影响拦截, orderId=${orderId}, error=${allocErr.message}`
);
}
// 拦截成功后释放订单锁
try {
await orderModel.update(
{ lock_status: 'none', updated_at: now },
{ where: orderWhere }
);
} catch (lockErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 释放锁失败,不影响拦截, orderId=${orderId}, error=${lockErr.message}`
);
}
// 写入操作日志(失败不影响主流程)
try {
const operator = this.getOrderLogOperator();
const logWarehouseId = this.getOrderLogWarehouseId(warehouseId);
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: orderId,
operationCode: 'ORDER_INTERCEPT_CONFIRM',
operator,
extras: {
warehouseId: logWarehouseId,
orderId,
orderNo,
previousInterceptStatus: String(order.intercept_status || '').trim(),
newInterceptStatus: 'intercepted_at_warehouse',
},
beforeChanges: null,
});
} catch (logErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${logErr.message}`
);
}
successOrders.push({
order_id: orderId,
order_no: orderNo,
intercept_status: 'intercepted_at_warehouse',
updated_at: now,
});
successOrderIds.push(orderId);
} catch (error) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 确认拦截失败, orderId=${orderId}, error=${error.message}`
);
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: `确认拦截失败: ${error.message}`,
});
}
}
// 创建售后工单 + 通知快递群(成功订单 ID 汇总统一调用,失败不影响主流程)
if (successOrderIds.length > 0) {
try {
const operator = this.getOrderLogOperator();
await this.service.systems.afterSale.createInterceptWorkOrdersAndNotify({
orderIds: successOrderIds,
warehouseId,
creatorLabel: operator.name || '系统',
});
} catch (workOrderErr) {
ctx.logger.warn(
`[recheckOrder.confirmIntercept] 创建工单/通知失败, orderIds=${successOrderIds.join(',')}, error=${workOrderErr.message}`
);
}
}
return {
success: successOrders,
failed: failedOrders,
success_count: successOrders.length,
failed_count: failedOrders.length,
};
}
/**
@ -3965,7 +3839,7 @@ class RecheckOrderService extends OrderBaseService {
* 2. 校验通过后将运单 is_back、is_intercept 设为 'Y'
* 3. 检查是否存在关联的未完结售后工单(wms_after_sale),若有则调用 handleWorkOrder 写入
* "库内拦截成功"步骤并将工单置为 completed
* 4. 同步更新 wms_order_delivery 的 intercept_status 为 intercepted_at_warehouse,
* 4. 同步更新 wms_order_delivery 的 intercept_status 为 intercepted_at_warehouse 并写入拦截时间 intercept_time,
* 并释放储位分配(拦截模式:库存移入拦截锁定,不归还可用)与订单锁(仅订单级状态更新,不标记订单下其他面单)
*
* 注:库内拦截确认需标记退回 is_back='Y';发起拦截链路仅写 is_intercept,不写 is_back。
@ -4082,6 +3956,7 @@ class RecheckOrderService extends OrderBaseService {
await orderModel.update(
{
intercept_status: 'intercepted_at_warehouse',
intercept_time: now,
step: 4,
outbound_status: 'fin',
updated_at: now,
@ -5033,8 +4908,170 @@ class RecheckOrderService extends OrderBaseService {
);
}
/**
* 将波次内「已拦截且未打印」的订单移除出波次(回池)。
*
* 背景:拦截订单无法打印、无法复核,会卡住波次复核完成判定与波次终结;
* 解除拦截后因 wave_id 仍大于 0 而无法被波次策略重新抓取,导致无法继续发货。
* 复核链路在更新复核状态后调用本方法,把未打印的拦截订单从波次中释放回候选池,
* 拦截解除后即可重新抓取发货;已打印(print_status != 'none')的拦截订单保持不动,
* 避免已贴面单实物与波次记录分离。
*
* @param {Object} params 移除参数。
* @param {number} params.waveId 波次ID。
* @param {number} params.warehouseId 仓库ID。
* @param {{ id: string|null, name: string }} params.operator 操作人信息。
* @param {Object} [params.transaction] Sequelize 事务对象(事务内调用时传入)。
* @return {Promise<{removed_order_ids: number[], removed_count: number}>} 移除结果。
*/
async removeUnprintedInterceptedOrdersFromWave({ waveId, warehouseId, operator, transaction = null } = {}) {
const { ctx } = this;
const normalizedWaveId = Number(waveId || 0);
const normalizedWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(normalizedWaveId) || normalizedWaveId <= 0
|| !Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
return { removed_order_ids: [], removed_count: 0 };
}
// 查询波次内「已拦截且未打印」的订单(intercept_status 空值按 none 处理,Op.ne 对 NULL 不命中)
const orderModel = await this.getOrderModelByTableType('current', normalizedWarehouseId);
const removableRows = await orderModel.findAll({
where: {
warehouse_id: normalizedWarehouseId,
wave_id: normalizedWaveId,
print_status: 'none',
intercept_status: { [this.app.Sequelize.Op.ne]: 'none' },
},
attributes: [ 'id', 'wave_id', 'wave_no' ],
raw: true,
transaction,
});
const normalizedRemovableRows = Array.isArray(removableRows) ? removableRows : [];
const removedOrderIds = [ ...new Set(normalizedRemovableRows
.map(row => Number(row && row.id || 0))
.filter(id => Number.isInteger(id) && id > 0)) ];
if (removedOrderIds.length === 0) {
return { removed_order_ids: [], removed_count: 0 };
}
// 1. 订单 wave_id 清零(回池),清空波次编号与策略扫描标记
await orderModel.update({
wave_id: 0,
wave_no: '',
wave_strategy_version: 0,
wave_scan_result: 0,
}, {
where: {
warehouse_id: normalizedWarehouseId,
id: { [this.app.Sequelize.Op.in]: removedOrderIds },
},
transaction,
validate: false,
hooks: false,
});
// 2. 删除波次索引行(其余订单 wave_index 保持不变仅跳号,避免与已放货篮子编号错位)
const waveService = ctx.service && ctx.service.systemMethods && ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.deleteOrderWaveIndexByOrderIds === 'function') {
await waveService.deleteOrderWaveIndexByOrderIds({
warehouseId: normalizedWarehouseId,
orderIds: removedOrderIds,
transaction,
});
}
// 3. 移除任务订单关联(散单模式),任务复核完成判定与进度统计不再包含拦截订单
await ctx.model.query(
`DELETE FROM wms_wave_pick_task_order
WHERE warehouse_id = :warehouseId
AND order_id IN (:orderIds)`,
{
replacements: {
warehouseId: normalizedWarehouseId,
orderIds: removedOrderIds,
},
transaction,
}
);
// 4. 回写波次统计:total_orders 扣除被移除订单数,processed_orders 收敛不超过剩余订单数
const remainingRows = await orderModel.findAll({
where: {
warehouse_id: normalizedWarehouseId,
wave_id: normalizedWaveId,
},
attributes: [ 'id' ],
raw: true,
transaction,
});
const remainingCount = Array.isArray(remainingRows) ? remainingRows.length : 0;
await ctx.model.query(
`UPDATE wms_wave_batch
SET total_orders = :remainingCount,
processed_orders = LEAST(processed_orders, :remainingCount),
update_time = NOW()
WHERE warehouse_id = :warehouseId
AND wave_id = :waveId`,
{
replacements: {
warehouseId: normalizedWarehouseId,
waveId: normalizedWaveId,
remainingCount,
},
type: ctx.model.QueryTypes.UPDATE,
transaction,
}
);
// 5. 写订单操作日志 ORDER_WAVE_REMOVE(不影响主流程)
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (operationLogService && typeof operationLogService.createOperationLogs === 'function') {
const logPayloads = normalizedRemovableRows.map(row => ({
businessType: 'order',
businessId: `${row.id}`,
operationCode: 'ORDER_WAVE_REMOVE',
operator: {
id: operator && operator.id ? String(operator.id) : null,
name: operator && operator.name ? String(operator.name).trim() : 'system',
},
extras: {
message: `订单从波次 ${String(row && row.wave_no || '').trim() || '未知波次'} 中移除`,
warehouseId: normalizedWarehouseId,
externalLogType: 'API',
},
}));
await operationLogService.createOperationLogs(logPayloads);
}
} catch (logErr) {
ctx.logger.warn(`[recheckOrder.removeUnprintedIntercepted] 写订单操作日志失败,不影响主流程, waveId=${normalizedWaveId}, error=${logErr.message}`);
}
// 6. 触发波次策略快扫,让回池订单重新进入候选池(拦截未解除时策略仍会排除)
try {
if (waveService && typeof waveService.enqueueWaveStrategyQuickScanPostOrderChange === 'function') {
waveService.enqueueWaveStrategyQuickScanPostOrderChange(
normalizedWarehouseId,
removedOrderIds,
{ triggerScan: true, source: 'recheckRemoveUnprintedIntercepted' }
);
}
} catch (scanErr) {
ctx.logger.warn(`[recheckOrder.removeUnprintedIntercepted] 触发策略快扫失败,不影响主流程, waveId=${normalizedWaveId}, error=${scanErr.message}`);
}
ctx.logger.info(
`[recheckOrder.removeUnprintedIntercepted] 波次未打印拦截订单已移除回池, waveId=${normalizedWaveId}, removedCount=${removedOrderIds.length}, orderIds=${removedOrderIds.join(',')}`
);
return { removed_order_ids: removedOrderIds, removed_count: removedOrderIds.length };
}
/**
* 在事务中更新波次拣货任务订单的复核状态,并判断是否需要解绑车任务。
* 复核状态更新后,会先在事务内清理波次内「已拦截且未打印」的订单(回池),
* 避免其卡住任务完成判定。
*
* @param {number} orderId 订单ID。
* @param {number} warehouseId 仓库ID。
@ -5081,6 +5118,28 @@ class RecheckOrderService extends OrderBaseService {
}
);
// 复核时在事务内清理波次内「已拦截且未打印」的订单(回池),避免拦截订单卡住任务完成判定
try {
const cleanupOrderModel = await this.getOrderModelByTableType('current', warehouseId);
const cleanupOrder = await cleanupOrderModel.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id' ],
raw: true,
transaction,
});
const cleanupWaveId = Number(cleanupOrder && cleanupOrder.wave_id || 0);
if (cleanupWaveId > 0) {
await this.removeUnprintedInterceptedOrdersFromWave({
waveId: cleanupWaveId,
warehouseId,
operator,
transaction,
});
}
} catch (removeErr) {
ctx.logger.warn(`[batchQuickRecheck] 清理波次未打印拦截订单失败,不影响复核主流程, orderId=${orderId}, error=${removeErr.message}`);
}
// 查询当前订单所属的波次拣货任务ID
const taskRows = await ctx.model.query(
`SELECT DISTINCT task_id

View File

@ -7,6 +7,7 @@ const {
ExpressPrintPayloadBuilder,
RequestScopedPrintIdGenerator,
} = require('../../lib/express_print_payload_builder');
const { INTERCEPT_STATUS_NONE } = require('../../lib/intercept_guard');
/**
* 打印 Service
@ -2880,21 +2881,40 @@ class PrintService extends MainService {
}
const orderDeliveryModel = await orderDeliveryFactory.getCurrentModel(resolvedWarehouseId);
// 查询任务主表:团购模式校验、任务结束状态兜底解绑均需要
const taskRows = await ctx.model.query(
'SELECT pick_mode, status FROM wms_wave_pick_task WHERE id = :taskId LIMIT 1',
{ replacements: { taskId }, type: ctx.model.QueryTypes.SELECT }
);
const task = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
if (!task) return;
const pickMode = Number(task.pick_mode || 0);
const taskStatus = Number(task.status || 0);
// 拦截订单不可打印(打印清单剔除 + 打印回执更新排除拦截订单),print_status 永远停留在 none。
// 解绑判定的「未打印」统计必须排除拦截订单,与打印剔除、复核打印统计口径保持一致,
// 避免波次内存在拦截订单时车永远无法解绑。
const nonInterceptedWhere = { [ctx.model.Sequelize.Op.in]: [ INTERCEPT_STATUS_NONE, null ] };
const unbindCart = async reason => {
const operator = this.getPrintOrderOperationOperator();
const unbindUserId = operator.id || null;
await ctx.model.query(
'UPDATE wms_pick_task_cart_binding SET is_active = 0, unbind_user_id = :unbindUserId, unbind_time = NOW(), update_time = NOW() WHERE task_id = :taskId AND is_active = 1',
{ replacements: { taskId, unbindUserId } }
);
this.ctx.logger.info('[print.unbindCart] 车标解绑成功', { waveId, warehouseId: resolvedWarehouseId, taskId, waveType, waveTypeLabel: waveType === 1 ? '团购' : '散单', reason, unbindUserId });
};
let totalOrderCount = 0;
let unprintedCount = 0;
if (waveType === 1) {
// 团购波次:仅团购拣货模式(pick_mode=1 小团购 / pick_mode=5 大团购)参与解绑判断
const taskRows = await ctx.model.query(
'SELECT pick_mode FROM wms_wave_pick_task WHERE id = :taskId LIMIT 1',
{ replacements: { taskId }, type: ctx.model.QueryTypes.SELECT }
);
const task = Array.isArray(taskRows) && taskRows.length > 0 ? taskRows[0] : null;
const pickMode = task ? Number(task.pick_mode) : 0;
if (![ 1, 5 ].includes(pickMode)) return;
// 团购任务订单不写入 wms_wave_pick_task_order,改为按任务关联的全部波次统计:
// 任务下所有波次的订单均已打印时才解绑
// 任务下所有波次的非拦截订单均已打印时才解绑
const taskWaveIdRows = await ctx.model.query(
'SELECT DISTINCT wave_id FROM wms_wave_pick_task_wave WHERE task_id = :taskId AND warehouse_id = :warehouseId',
{ replacements: { taskId, warehouseId: resolvedWarehouseId }, type: ctx.model.QueryTypes.SELECT }
@ -2902,32 +2922,51 @@ class PrintService extends MainService {
const waveIds = (Array.isArray(taskWaveIdRows) ? taskWaveIdRows : [])
.map(r => Number(r && r.wave_id))
.filter(id => id > 0);
if (waveIds.length === 0) return;
if (waveIds.length === 0) {
// 任务无波次关联:仅任务已结束(待复核/完成/取消)时兜底解绑,避免车残留
if ([ 2, 3, 9 ].includes(taskStatus)) await unbindCart('task_no_wave_ended');
return;
}
unprintedCount = await orderDeliveryModel.count({
where: {
warehouse_id: resolvedWarehouseId,
wave_id: { [ctx.model.Sequelize.Op.in]: waveIds },
print_status: 'none',
intercept_status: nonInterceptedWhere,
},
});
totalOrderCount = await orderDeliveryModel.count({
where: {
warehouse_id: resolvedWarehouseId,
wave_id: { [ctx.model.Sequelize.Op.in]: waveIds },
intercept_status: nonInterceptedWhere,
},
});
} else {
// 散单波次:按任务订单维度检查,任务下所有订单均已打印时才解绑
// 散单波次:按任务订单维度检查,任务下所有非拦截订单均已打印时才解绑
const taskOrders = await ctx.model.query(
'SELECT DISTINCT order_id FROM wms_wave_pick_task_order WHERE task_id = :taskId',
{ replacements: { taskId }, type: ctx.model.QueryTypes.SELECT }
);
const orderIds = (Array.isArray(taskOrders) ? taskOrders : []).map(r => Number(r && r.order_id)).filter(id => id > 0);
if (orderIds.length === 0) return;
if (orderIds.length === 0) {
// 任务订单关联为空(如拦截订单被提交拣货移除):任务已结束时兜底解绑,避免车残留
if ([ 2, 3, 9 ].includes(taskStatus)) await unbindCart('task_no_orders_ended');
return;
}
unprintedCount = await orderDeliveryModel.count({
where: { id: { [ctx.model.Sequelize.Op.in]: orderIds }, print_status: 'none' },
where: {
id: { [ctx.model.Sequelize.Op.in]: orderIds },
print_status: 'none',
intercept_status: nonInterceptedWhere,
},
});
totalOrderCount = await orderDeliveryModel.count({
where: {
id: { [ctx.model.Sequelize.Op.in]: orderIds },
intercept_status: nonInterceptedWhere,
},
});
totalOrderCount = orderIds.length;
}
if (unprintedCount > 0) {
@ -2935,13 +2974,7 @@ class PrintService extends MainService {
return;
}
const operator = this.getPrintOrderOperationOperator();
const unbindUserId = operator.id || null;
await ctx.model.query(
'UPDATE wms_pick_task_cart_binding SET is_active = 0, unbind_user_id = :unbindUserId, unbind_time = NOW(), update_time = NOW() WHERE task_id = :taskId AND is_active = 1',
{ replacements: { taskId, unbindUserId } }
);
this.ctx.logger.info('[print.unbindCart] 车标解绑成功', { waveId, warehouseId: resolvedWarehouseId, taskId, waveType, waveTypeLabel: waveType === 1 ? '团购' : '散单', unbindUserId });
await unbindCart('all_printed');
} catch (error) {
this.ctx.logger.error('[print.unbindCart] 解绑车标检查异常', { waveId, warehouseId: resolvedWarehouseId, taskId, waveType, error: error && error.message ? error.message : String(error) });
}

View File

@ -5,10 +5,10 @@ const MainService = require('../main');
class WorkbenchService extends MainService {
constructor(ctx) {
super(ctx);
const _noNeedLogin = 'business,getWorkbenchInfo,removeMember,bindMember';
const _noNeedRight = 'list,detail,business,getWorkbenchInfo,removeMember,bindMember';
const _noNeedLogin = 'business,getWorkbenchInfo,removeMember,bindMember,packOrder,finishPack,sendWeight,queryOrder';
const _noNeedRight = 'list,detail,business,getWorkbenchInfo,removeMember,bindMember,packOrder,finishPack,sendWeight,queryOrder';
const _noNeedLog = 'list,detail,getWorkbenchInfo,removeMember,bindMember';
const _noNeedAuth = 'list,detail,business,getWorkbenchInfo,removeMember,bindMember';
const _noNeedAuth = 'list,detail,business,getWorkbenchInfo,removeMember,bindMember,packOrder,finishPack,sendWeight,queryOrder';
this.systemInit(_noNeedLogin, _noNeedRight, _noNeedLog, _noNeedAuth);
}
@ -143,13 +143,15 @@ class WorkbenchService extends MainService {
}
/**
* 使用 token 获取工作台信息(免登录、免鉴权)
* @param data - { token }
* 使用 token 获取工作台信息(免登录、免鉴权)。
* 返回主表信息、成员列表 members,以及当前正在打包的波次(current_wave)与订单列表(current_orders)。
* @param {Object} data - { token }
*/
async getWorkbenchInfo(data) {
const { service } = this;
try {
const result = await service.systems.workbench.getWorkbenchInfoByToken(data || {});
const { token } = data || {};
const result = await service.systems.workbench.getWorkbenchInfoByToken({ token });
if (result && result.success) {
return this.success('获取成功', result);
}
@ -220,6 +222,117 @@ class WorkbenchService extends MainService {
return this.fail(error.message);
}
}
/**
* 工作台打包上报(免登录、免鉴权,以工作台 token 鉴权,仓库与工作台由服务端注入)
* @param {Object} data - {
* token, delivery_order_code, wave_no, status, pack_time,
* wave_total_orders, items_count, items_total, users
* }
*/
async packOrder(data) {
const { service } = this;
try {
const {
token,
delivery_order_code: deliveryOrderCode,
wave_no: waveNo,
status,
pack_time: packTime,
wave_total_orders: waveTotalOrders,
items_count: itemsCount,
items_total: itemsTotal,
users,
} = data || {};
const result = await service.systems.workbench.packOrderByToken({
token,
delivery_order_code: deliveryOrderCode,
wave_no: waveNo,
status,
pack_time: packTime,
wave_total_orders: waveTotalOrders,
items_count: itemsCount,
items_total: itemsTotal,
users,
});
if (result && result.success) {
return this.success('ok', result);
}
const statusCode = result && result.statusCode;
return this.fail(
result && result.message ? result.message : '打包上报失败',
statusCode ? { code: statusCode } : undefined
);
} catch (error) {
return this.fail(error.message);
}
}
/**
* 工作台打包完成(免登录、免鉴权,以工作台 token 鉴权,仓库与工作台由服务端注入)
* @param {Object} data - { token }
*/
async finishPack(data) {
const { service } = this;
try {
const { token } = data || {};
const result = await service.systems.workbench.finishPackByToken({ token });
if (result && result.success) {
return this.success('ok', result);
}
const statusCode = result && result.statusCode;
return this.fail(
result && result.message ? result.message : '打包完成失败',
statusCode ? { code: statusCode } : undefined
);
} catch (error) {
return this.fail(error.message);
}
}
/**
* 工作台称重上报(免登录、免鉴权,以工作台 token 鉴权,仓库由服务端注入)
* @param {Object} data - { token, barcode, weight }
*/
async sendWeight(data) {
const { service } = this;
try {
const { token, barcode, weight } = data || {};
const result = await service.systems.workbench.sendWeightByToken({ token, barcode, weight });
if (result && result.success) {
return this.success('ok', result);
}
const statusCode = result && result.statusCode;
return this.fail(
result && result.message ? result.message : '称重上报失败',
statusCode ? { code: statusCode } : undefined
);
} catch (error) {
return this.fail(error.message);
}
}
/**
* 条码查询订单(免登录、免鉴权,以工作台 token 鉴权,仓库由服务端注入)
* body 传入的 warehouse_id/workbench_id 一律忽略,仅以 token 解析出的工作台仓库为准。
* @param {Object} data - { token, barcode }
*/
async queryOrder(data) {
const { service } = this;
try {
const { token, barcode } = data || {};
const result = await service.systems.workbench.queryOrderByToken({ token, barcode });
if (result && result.success) {
return this.success('ok', result);
}
const statusCode = result && result.statusCode;
return this.fail(
result && result.message ? result.message : '查询订单失败',
statusCode ? { code: statusCode } : undefined
);
} catch (error) {
return this.fail(error.message);
}
}
}
module.exports = WorkbenchService;

View File

@ -601,6 +601,76 @@ class ExpressPlatformService extends MainService {
}
}
/**
* 取号回写前兜底校验:比对订单主表当前快递编码与本次取号请求的快递编码。
*
* 取号请求为外部 HTTP 调用且耗时较长,期间订单快递可能被并发修改;
* 此处只做告警记录,不阻断回写,用于事后定位编码错位问题。
*
* @param {Object} params 校验入参。
* @param {string} params.traceId 本次取号链路标识。
* @param {Array<Object>} params.successUpdates 即将回写的成功取号项列表。
* @param {string} [params.requestExpressCode] 本次取号请求使用的快递编码。
* @param {Object} [params.transaction] 回写事务对象。
* @return {Promise<void>} 无返回值。
*/
async warnExpressCodeMismatch(params = {}) {
const {
traceId,
successUpdates,
requestExpressCode,
transaction,
} = params;
const updates = Array.isArray(successUpdates) ? successUpdates : [];
const requestCode = String(requestExpressCode || '').trim();
if (!requestCode || updates.length === 0) {
return;
}
const firstWarehouseId = Number(updates[0] && updates[0].warehouse_id) || 0;
if (!firstWarehouseId) {
return;
}
try {
const orderModel = await this.service.systems.express.getWaybillAsyncOrderDeliveryModel(firstWarehouseId);
const orderIds = updates
.map(item => Number(item && item.order_id))
.filter(v => Number.isFinite(v) && v > 0);
if (orderIds.length === 0) {
return;
}
const rows = await orderModel.findAll({
attributes: [ 'id', 'logistics_code' ],
where: { id: orderIds },
transaction,
raw: true,
});
const currentCodeMap = new Map(
(Array.isArray(rows) ? rows : [])
.map(row => [ Number(row && row.id) || 0, String(row && row.logistics_code || '').trim() ])
);
for (const item of updates) {
const orderId = Number(item && item.order_id) || 0;
const currentCode = currentCodeMap.get(orderId) || '';
if (currentCode && currentCode !== requestCode) {
this.ctx.logger.error('[expressPlatform.polyapi] 回写前快递编码不一致告警', {
traceId,
order_id: orderId,
request_express_code: requestCode,
current_logistics_code: currentCode,
});
}
}
} catch (error) {
// 兜底校验失败不影响回写主流程
this.ctx.logger.warn('[expressPlatform.polyapi] 回写前快递编码校验异常,跳过', {
traceId,
error: error && error.message ? error.message : `${error}`,
});
}
}
/**
* 从 orders 数据中提取失败订单清理所需的基本字段。
*
@ -630,11 +700,18 @@ class ExpressPlatformService extends MainService {
}
/**
* 菠萝派数据处理接口。
*
* @param {Object} [data={}] 平台业务入参。
* @return {Promise<never>} 当前暂未实现,直接抛出异常。
*/
* 菠萝派(PolyAPI)平台取号接口。
*
* 流程:查询已分配运单号 → 调用平台字典接口 → 按平台编码构造订单载荷并调用
* Differ.JH.Logistics.PostOrder 取号 → 逐条校验结果 → 事务回写运单号与快递编码。
* 回写前会兜底校验主表当前快递编码与本次取号接口编码是否一致,不一致仅告警。
*
* @param {Object} [data={}] 平台业务入参。
* @param {Object} [data.matchedPlatform] 匹配到的快递平台配置。
* @param {Object} [data.listByWarehousePlatformCode] 当前仓库平台快递接口配置。
* @param {Array} [data.orders] 待取号订单列表(含 order_delivery 与 business_key)。
* @return {Promise<void>} 无返回值;内部完成回写与日志,失败时抛出异常。
*/
async polyapi(data = {}) {
const { matchedPlatform, listByWarehousePlatformCode, orders } = data;
const traceId = this.buildExpressPlatformTraceId(data);
@ -1564,6 +1641,15 @@ class ExpressPlatformService extends MainService {
// 与 createWaybillCode 回写事务一致,避免 AB-BA 死锁
await this.lockAndDeductWaybillSettlement(settlementRelationMap, storeWarehouseModel, transaction);
// 回写前兜底校验:主表当前快递编码与本次取号接口编码不一致时告警,
// 防止取号期间订单快递被并发修改导致回写编码错位
await this.warnExpressCodeMismatch({
traceId,
successUpdates,
requestExpressCode: listByWarehousePlatformCode && listByWarehousePlatformCode.sys_express_code,
transaction,
});
for (const item of successUpdates) {
const warehouseId = Number(item.warehouse_id) || 0;
const orderId = Number(item.order_id) || 0;

View File

@ -0,0 +1,576 @@
// app/service/systems/intercept_auto_confirm.js
'use strict';
const MainService = require('../main');
// 允许确认拦截(更新为 intercepted_at_warehouse)的前置拦截状态白名单:
// 拦截发起中(requested/requesting/intercepting)与历史遗留值 intercepted。
// 其余状态一律不允许确认拦截,防止并发修改导致误更新。
const CONFIRMABLE_INTERCEPT_STATUSES = Object.freeze([ 'requested', 'requesting', 'intercepting', 'intercepted' ]);
// 自动确认扫描命中的拦截状态:仅请求拦截(requested)
const AUTO_CONFIRM_INTERCEPT_STATUS = 'requested';
// 自动确认扫描要求的面单打印状态:未打印
const AUTO_CONFIRM_PRINT_STATUS = 'none';
// 拦截时间超时阈值(小时):intercept_time 超过 12 小时自动确认
const INTERCEPT_TIME_TIMEOUT_HOURS = 12;
// 创建时间超时阈值(小时):create_at 超过 36 小时自动确认
const CREATE_AT_TIMEOUT_HOURS = 36;
// 拦截时间超时阈值(毫秒),供口径镜像函数使用
const INTERCEPT_TIME_TIMEOUT_MS = INTERCEPT_TIME_TIMEOUT_HOURS * 60 * 60 * 1000;
// 创建时间超时阈值(毫秒),供口径镜像函数使用
const CREATE_AT_TIMEOUT_MS = CREATE_AT_TIMEOUT_HOURS * 60 * 60 * 1000;
// 单批扫描数量上限(分页扫描,避免单批过大)
const SCAN_BATCH_SIZE = 100;
// 单批确认数量上限(批量确认,避免单批过大)
const CONFIRM_BATCH_SIZE = 100;
// 仓库当前表分表名匹配模式:wms_order_delivery_{warehouseId}(不含 history/dispatch/outsourced)
const CURRENT_SHARD_TABLE_PATTERN = /^wms_order_delivery_(\d+)$/;
// 定时任务自动确认的操作人(无用户上下文)
const AUTO_CONFIRM_OPERATOR = Object.freeze({ id: null, name: '系统' });
/**
* 将任意时间值转换为毫秒时间戳,无法解析时返回 null。
*
* @param {*} value 时间值(Date / 日期字符串 / 数字)。
* @return {number|null} 毫秒时间戳或 null。
*/
function toTimestamp(value) {
if (value === null || value === undefined || value === '') {
return null;
}
if (value instanceof Date) {
const time = value.getTime();
return Number.isFinite(time) ? time : null;
}
if (typeof value === 'number') {
return Number.isFinite(value) ? value : null;
}
const parsed = Date.parse(String(value));
return Number.isFinite(parsed) ? parsed : null;
}
/**
* 自动库内拦截确定服务。
*
* 背景:订单发起拦截(intercept_status='requested')后若人工迟迟未做「库内拦截确定」,
* 订单会长期停留在拦截发起中。本服务定时扫描待处理表(current 分表),对
* 「intercept_status='requested' 且 print_status='none'(面单未打印)」的订单,
* 满足以下任一条件时自动执行库内拦截确定:
* - intercept_time 超过 12 小时(NULL 自然不命中,无需特判);
* - create_at 超过 36 小时。
*
* 本服务同时提供 confirmInterceptForOrderIds 作为库内拦截确定的内部实现,
* systemMethods/order/recheckOrder.js 的 confirmIntercept 出口复用该方法,
* 定时任务同样复用,保证两条链路行为一致。
*/
class InterceptAutoConfirmService extends MainService {
/**
* 在当前调用内临时注入 ctx.user 上下文,并在结束后恢复。
*
* 用于复用依赖登录上下文的既有 service 能力(如储位取消分配读取 ctx.user.store_id),
* 避免扩大影响范围。
*
* @param {Object} patchUser 需要覆盖的用户上下文字段。
* @param {Function} callback 业务回调。
* @return {Promise<any>} 回调执行结果。
*/
async withPatchedCtxUser(patchUser, callback) {
const { ctx } = this;
const originUser = ctx.user;
const safeOriginUser = originUser && typeof originUser === 'object' ? originUser : {};
const safePatchUser = patchUser && typeof patchUser === 'object' ? patchUser : {};
ctx.user = {
...safeOriginUser,
...safePatchUser,
};
try {
return await callback();
} finally {
ctx.user = originUser;
}
}
/**
* 枚举库内全部仓库的当前订单分表(wms_order_delivery_{warehouseId})对应的仓库ID。
*
* 通过 INFORMATION_SCHEMA 枚举真实存在的物理分表,比查询 wms_warehouse 更可靠:
* 避免仓库配置表与物理分表不一致(如已建表未配置、已停用仓库残留分表)导致的漏扫;
* history/dispatch/outsourced 等表位通过表名正则过滤,仅保留 current 表位。
*
* @return {Promise<number[]>} 仓库ID列表。
*/
async listCurrentWarehouseIds() {
const { ctx } = this;
const rows = await ctx.model.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',
{ type: ctx.model.QueryTypes.SELECT }
);
const warehouseIds = [];
for (const row of (Array.isArray(rows) ? rows : [])) {
const tableName = String(row.tableName || row.TABLE_NAME || '').trim();
const matched = CURRENT_SHARD_TABLE_PATTERN.exec(tableName);
if (!matched) {
continue;
}
const warehouseId = Number(matched[1]);
if (Number.isInteger(warehouseId) && warehouseId > 0) {
warehouseIds.push(warehouseId);
}
}
return Array.from(new Set(warehouseIds));
}
/**
* 构造自动确认候选订单的 SQL 过滤条件(不含 warehouse_id 与 id 分页条件)。
*
* 口径:
* - intercept_status = 'requested'(请求拦截);
* - print_status = 'none'(面单未打印);
* - 满足任一超时条件:intercept_time 超过 12 小时,或 create_at 超过 36 小时;
* 时间比较使用数据库侧 NOW()/DATE_SUB,避免应用与数据库时钟偏差;
* intercept_time 为 NULL 时小于比较自然不命中,无需特判。
*
* @return {string} SQL 过滤条件片段。
*/
buildCandidateWhereSql() {
return `intercept_status = '${AUTO_CONFIRM_INTERCEPT_STATUS}'`
+ ` AND print_status = '${AUTO_CONFIRM_PRINT_STATUS}'`
+ ' AND ('
+ ` intercept_time < DATE_SUB(NOW(), INTERVAL ${INTERCEPT_TIME_TIMEOUT_HOURS} HOUR)`
+ ` OR create_at < DATE_SUB(NOW(), INTERVAL ${CREATE_AT_TIMEOUT_HOURS} HOUR)`
+ ' )';
}
/**
* 候选订单口径镜像函数:判断单行是否命中自动确认条件(12h/36h 口径)。
*
* 与 buildCandidateWhereSql 的 SQL 口径保持一致,供单元测试验证边界语义;
* 生产扫描以 SQL 为准。
*
* @param {Object} fields 订单行字段。
* @param {string} [fields.interceptStatus] 拦截状态。
* @param {string} [fields.printStatus] 面单打印状态。
* @param {Date|string|number|null} [fields.interceptTime] 拦截时间(可空)。
* @param {Date|string|number|null} [fields.createAt] 创建时间。
* @param {Date} [now=new Date()] 当前时间基准。
* @return {boolean} 是否命中自动确认条件。
*/
matchesAutoConfirmCriteria(fields = {}, now = new Date()) {
const row = fields && typeof fields === 'object' ? fields : {};
const interceptStatus = String(row.interceptStatus ?? '').trim();
const printStatus = String(row.printStatus ?? '').trim();
const nowMs = now instanceof Date ? now.getTime() : toTimestamp(now);
if (interceptStatus !== AUTO_CONFIRM_INTERCEPT_STATUS || printStatus !== AUTO_CONFIRM_PRINT_STATUS) {
return false;
}
const interceptMs = toTimestamp(row.interceptTime);
if (interceptMs !== null && interceptMs < nowMs - INTERCEPT_TIME_TIMEOUT_MS) {
return true;
}
const createMs = toTimestamp(row.createAt);
if (createMs !== null && createMs < nowMs - CREATE_AT_TIMEOUT_MS) {
return true;
}
return false;
}
/**
* 解析并校验仓库当前订单分表名。
*
* @param {number|string} warehouseId 仓库ID。
* @return {string} 可直接拼接到 SQL 的表名(仅含字母数字下划线)。
*/
resolveCurrentTableName(warehouseId) {
const normalizedWarehouseId = Number(warehouseId);
if (!Number.isInteger(normalizedWarehouseId) || normalizedWarehouseId <= 0) {
throw new Error(`非法仓库ID: ${warehouseId}`);
}
const factory = this.ctx.model && this.ctx.model.OrderDeliveryFactory;
if (!factory || typeof factory.generateTableName !== 'function') {
throw new Error('订单工厂不可用');
}
const tableName = String(factory.generateTableName(normalizedWarehouseId, 'current') || '').trim();
if (!/^[a-zA-Z0-9_]+$/.test(tableName)) {
throw new Error(`订单表名不合法: ${tableName}`);
}
return tableName;
}
/**
* 分页扫描指定仓库的自动确认候选订单ID(id 游标翻页,避免 OFFSET 深翻页)。
*
* @param {number|string} warehouseId 仓库ID。
* @param {number} [batchSize=SCAN_BATCH_SIZE] 单批扫描数量。
* @return {Promise<number[]>} 命中条件的订单ID列表。
*/
async scanCandidateOrderIds(warehouseId, batchSize = SCAN_BATCH_SIZE) {
const { ctx } = this;
const tableName = this.resolveCurrentTableName(warehouseId);
const candidateWhereSql = this.buildCandidateWhereSql();
const normalizedBatchSize = Math.max(Number.parseInt(batchSize, 10) || SCAN_BATCH_SIZE, 1);
const orderIds = [];
let lastId = 0;
for (;;) {
const rows = await ctx.model.query(
'SELECT id'
+ ` FROM ${tableName}`
+ ' WHERE warehouse_id = :warehouseId'
+ ` AND ${candidateWhereSql}`
+ ' AND id > :lastId'
+ ' ORDER BY id ASC'
+ ' LIMIT :limit',
{
replacements: {
warehouseId: Number(warehouseId),
lastId,
limit: normalizedBatchSize,
},
type: ctx.model.QueryTypes.SELECT,
}
);
const pageRows = Array.isArray(rows) ? rows : [];
if (pageRows.length === 0) {
break;
}
let pageMaxId = lastId;
for (const row of pageRows) {
const orderId = Number(row && row.id || 0);
if (Number.isFinite(orderId) && orderId > 0) {
orderIds.push(orderId);
pageMaxId = orderId;
}
}
// 防死循环:本页没有解析出任何有效订单ID,或已不足一页,结束翻页
if (pageMaxId <= lastId || pageRows.length < normalizedBatchSize) {
break;
}
lastId = pageMaxId;
}
return orderIds;
}
/**
* 库内拦截确定内部实现:按订单ID列表批量确认仓库拦截(不依赖用户上下文)。
*
* systemMethods 出口 confirmIntercept 与定时任务统一复用本方法,保证行为一致。
* 支持部分失败:未找到的订单与处理失败的订单记录在 failed 列表并返回失败原因,
* 其余订单继续处理;每单失败不影响其他订单。
*
* 每个订单的拦截处理:
* 1. 更新订单:intercept_status=intercepted_at_warehouse、intercept_time=当前时间、
* step=4、outbound_status=fin,where 同时限定拦截状态白名单防并发误更新
* 2. 同步更新运单表:is_intercept='Y'、is_back='Y'
* 3. 释放储位分配(cancelAllocateStorage 拦截模式,临时注入仓库上下文)
* 4. 释放订单锁(lock_status='none')
* 5. 写入操作日志(ORDER_INTERCEPT_CONFIRM)
* 全部订单处理完后,按成功订单ID汇总批量创建售后工单 + 通知快递群。
* 运单标记、储位释放、锁释放、工单创建、日志写入失败均不影响主流程。
*
* @param {Object} params 参数。
* @param {number[]} params.orderIds 订单ID列表。
* @param {number|string} params.warehouseId 仓库ID。
* @param {Object} [params.operator] 操作人信息({ id, name })。
* @return {Promise<Object>} 批量拦截结果,包含 success/failed 列表与 success_count/failed_count 计数。
*/
async confirmInterceptForOrderIds(params = {}) {
const { ctx } = this;
const requestParams = params && typeof params === 'object' ? params : {};
const orderIds = Array.isArray(requestParams.orderIds)
? Array.from(new Set(
requestParams.orderIds.map(value => Number(value)).filter(value => Number.isFinite(value) && value > 0)
))
: [];
const warehouseId = requestParams.warehouseId ?? null;
const operator = requestParams.operator && typeof requestParams.operator === 'object'
? requestParams.operator
: { ...AUTO_CONFIRM_OPERATOR };
if (orderIds.length === 0) {
throw new Error('订单ID不能为空');
}
if (warehouseId === null || warehouseId === undefined || warehouseId === '') {
throw new Error('缺少仓库上下文 store_id');
}
const { Op } = ctx.app.Sequelize;
const orderModel = await ctx.model.OrderDeliveryFactory.getCurrentModel(warehouseId);
const orderRows = await orderModel.findAll({
where: {
id: { [Op.in]: orderIds },
warehouse_id: warehouseId,
},
attributes: [ 'id', 'delivery_order_code', 'pre_delivery_order_code', 'intercept_status', 'wave_no' ],
raw: true,
});
const orderMap = new Map();
for (const row of orderRows) {
orderMap.set(Number(row.id), row);
}
const successOrders = [];
const failedOrders = [];
const successOrderIds = [];
for (const orderId of orderIds) {
const order = orderMap.get(orderId);
if (!order) {
failedOrders.push({ order_id: orderId, reason: '未找到对应订单' });
continue;
}
const orderNo = String(order.delivery_order_code || order.pre_delivery_order_code || '').trim();
const interceptStatus = String(order.intercept_status || '').trim();
// 未发起拦截(none/空)的订单直接跳过,不参与确认拦截处理
if (interceptStatus === '' || interceptStatus === 'none') {
continue;
}
// 已确认拦截的订单跳过,避免重复执行副作用(释放储位/工单/日志等)
if (interceptStatus === 'intercepted_at_warehouse') {
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: '订单已确认拦截',
});
continue;
}
// 仅拦截发起中与历史值 intercepted 允许确认,其余状态不允许确认拦截
if (!CONFIRMABLE_INTERCEPT_STATUSES.includes(interceptStatus)) {
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: `订单拦截状态不允许确认拦截: ${interceptStatus}`,
});
continue;
}
try {
const now = new Date();
const updateValues = {
intercept_status: 'intercepted_at_warehouse',
intercept_time: now,
step: 4,
outbound_status: 'fin',
updated_at: now,
};
const updateResult = await orderModel.update(updateValues, {
where: {
id: orderId,
warehouse_id: warehouseId,
// 数据库层再次限定拦截状态,防止查询后状态被并发修改导致误更新
intercept_status: { [Op.in]: CONFIRMABLE_INTERCEPT_STATUSES },
},
});
const affectedRows = Array.isArray(updateResult) ? Number(updateResult[0] || 0) : Number(updateResult || 0);
if (affectedRows <= 0) {
throw new Error('拦截状态更新失败,请稍后重试');
}
// 同步更新运单表:标记拦截 + 退回(库内拦截确认,货物在库内需退回)
try {
await ctx.model.OrderExpress.update(
{ is_intercept: 'Y', is_back: 'Y' },
{ where: { order_id: orderId, warehouse_id: warehouseId } }
);
} catch (expressErr) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 更新运单拦截/退回标记失败, orderId=${orderId}, error=${expressErr.message}`
);
}
// 拦截成功后释放储位分配(拦截模式:库存移入拦截锁定,不归还可用)
try {
await this.withPatchedCtxUser({ store_id: warehouseId }, () => (
ctx.service.systems.orderStorageAllocation.cancelAllocateStorage({
order_ids: [ orderId ],
interceptMode: true,
})
));
} catch (allocErr) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 释放储位分配失败,不影响拦截, orderId=${orderId}, error=${allocErr.message}`
);
}
// 拦截成功后释放订单锁
try {
await orderModel.update(
{ lock_status: 'none', updated_at: now },
{ where: { id: orderId, warehouse_id: warehouseId } }
);
} catch (lockErr) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 释放锁失败,不影响拦截, orderId=${orderId}, error=${lockErr.message}`
);
}
// 写入操作日志(失败不影响主流程)
try {
await ctx.service.systems.operationLog.createOperationLog({
businessType: 'order',
businessId: orderId,
operationCode: 'ORDER_INTERCEPT_CONFIRM',
operator,
extras: {
warehouseId,
orderId,
orderNo,
previousInterceptStatus: String(order.intercept_status || '').trim(),
newInterceptStatus: 'intercepted_at_warehouse',
},
beforeChanges: null,
});
} catch (logErr) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 写入操作日志失败,不影响业务, orderId=${orderId}, error=${logErr.message}`
);
}
successOrders.push({
order_id: orderId,
order_no: orderNo,
intercept_status: 'intercepted_at_warehouse',
updated_at: now,
});
successOrderIds.push(orderId);
} catch (error) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 确认拦截失败, orderId=${orderId}, error=${error.message}`
);
failedOrders.push({
order_id: orderId,
delivery_order_code: orderNo,
reason: `确认拦截失败: ${error.message}`,
});
}
}
// 创建售后工单 + 通知快递群(成功订单 ID 汇总统一调用,失败不影响主流程)
if (successOrderIds.length > 0) {
try {
await ctx.service.systems.afterSale.createInterceptWorkOrdersAndNotify({
orderIds: successOrderIds,
warehouseId,
creatorLabel: operator.name || '系统',
});
} catch (workOrderErr) {
ctx.logger.warn(
`[interceptAutoConfirm.confirmInterceptForOrderIds] 创建工单/通知失败, orderIds=${successOrderIds.join(',')}, error=${workOrderErr.message}`
);
}
}
return {
success: successOrders,
failed: failedOrders,
success_count: successOrders.length,
failed_count: failedOrders.length,
};
}
/**
* 自动库内拦截确定主入口:枚举仓库 → 分页扫描候选订单 → 分批确认拦截。
*
* 单个仓库扫描/确认失败仅记录日志与 detail.error,不影响其他仓库;
* 全部动作失败不阻断下轮执行(异常上抛由定时任务捕获记录)。
*
* @param {Object} [options={}] 执行选项。
* @param {number} [options.scanBatchSize=SCAN_BATCH_SIZE] 单批扫描数量。
* @param {number} [options.confirmBatchSize=CONFIRM_BATCH_SIZE] 单批确认数量。
* @return {Promise<Object>} 执行结果汇总,包含 warehouse_count/candidate_count/confirmed_count/
* failed_count/warehouse_ids/duration_ms/details。
*/
async runAutoConfirm(options = {}) {
const { ctx } = this;
const startedAt = Date.now();
const requestOptions = options && typeof options === 'object' ? options : {};
const scanBatchSize = Math.max(Number.parseInt(requestOptions.scanBatchSize, 10) || SCAN_BATCH_SIZE, 1);
const confirmBatchSize = Math.max(Number.parseInt(requestOptions.confirmBatchSize, 10) || CONFIRM_BATCH_SIZE, 1);
const warehouseIds = await this.listCurrentWarehouseIds();
const details = [];
let candidateCount = 0;
let confirmedCount = 0;
let failedCount = 0;
for (const warehouseId of warehouseIds) {
const detail = {
warehouse_id: warehouseId,
candidate_count: 0,
confirmed_count: 0,
failed_count: 0,
error: null,
};
try {
const candidateIds = await this.scanCandidateOrderIds(warehouseId, scanBatchSize);
detail.candidate_count = candidateIds.length;
for (let offset = 0; offset < candidateIds.length; offset += confirmBatchSize) {
const batchIds = candidateIds.slice(offset, offset + confirmBatchSize);
const batchResult = await this.confirmInterceptForOrderIds({
orderIds: batchIds,
warehouseId,
operator: AUTO_CONFIRM_OPERATOR,
});
detail.confirmed_count += batchResult.success_count;
detail.failed_count += batchResult.failed_count;
}
} catch (error) {
detail.error = String(error && error.message ? error.message : error);
ctx.logger.warn(
`[interceptAutoConfirm.runAutoConfirm] 仓库 ${warehouseId} 处理失败,跳过: ${detail.error}`
);
}
candidateCount += detail.candidate_count;
confirmedCount += detail.confirmed_count;
failedCount += detail.failed_count;
details.push(detail);
}
return {
warehouse_count: warehouseIds.length,
candidate_count: candidateCount,
confirmed_count: confirmedCount,
failed_count: failedCount,
warehouse_ids: warehouseIds,
duration_ms: Date.now() - startedAt,
details,
};
}
}
module.exports = InterceptAutoConfirmService;

View File

@ -1985,6 +1985,7 @@ class PickSystemService extends Service {
// 订单 wave_id 清零、重建波次索引、回写波次统计,并移除任务订单关联
const removedFromWaveOrderLogItems = [];
const removedFromWaveOrderIds = [];
const affectedWaveIdsForUnbind = [];
if (skippedInterceptedOrders.length > 0 && taskSource !== 0) {
const skippedOrderIds = skippedInterceptedOrders.map(item => item.order_id);
const interceptOrderModel = await this.getOrderModel(warehouseId);
@ -2007,6 +2008,7 @@ class PickSystemService extends Service {
const affectedWaveIds = [ ...new Set(normalizedRemovableRows
.map(row => Number(row && row.wave_id || 0))
.filter(waveId => Number.isInteger(waveId) && waveId > 0)) ];
affectedWaveIdsForUnbind.push(...affectedWaveIds);
if (normalizedRemovableRows.length > 0) {
await interceptOrderModel.update({
@ -2234,6 +2236,7 @@ class PickSystemService extends Service {
operatorName,
removedFromWaveOrderLogItems,
removedFromWaveOrderIds,
affectedWaveIds: affectedWaveIdsForUnbind,
});
return {
task_id: taskId,
@ -2519,6 +2522,7 @@ class PickSystemService extends Service {
operatorName,
removedFromWaveOrderLogItems,
removedFromWaveOrderIds,
affectedWaveIds: affectedWaveIdsForUnbind,
});
// 写入 order_operation_log 拣货完成日志
@ -2595,6 +2599,9 @@ class PickSystemService extends Service {
const removedFromWaveOrderIds = Array.isArray(params && params.removedFromWaveOrderIds)
? params.removedFromWaveOrderIds
: [];
const affectedWaveIds = Array.isArray(params && params.affectedWaveIds)
? params.affectedWaveIds
: [];
if (removedFromWaveOrderLogItems.length > 0) {
try {
@ -2645,6 +2652,28 @@ class PickSystemService extends Service {
});
}
}
// 拦截订单被移出波次后,补触发打印完成解绑车核实:
// 打印链路对含拦截订单的波次无法解绑(拦截订单不可打印),提交拣货移除拦截订单后重查一次,
// 保证任务结束时车能被释放(不影响主流程)
if (affectedWaveIds.length > 0) {
try {
const printService = this.ctx
&& this.ctx.service
&& this.ctx.service.systemMethods
&& this.ctx.service.systemMethods.print;
if (printService && typeof printService.tryUnbindCartAfterPrintComplete === 'function') {
for (const waveId of [ ...new Set(affectedWaveIds) ]) {
await printService.tryUnbindCartAfterPrintComplete(waveId, warehouseId);
}
}
} catch (e) {
this.ctx.logger.warn('[pick.wavePickTaskComplete] 移除拦截订单后补触发解绑车失败,不影响主流程', {
error: e && e.message,
affectedWaveIds,
});
}
}
}
/**

View File

@ -358,6 +358,7 @@ class ReturnReceivedService extends Service {
* 更新退回运单关联订单的退回状态并写入操作记录(不处理库存信息)。
* - current 表(待处理):设置 intercept_status='returned'、step=4、outbound_status='fin' 触发自动转配送表;
* - dispatch 表(配送中):仅更新 intercept_status='returned';
* - 两条链路均同步写入拦截时间 intercept_time(当前时间);
* - 不释放储位分配、不释放订单锁。
* 兼容 current/dispatch 分表:先查 current 表,不存在再查 dispatch 表。
*
@ -399,6 +400,7 @@ class ReturnReceivedService extends Service {
const updateFields = {
intercept_status: 'returned',
intercept_time: new Date(),
updated_at: new Date(),
};

View File

@ -388,9 +388,9 @@ class StorageReportService extends Service {
* @param {number[]} [options.storeIds=[]] 货主ID列表
* @param {number[]} [options.spaceIds=[]] 库位ID列表
* @param {boolean} [options.includeBarcode=false] 是否加载条码映射
* @param options.entryOrderIds
* @param options.orderIds
* @param options.warehouseId
* @param {number[]} [options.entryOrderIds=[]] 入库单ID列表
* @param {number[]} [options.orderIds=[]] 出库单ID列表
* @param {number|null} [options.warehouseId=null] 仓库ID
* @return {Promise<Object>} 映射对象
*/
async loadReportReferenceMaps({
@ -577,7 +577,7 @@ class StorageReportService extends Service {
* @param {Object} [sort] 排序参数
* @param {string} [sort.sortField] 排序字段
* @param {string} [sort.sortOrder] 排序顺序
* @param {string} [exportMode] 导出模式:'item' 导出全部(含锁定),不传/其他值则排除锁定类型记录
* @param {string} [exportMode] 导出模式(仅仓库侧生效):'item' 导出全部(含锁定),不传/其他值则排除锁定类型记录;货主侧固定只导出出入库流水
* @param {string} [searchMode='warehouse'] 查询维度:'warehouse' 按仓库维度(默认),'store' 按货主维度
* @param {number[]} [stockIds=null] 商品库存ID列表(精确过滤)
* @param {string} [keyword=''] 商品关键字(模糊匹配)
@ -633,7 +633,11 @@ class StorageReportService extends Service {
}
const normalizedExportMode = String(exportMode || '').trim();
if (normalizedExportMode !== 'item') {
if (isStoreMode) {
// 货主侧口径:变更记录只包含出入库流水,锁定/解锁(LOCK/UNLOCK)一律不导出,无视 exportMode
whereClauses.push('t.transaction_type NOT IN (:excludeStoreTypes)');
replacements.excludeStoreTypes = [ 'LOCK', 'UNLOCK' ];
} else if (normalizedExportMode !== 'item') {
whereClauses.push('t.transaction_type != :excludeLockType');
replacements.excludeLockType = 'LOCK';
}
@ -1185,14 +1189,14 @@ class StorageReportService extends Service {
ON ft.id = (
SELECT MIN(t2.id)
FROM ${transactionSource.tableName} t2
WHERE ${rebindTableAlias(rangeWhereClauses, 't2').join(' AND ')}${isBySpace ? ' AND COALESCE(t2.space_id, 0) = g.space_id' : ''}
WHERE ${rebindTableAlias(rangeWhereClauses, 't2').join(' AND ')}${isBySpace ? ' AND COALESCE(t2.space_id, 0) = g.space_id' : ''} AND t2.stock_id = g.stock_id AND t2.store_id = g.store_id
AND t2.created_at = g._min_ct
)
LEFT JOIN ${transactionSource.tableName} lt
ON lt.id = (
SELECT MAX(t3.id)
FROM ${transactionSource.tableName} t3
WHERE ${rebindTableAlias(rangeWhereClauses, 't3').join(' AND ')}${isBySpace ? ' AND COALESCE(t3.space_id, 0) = g.space_id' : ''}
WHERE ${rebindTableAlias(rangeWhereClauses, 't3').join(' AND ')}${isBySpace ? ' AND COALESCE(t3.space_id, 0) = g.space_id' : ''} AND t3.stock_id = g.stock_id AND t3.store_id = g.store_id
AND t3.created_at = g._max_ct
)
ORDER BY g.stock_id ASC, g.space_id ASC, g.store_id ASC, g._min_ct ASC, g._max_ct ASC
@ -1245,7 +1249,7 @@ class StorageReportService extends Service {
ON lt.id = (
SELECT MAX(t3.id)
FROM ${transactionSource.tableName} t3
WHERE ${rebindTableAlias(preStartWhereClauses, 't3').join(' AND ')}${isBySpace ? ' AND COALESCE(t3.space_id, 0) = g.space_id' : ''}
WHERE ${rebindTableAlias(preStartWhereClauses, 't3').join(' AND ')}${isBySpace ? ' AND COALESCE(t3.space_id, 0) = g.space_id' : ''} AND t3.stock_id = g.stock_id AND t3.store_id = g.store_id
AND t3.created_at = g._max_ct
)
ORDER BY g.stock_id ASC, g.space_id ASC, g.store_id ASC, g._max_ct DESC

View File

@ -9,6 +9,10 @@ const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
const WAVE_ORDER_COUNT_CACHE_KEY_PREFIX = 'cache:workbench:wave_order_count';
/** @type {number} 工作台波次订单实时计数缓存 TTL(秒),TTL 内分表 COUNT 只执行一次 */
const WAVE_ORDER_COUNT_CACHE_TTL_SECONDS = 15;
/** @type {string} 工作台波次商品总件数缓存 key 前缀(最终 key:{前缀}:{warehouseId}:{waveId}) */
const WAVE_ITEMS_TOTAL_CACHE_KEY_PREFIX = 'cache:workbench:wave_items_total';
/** @type {number} 工作台波次商品总件数缓存 TTL(秒),TTL 内分表 SUM 只执行一次 */
const WAVE_ITEMS_TOTAL_CACHE_TTL_SECONDS = 15;
/** @type {string} 工作台绑定会话缓存 key 前缀(client_code 维度,最终 key:{前缀}{clientCode}) */
const WORKBENCH_BIND_CLIENT_CACHE_PREFIX = 'workbench:bind:client:';
@ -310,6 +314,78 @@ class WorkbenchService extends Service {
return total;
}
/**
* 实时统计波次下的商品总件数(并发遍历 current + dispatch 分表,SUM(items_total))
*
* items_total 为订单级商品总数(权威字段,非 SKU 品种数),对波次内 current 与 dispatch
* 两张分表分别执行 SUM 并使用 Promise.all 并发执行,将缓存未命中时的实时统计耗时
* 从两张表串行累加压缩为单表耗时级别;单张分表查询失败时按 0 处理,不影响另一张表。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的商品总件数之和
*/
async _sumWaveItemsTotal(warehouseId, waveId) {
const { ctx } = this;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const sums = await Promise.all(tableOrders.map(async entry => {
try {
const model = await entry.getModel();
if (!model) return 0;
const sum = await model.sum('items_total', { where: { wave_id: waveId, warehouse_id: warehouseId } });
return Number(sum) || 0;
} catch (_err) { return 0; }
}));
return sums.reduce((total, sum) => total + sum, 0);
}
/**
* 团购波次商品总件数统计(带 Redis 短 TTL 缓存兜底)
*
* 分表 SUM 与订单计数 COUNT 同属无索引扫描,生产耗时长,因此与 _countWaveOrdersCached
* 保持一致:按 (warehouseId, waveId) 维度做 15s 短 TTL 缓存,TTL 内重复查询直接命中;
* 缓存不可用或读取失败时降级为实时统计。打包状态变更(packOrder/finishPack)会主动失效
* 工作台 token 缓存(含 current_wave 快照),本短缓存在 TTL 到期后自动重建最新值。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的商品总件数之和
*/
async _sumWaveItemsTotalCached(warehouseId, waveId) {
const { ctx, app } = this;
const cacheKey = `${WAVE_ITEMS_TOTAL_CACHE_KEY_PREFIX}:${warehouseId}:${waveId}`;
if (app && typeof app.getCacheAsync === 'function') {
try {
const cached = await app.getCacheAsync(cacheKey);
if (cached !== null && cached !== undefined) {
const parsed = Number(cached);
if (Number.isFinite(parsed) && parsed >= 0) {
return parsed;
}
}
} catch (cacheReadErr) {
ctx.logger.warn('[Workbench._sumWaveItemsTotalCached] 读取缓存失败,降级为实时统计: %s', cacheReadErr.message);
}
}
const total = await this._sumWaveItemsTotal(warehouseId, waveId);
if (app && typeof app.setCacheAsync === 'function') {
try {
await app.setCacheAsync(cacheKey, total, WAVE_ITEMS_TOTAL_CACHE_TTL_SECONDS);
} catch (cacheWriteErr) {
ctx.logger.warn('[Workbench._sumWaveItemsTotalCached] 写入缓存失败,不影响本次返回: %s', cacheWriteErr.message);
}
}
return total;
}
/**
* 获取波次下订单ID(遍历 current + dispatch 分表)。
* 默认排除拦截订单(intercept_status 空值按 none 处理),
@ -790,6 +866,10 @@ class WorkbenchService extends Service {
const packTask = await ctx.model.PackTask.create(packData);
ctx.logger.info('[Workbench._packOrder] 创建打包任务 taskId=%d orderId=%d', packTask.id, orderId);
// 打包任务状态已变更(新建任务,且可能已关闭上一个未结束任务),
// 失效对应工作台 token 缓存,保证 getWorkbenchInfo 尽快返回最新打包中信息。
await this.invalidateWorkbenchTokenCacheByWorkbenchId(validWorkbenchId);
// 步骤6.5:更新订单的打包状态字段(散单按订单更新,团购按波次批量更新)
// 传 packData.status(已归一化,缺省为 1),避免设备端未传 status 时订单被误写为已完成
await this._updateOrderPackStatus(warehouseId, {
@ -1018,6 +1098,9 @@ class WorkbenchService extends Service {
const endTime = await this.resolvePackTaskEndTime(lastTask, now);
await lastTask.update({ end_time: endTime, status: 2 });
// 打包任务已结束,失效对应工作台 token 缓存,保证 getWorkbenchInfo 尽快返回最新打包中信息。
await this.invalidateWorkbenchTokenCacheByWorkbenchId(validWorkbenchId);
ctx.logger.info('[Workbench._finishPack] 工作台 %d 结束打包任务 taskId=%d orderId=%d',
validWorkbenchId, lastTask.id, lastTask.order_id);
@ -2016,9 +2099,10 @@ class WorkbenchService extends Service {
}
/**
* 格式化工作台 token 缓存/接口信息(不含 token、login_code 敏感字段)。
* 格式化工作台主表字段(不含 token、login_code 敏感字段,不含成员列表)。
* 成员列表由 buildWorkbenchTokenInfo 统一组装。
* @param {Object} record 工作台记录(模型实例或普通对象)
* @return {Object} 对外信息
* @return {Object} 工作台主表对外信息
*/
formatWorkbenchTokenInfo(record) {
const plain = record && typeof record.get === 'function'
@ -2037,10 +2121,188 @@ class WorkbenchService extends Service {
};
}
/**
* 查询工作台未软删除的成员列表(轻量字段,供缓存组装与接口返回)。
* @param {number} workbenchId 工作台 ID
* @return {Promise<Array<{id: number, user_id: (number|null), user_name: (string|null)}>>} 成员列表
*/
async listWorkbenchMembers(workbenchId) {
const { ctx } = this;
const rows = await ctx.model.WorkbenchMember.findAll({
where: { workbench_id: workbenchId },
attributes: [ 'id', 'user_id', 'user_name' ],
order: [[ 'id', 'ASC' ]],
});
return rows.map(row => ({
id: row.id,
user_id: row.user_id,
user_name: row.user_name,
}));
}
/**
* 查询工作台当前未结束的打包任务列表(status < 2,按 id 倒序)。
* 判定口径与 _packOrder/_finishPack 保持一致:0=待处理、1=打包中均视为未结束。
* @param {number} workbenchId 工作台 ID
* @param {number} warehouseId 仓库 ID
* @return {Promise<Array<Object>>} 未结束打包任务列表(raw 行)
*/
async listCurrentPackTasks(workbenchId, warehouseId) {
const { ctx } = this;
return await ctx.model.PackTask.findAll({
where: {
workbench_id: workbenchId,
warehouse_id: warehouseId,
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
order: [[ 'id', 'DESC' ]],
raw: true,
});
}
/**
* 组装工作台当前正在打包的波次与订单信息(供 workbench.getWorkbenchInfo 返回)。
* - current_wave:最新一条团购(pack_mode=2)未结束任务对应的波次信息,无则为空对象;
* - current_orders:全部未结束打包任务列表(含发货单号、波次号、任务状态等),无则为空数组。
* 任一环节异常均降级为空对象/空数组,不影响主信息返回。
* @param {number} workbenchId 工作台 ID
* @param {number} warehouseId 仓库 ID
* @return {Promise<{current_wave: Object, current_orders: Array<Object>}>} 当前打包中波次与订单
*/
async buildCurrentPackingInfo(workbenchId, warehouseId) {
const { ctx } = this;
try {
if (!Number.isInteger(workbenchId) || workbenchId <= 0) {
return { current_wave: {}, current_orders: [] };
}
const tasks = await this.listCurrentPackTasks(workbenchId, warehouseId);
if (!tasks || tasks.length === 0) {
return { current_wave: {}, current_orders: [] };
}
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let currentWave = {};
const currentOrders = [];
for (const task of tasks) {
// 按订单ID补齐发货单号(current → dispatch 分表遍历,与 _packOrder 口径一致)
let deliveryOrderCode = '';
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const row = await model.findOne({
where: { id: Number(task.order_id || 0), warehouse_id: warehouseId },
attributes: [ 'delivery_order_code' ],
raw: true,
});
if (row) {
deliveryOrderCode = row.delivery_order_code || '';
break;
}
} catch (_err) { continue; }
}
currentOrders.push({
task_id: task.id,
order_id: task.order_id,
delivery_order_code: deliveryOrderCode,
wave_id: Number(task.wave_id || 0),
wave_no: task.wave_no || '',
pack_mode: Number(task.pack_mode || 1),
status: Number(task.status || 0),
pack_quantity: Number(task.pack_quantity || 0),
operator_text: task.operator_text || '',
start_time: task.start_time,
});
// 团购任务(pack_mode=2)作为当前波次,只取最新一条未结束任务
const isGroup = Number(task.pack_mode) === 2;
if (isGroup && !currentWave.task_id && Number(task.wave_id) > 0) {
// 订单数与商品总件数并行统计(各自带 15s 短 TTL 缓存,缓存命中后几乎零开销)
const [ orderCount, itemsTotal ] = await Promise.all([
this._countWaveOrdersCached(warehouseId, Number(task.wave_id)),
this._sumWaveItemsTotalCached(warehouseId, Number(task.wave_id)),
]);
currentWave = {
task_id: task.id,
wave_id: Number(task.wave_id),
wave_no: task.wave_no || '',
status: Number(task.status || 0),
order_count: orderCount,
items_total: itemsTotal,
operator_text: task.operator_text || '',
start_time: task.start_time,
};
}
}
return { current_wave: currentWave, current_orders: currentOrders };
} catch (err) {
ctx.logger.warn('[Workbench.buildCurrentPackingInfo] 查询当前打包信息失败,降级为空: %s', err.message);
return { current_wave: {}, current_orders: [] };
}
}
/**
* 按工作台 ID 失效 token 信息缓存(workbench:token:{token})。
* packOrder/finishPack 打包状态变更后调用,保证 getWorkbenchInfo 尽快返回最新打包中信息;
* 工作台未绑定 token 或缓存删除失败时静默降级,不影响主流程。
* @param {number} workbenchId 工作台 ID
* @return {Promise<void>}
*/
async invalidateWorkbenchTokenCacheByWorkbenchId(workbenchId) {
const { ctx, app } = this;
if (!Number.isInteger(workbenchId) || workbenchId <= 0) return;
try {
const wb = await ctx.model.Workbench.findByPk(workbenchId, {
attributes: [ 'token' ],
raw: true,
});
const token = wb && typeof wb.token === 'string' ? wb.token : '';
if (token) {
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(token));
ctx.logger.info('[Workbench.invalidateWorkbenchTokenCacheByWorkbenchId] 打包状态变更,已失效工作台 token 缓存 workbenchId=%d', workbenchId);
}
} catch (err) {
ctx.logger.warn('[Workbench.invalidateWorkbenchTokenCacheByWorkbenchId] 失效工作台 token 缓存失败 workbenchId=%d err=%s', workbenchId, err.message);
}
}
/**
* 组装工作台 token 缓存/接口完整信息:主表字段 + 未软删除的成员列表 + 当前正在打包的波次/订单。
* 成员查询失败时降级为空数组,打包信息查询失败时降级为空对象/空数组,均不影响主表信息返回。
* @param {Object} record 工作台记录(模型实例或普通对象)
* @return {Promise<Object>} 对外信息(含 members 成员列表、current_wave 当前波次、current_orders 当前打包订单)
*/
async buildWorkbenchTokenInfo(record) {
const { app } = this;
const info = this.formatWorkbenchTokenInfo(record);
let members = [];
try {
members = await this.listWorkbenchMembers(info.id);
} catch (memberErr) {
app.coreLogger.warn(`查询工作台成员失败: ${memberErr.message}`);
}
// 当前正在打包的波次与订单信息(内部已做异常降级,不抛错)
const packing = await this.buildCurrentPackingInfo(info.id, Number(info.warehouse_id || 0));
return {
...info,
members,
...packing,
};
}
/**
* 绑定工作台:校验缓存绑定码 + 工作台归属后写入随机 token(供 workbench.bind)。
* - 成功后在 wms_workbench.token 写入随机生成的 token;
* - 写入 token 时同步更新 token_updated_at,供 token 超期强制下线定时任务判定;
* - 若工作台已有 token,删除旧 workbench:token:{token} 缓存;
* - 写入新 token 信息缓存(含成员列表 members),供 workbench.getWorkbenchInfo 返回;
* - 更新绑定会话状态为 bound,供 index.getWorkbenchBindCode 长轮询返回 token。
* @param {Object} data - { code, id }
* @return {Promise<Object>} { success, code, data, message }
@ -2109,12 +2371,12 @@ class WorkbenchService extends Service {
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(oldToken));
}
await record.update({ token: newToken });
await record.update({ token: newToken, token_updated_at: new Date() });
// 写入 token → 工作台信息缓存。
// 写入 token → 工作台信息缓存(含成员列表)。
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(newToken),
this.formatWorkbenchTokenInfo(record),
await this.buildWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
@ -2152,50 +2414,30 @@ class WorkbenchService extends Service {
/**
* 通过 token 获取工作台信息(供 workbench.getWorkbenchInfo)。
* 先查缓存 workbench:token:{token},未命中则查库并回填缓存;查无信息返回失败(403)。
* 统一走 resolveWorkbenchContext 校验:无 token 返回失败(401)、token 无效返回失败(403);
* 缓存优先(workbench:token:{token}),未命中查库并回填缓存;
* 缓存与返回数据均包含未软删除成员列表 members 与当前打包信息。
* @param {Object} [data={}] - { token }
* @return {Promise<Object>} { success, code, data, message }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
async getWorkbenchInfoByToken(data = {}) {
const { ctx, app } = this;
const { app } = this;
try {
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
if (!rawToken) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: 'token 不能为空',
};
}
const tokenCacheKey = this.getWorkbenchTokenCacheKey(rawToken);
let cached = null;
try {
cached = await app.getCacheAsync(tokenCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台 token 缓存失败: ${cacheErr.message}`);
}
if (cached) {
return { success: true, code: 200, data: cached, message: 'ok' };
}
// 统一 token 校验(无 token 401、无效 403),解析成功后写入 ctx 备用
const resolved = await this.resolveWorkbenchContext(rawToken);
if (!resolved.success) return resolved;
const record = await ctx.model.Workbench.findOne({
where: { token: rawToken },
});
if (!record) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台不存在或 token 无效',
};
// 缓存优先:命中直接返回(含 members 与当前打包信息),未命中基于记录组装并回填
const info = resolved.cached || await this.buildWorkbenchTokenInfo(resolved.data);
if (!resolved.cached && info) {
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(rawToken),
info,
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
}
const info = this.formatWorkbenchTokenInfo(record);
await app.setCacheAsync(tokenCacheKey, info, WORKBENCH_TOKEN_CACHE_TTL_SECONDS);
return { success: true, code: 200, data: info, message: 'ok' };
} catch (error) {
app.coreLogger.error(`通过 token 获取工作台信息失败: ${error.message}`);
@ -2211,7 +2453,9 @@ class WorkbenchService extends Service {
/**
* 通过 login_code 获取工作台 token(供 index.LoginWorkbenchByCode)。
* 按 wms_workbench.login_code 查询;查无工作台返回失败(403);
* 工作台尚无 token 时自动生成并持久化(等价于补绑定)。
* 工作台尚无 token 时自动生成并持久化(等价于补绑定),
* 生成并持久化 token 时同步更新 token_updated_at,供 token 超期强制下线定时任务判定。
* 回填的 token 信息缓存包含成员列表 members。
* @param {Object} [data={}] - { loginCode | login_code }
* @return {Promise<Object>} { success, code, data, message }
*/
@ -2247,12 +2491,12 @@ class WorkbenchService extends Service {
let token = typeof record.token === 'string' ? record.token : '';
if (!token) {
token = this.generateWorkbenchToken();
await record.update({ token });
await record.update({ token, token_updated_at: new Date() });
}
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(token),
this.formatWorkbenchTokenInfo(record),
await this.buildWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
@ -2280,12 +2524,17 @@ class WorkbenchService extends Service {
/**
* 重置工作台登录码(供 workbench.resetLoginCode)。
* 重新生成随机 login_code 并写入数据库。
* 重置登录码的同时重置工作台 token:
* - 生成新 login_code 与新 token,一并持久化到 wms_workbench(旧 login_code 随即失效),
* 持久化新 token 时同步更新 token_updated_at,供 token 超期强制下线定时任务判定;
* - 删除旧 workbench:token:{旧token} 缓存,使旧 token 随即失效;
* - 立即回填新 token 信息缓存(含成员列表),设备端拿到新 token 即可继续工作,
* 回填口径与 bindWorkbench / loginWorkbenchByCode 保持一致。
* @param {number} id - 工作台 ID
* @return {Promise<{id: number, login_code: string}>} 新登录码
* @return {Promise<{id: number, login_code: string, token: string}>} 新登录码与新 token
*/
async resetLoginCode(id) {
const { ctx } = this;
const { ctx, app } = this;
const warehouseId = ctx.user.store_id;
const workbenchId = Number(id);
@ -2301,43 +2550,317 @@ class WorkbenchService extends Service {
}
const loginCode = await this.generateUniqueWorkbenchLoginCode();
await record.update({ login_code: loginCode });
const newToken = this.generateWorkbenchToken();
const oldToken = typeof record.token === 'string' ? record.token : '';
// 先删除旧 token 缓存(旧 token 随即失效),再持久化新 login_code 与新 token
if (oldToken && oldToken !== newToken) {
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(oldToken));
}
await record.update({ login_code: loginCode, token: newToken, token_updated_at: new Date() });
return { id: record.id, login_code: loginCode };
// 立即回填新 token 信息缓存(含成员列表),避免设备端首次请求额外查库
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(newToken),
await this.buildWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
return { id: record.id, login_code: loginCode, token: newToken };
}
/**
* 清理 token 超期未更新的工作台,强制其下线(供 workbench_token_expire 定时任务调用)。
* 判定口径:token 非空(非 NULL/非空串)且 token_updated_at 早于过期时间点;
* 按 id 升序分批处理(批大小 batchSize),单条失败不影响整批:
* - 置 token=NULL、token_updated_at=NULL(设备下次调用 token 校验返回 403,需用登录码重新登录);
* - 删除对应 workbench:token:{旧token} 缓存,使旧 token 随即失效;
* - 更新时以「id + 旧 token」为条件,避免误清并发重绑产生的新 token。
* @param {Object} [data={}] - { expiredBefore, batchSize }
* @param {Date} [data.expiredBefore] 过期时间点(token_updated_at 早于该时间视为过期)
* @param {number} [data.batchSize=50] 每批处理条数
* @return {Promise<{total_scanned: number, total_cleared: number, total_failed: number}>} 本轮清理汇总
*/
async clearExpiredWorkbenchTokens(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const expiredBefore = data.expiredBefore instanceof Date ? data.expiredBefore : new Date();
const batchSize = Math.min(200, Math.max(1, parseInt(data.batchSize) || 50));
const summary = { total_scanned: 0, total_cleared: 0, total_failed: 0 };
let lastId = 0;
// 按 id 升序分批拉取过期工作台,直至无更多记录
for (;;) {
const rows = await ctx.model.Workbench.findAll({
where: {
id: { [Op.gt]: lastId },
[Op.and]: [
{ token: { [Op.ne]: null } },
{ token: { [Op.ne]: '' } },
],
token_updated_at: { [Op.lt]: expiredBefore },
},
attributes: [ 'id', 'token' ],
order: [[ 'id', 'ASC' ]],
limit: batchSize,
raw: true,
});
if (!rows || rows.length === 0) break;
lastId = Number(rows[rows.length - 1].id);
summary.total_scanned += rows.length;
for (const row of rows) {
const oldToken = typeof row.token === 'string' ? row.token : '';
try {
const affected = await ctx.model.Workbench.update(
{ token: null, token_updated_at: null },
{ where: { id: row.id, token: oldToken } }
);
if (!affected || !affected[0]) {
ctx.logger.warn(`[workbench-token-expire] workbenchId=${row.id} 更新未生效(token 可能已被并发变更),跳过`);
continue;
}
if (oldToken) {
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(oldToken));
}
summary.total_cleared += 1;
ctx.logger.info(`[workbench-token-expire] workbenchId=${row.id} 已清除过期 token,设备下次请求将返回 403 并需重新登录`);
} catch (error) {
summary.total_failed += 1;
ctx.logger.error(`[workbench-token-expire] workbenchId=${row.id} 清除过期 token 失败: ${error.message}`);
}
}
}
return summary;
}
// ==================== 工作台成员(用户登录副表) ====================
/**
* 通过 token 解析工作台记录(缓存优先,未命中查库并回填缓存)。
* @param {string} token 工作台令牌
* @return {Promise<Object|null>} 工作台记录(模型实例),未命中返回 null
* 解析工作台上下文(公共 token 校验入口,供免登录免鉴权的 token 自校验接口复用)。
*
* 校验口径:
* - token 为空/缺失 → 失败(statusCode=401),对外统一返回 401;
* - token 无效/工作台不存在(含软删除)→ 失败(statusCode=403),保持既有口径不变。
*
* 解析成功后写入 ctx 备用(供后续业务方法按仓库限定查询/写入,禁止跨仓库操作):
* - ctx.workbenchToken:trim 后的原始 token;
* - ctx.workbenchId:工作台 ID(number);
* - ctx.workbenchWarehouseId:工作台所属仓库 ID(number)。
*
* 缓存命中与未命中统一走同一出口:缓存命中时仍回库确认工作台存在(防软删除后缓存残留),
* 未命中时查库并回填 token 信息缓存(含成员列表 members)。
*
* @param {string} token 工作台令牌(可为空字符串/undefined)
* @return {Promise<Object>} { success, code, data, cached, message, statusCode }
* success=true 时 data 为工作台记录(模型实例)、cached 为 token 信息缓存(未命中时为回填信息);
* success=false 时 statusCode 为 401/403
*/
async resolveWorkbenchByToken(token) {
async resolveWorkbenchContext(token) {
const { ctx, app } = this;
const tokenCacheKey = this.getWorkbenchTokenCacheKey(token);
const rawToken = typeof token === 'string' ? token.trim() : '';
if (!rawToken) {
return {
success: false,
code: 0,
statusCode: 401,
data: null,
message: '工作台 token 不能为空',
};
}
const tokenCacheKey = this.getWorkbenchTokenCacheKey(rawToken);
let cached = null;
try {
const cached = await app.getCacheAsync(tokenCacheKey);
if (cached && cached.id) {
return await ctx.model.Workbench.findOne({
where: { id: cached.id },
});
}
cached = await app.getCacheAsync(tokenCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台 token 缓存失败: ${cacheErr.message}`);
}
const record = await ctx.model.Workbench.findOne({
where: { token },
});
if (record) {
await app.setCacheAsync(
tokenCacheKey,
this.formatWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
let record = null;
if (cached && cached.id) {
record = await ctx.model.Workbench.findOne({
where: { id: cached.id },
});
}
return record;
if (!record) {
record = await ctx.model.Workbench.findOne({
where: { token: rawToken },
});
if (record) {
// 缓存未命中:查库成功后回填 token 信息缓存(含成员列表 members)
cached = await this.buildWorkbenchTokenInfo(record);
await app.setCacheAsync(tokenCacheKey, cached, WORKBENCH_TOKEN_CACHE_TTL_SECONDS);
}
}
if (!record) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台不存在或 token 无效',
};
}
// 写入上下文备用:后续业务方法按仓库限定查询,禁止跨仓库操作
ctx.workbenchToken = rawToken;
ctx.workbenchId = Number(record.id);
ctx.workbenchWarehouseId = Number(record.warehouse_id || 0);
return {
success: true,
code: 200,
data: record,
cached,
message: 'ok',
};
}
/**
* 通过 token 解析工作台记录(缓存优先,未命中查库并回填缓存)。
* 基于 resolveWorkbenchContext 实现:无 token 时返回 null(统一 401 口径由调用方处理)。
* 回填的 token 信息缓存包含成员列表 members。
* @param {string} token 工作台令牌
* @return {Promise<Object|null>} 工作台记录(模型实例),未命中返回 null
*/
async resolveWorkbenchByToken(token) {
const resolved = await this.resolveWorkbenchContext(token);
return resolved && resolved.success ? resolved.data : null;
}
/**
* 工作台打包上报(供 workbench.packOrder,免登录免鉴权,以工作台 token 鉴权)。
* warehouse_id/workbench_id 均由 token 解析出的工作台上下文注入,禁止前端传入,
* 防止跨仓库/跨工作台写数据;其余入参与 business(packOrder) 分支一致。
* 打包状态变更后由 _packOrder 内部主动失效 token 缓存,保证 getWorkbenchInfo 及时返回最新信息。
* @param {Object} [data={}] - {
* token, delivery_order_code, wave_no, status, pack_time,
* wave_total_orders, items_count, items_total, users
* }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _packOrder 返回的任务信息;失败时 statusCode 为 401/403
*/
async packOrderByToken(data = {}) {
const { ctx } = this;
const { token, ...packParams } = data || {};
const resolved = await this.resolveWorkbenchContext(token);
if (!resolved.success) return resolved;
const warehouseId = ctx.workbenchWarehouseId;
if (!warehouseId) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台未绑定有效仓库',
};
}
const result = await this._packOrder({
...packParams,
warehouse_id: warehouseId,
workbench_id: ctx.workbenchId,
});
return { success: true, code: 200, data: result, message: 'ok' };
}
/**
* 工作台打包完成(供 workbench.finishPack,免登录免鉴权,以工作台 token 鉴权)。
* warehouse_id/workbench_id 均由 token 解析出的工作台上下文注入,禁止前端传入。
* 任务结束后由 _finishPack 内部主动失效 token 缓存,保证 getWorkbenchInfo 及时返回最新信息。
* @param {Object} [data={}] - { token }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _finishPack 返回的完成信息;失败时 statusCode 为 401/403
*/
async finishPackByToken(data = {}) {
const { ctx } = this;
const { token } = data || {};
const resolved = await this.resolveWorkbenchContext(token);
if (!resolved.success) return resolved;
const warehouseId = ctx.workbenchWarehouseId;
if (!warehouseId) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台未绑定有效仓库',
};
}
const result = await this._finishPack({
workbench_id: ctx.workbenchId,
warehouse_id: warehouseId,
});
return { success: true, code: 200, data: result, message: 'ok' };
}
/**
* 工作台称重上报(供 workbench.sendWeight,免登录免鉴权,以工作台 token 鉴权)。
* warehouse_id 由 token 解析出的工作台上下文注入,禁止前端传入;
* 其余入参与 business(sendWeight) 分支一致,重量单位为克。
* @param {Object} [data={}] - { token, barcode, weight }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _sendWeight 返回的称重结果(weighing_weight/total_weight 单位 g);
* 失败时 statusCode 为 401/403
*/
async sendWeightByToken(data = {}) {
const { ctx } = this;
const { token, barcode, weight } = data || {};
const resolved = await this.resolveWorkbenchContext(token);
if (!resolved.success) return resolved;
const warehouseId = ctx.workbenchWarehouseId;
if (!warehouseId) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台未绑定有效仓库',
};
}
const result = await this._sendWeight({ barcode, weight, warehouseId });
return { success: true, code: 200, data: result, message: 'ok' };
}
/**
* 条码查询订单(供 workbench.queryOrder,免登录免鉴权,以工作台 token 鉴权)。
* warehouse_id 由 token 解析出的工作台上下文注入,禁止前端传入,
* 防止跨仓库查单;body 传入的 warehouse_id/workbench_id 一律忽略。
* 只读查询,不涉及缓存失效;其余入参与 business(queryOrder) 分支一致。
* @param {Object} [data={}] - { token, barcode }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _queryOrder 返回的条码查询订单结果;失败时 statusCode 为 401/403
*/
async queryOrderByToken(data = {}) {
const { ctx } = this;
const { token, barcode } = data || {};
const resolved = await this.resolveWorkbenchContext(token);
if (!resolved.success) return resolved;
const warehouseId = ctx.workbenchWarehouseId;
if (!warehouseId) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台未绑定有效仓库',
};
}
const result = await this._queryOrder({ barcode, warehouseId });
return { success: true, code: 200, data: result, message: 'ok' };
}
/**
@ -2362,23 +2885,19 @@ class WorkbenchService extends Service {
/**
* 移除工作台成员(供 workbench.removeMember,免登录免鉴权,以工作台 token 鉴权)。
* 按 token 解析工作台后,仅删除归属于该工作台的成员行(软删除)。
* 统一走 resolveWorkbenchContext 校验:无 token 返回失败(401)、token 无效返回失败(403);
* 解析成功后仅删除归属于该工作台的成员行(软删除),
* 并清除对应 token 信息缓存,保证接口尽快返回最新成员。
* @param {Object} [data={}] - { ids, token }
* @return {Promise<Object>} { success, code, data, message }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
async removeWorkbenchMember(data = {}) {
const { ctx, app } = this;
try {
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
if (!rawToken) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '工作台 token 不能为空',
};
}
// 统一 token 校验(无 token 401、无效 403),解析成功后写入 ctx 备用
const resolved = await this.resolveWorkbenchContext(data.token);
if (!resolved.success) return resolved;
const rawToken = ctx.workbenchToken;
const memberIds = this.normalizeWorkbenchMemberIds(data.ids ?? data.memberIds ?? data.member_ids);
if (memberIds.length === 0) {
@ -2391,16 +2910,7 @@ class WorkbenchService extends Service {
};
}
const workbench = await this.resolveWorkbenchByToken(rawToken);
if (!workbench) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台不存在或 token 无效',
};
}
const workbench = resolved.data;
const rows = await ctx.model.WorkbenchMember.findAll({
where: { id: memberIds, workbench_id: workbench.id },
@ -2421,6 +2931,9 @@ class WorkbenchService extends Service {
where: { id: matchedIds, workbench_id: workbench.id },
});
// 成员变更后清除 token 信息缓存,下次获取工作台信息立即反映最新成员。
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(rawToken));
return {
success: true,
code: 200,
@ -2443,23 +2956,19 @@ class WorkbenchService extends Service {
/**
* 绑定工作台成员(供 workbench.bindMember,免登录免鉴权,以工作台 token 鉴权)。
* 入参用户ID(可空,兼容非系统账号用户)+ 姓名(必填)+ 工作台 token。
* 统一走 resolveWorkbenchContext 校验:无 token 返回失败(401)、token 无效返回失败(403);
* 入参用户ID(可空,兼容非系统账号用户)+ 姓名(必填)+ 工作台 token;
* 绑定成功后清除对应 token 信息缓存,保证接口尽快返回最新成员。
* @param {Object} [data={}] - { userId | user_id, userName | user_name | name, token }
* @return {Promise<Object>} { success, code, data, message }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
async bindWorkbenchMember(data = {}) {
const { ctx, app } = this;
try {
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
if (!rawToken) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '工作台 token 不能为空',
};
}
// 统一 token 校验(无 token 401、无效 403),解析成功后写入 ctx 备用
const resolved = await this.resolveWorkbenchContext(data.token);
if (!resolved.success) return resolved;
const rawToken = ctx.workbenchToken;
const rawUserName = typeof data.userName === 'string'
? data.userName
@ -2491,16 +3000,7 @@ class WorkbenchService extends Service {
};
}
const workbench = await this.resolveWorkbenchByToken(rawToken);
if (!workbench) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台不存在或 token 无效',
};
}
const workbench = resolved.data;
const member = await ctx.model.WorkbenchMember.create({
workbench_id: workbench.id,
@ -2508,6 +3008,9 @@ class WorkbenchService extends Service {
user_name: userName,
});
// 成员变更后清除 token 信息缓存,下次获取工作台信息立即反映最新成员。
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(rawToken));
return {
success: true,
code: 200,

View File

@ -226,6 +226,16 @@ module.exports = appInfo => {
batchSize: 50,
force: false,
};
// 工作台 token 超期强制下线定时任务配置
config.workbenchTokenExpire = {
enable: true,
// 扫描间隔(毫秒),默认每小时扫描一次;开发环境可在 config.local.js 覆盖为短循环
scanIntervalMs: 60 * 60 * 1000,
// token 有效期阈值(毫秒):token_updated_at 距今超过该时长则强制下线(默认 3 个月,按 30 天/月折算)
maxAgeMs: 3 * 30 * 24 * 60 * 60 * 1000,
// 单轮批处理大小(按 id 升序分批)
batchSize: 50,
};
// 打印自定义区模板出口域名
config.customAreaBaseUrl = 'https://api.ye4s.com';

View File

@ -0,0 +1,129 @@
'use strict';
/**
* 存量订单治理:单品单件散单波次订单回填 wave_scope = 4。
*
* 口径(与代码写入逻辑 resolveWaveScopeByWaveMeta 一致):
* - 订单 wave_id > 0;
* - 波次 wms_wave_batch.wave_type = 2(散单);
* - 该波次最新拣货任务 pick_mode = 2(单品单件,1-小团购 2-单品单件 3-先拣后分 4-边拣边分 5-大团购)。
*
* pick_mode 取“每波次最新任务”:wms_wave_pick_task(wave_id 直连)与
* wms_wave_pick_task_wave(任务-波次关联)两个来源取 id 最大的一条。
* MySQL 5.7 兼容(不使用窗口函数)。
*
* 覆盖范围:基表 wms_order_delivery 与全部仓库分表(current/history/dispatch/outsourced)。
* 幂等:按条件覆盖写入,重复执行结果一致。
*/
const BASE_TABLE = 'wms_order_delivery';
const SHARD_PATTERN = /^wms_order_delivery_(\d+)(?:_(history|dispatch|outsourced))?$/;
/** 每波次最新拣货任务的 pick_mode 派生表 SQL(两个来源取 id 最大,DISTINCT 去重防止直连/关联重复行放大) */
const LATEST_PICK_MODE_SQL = `
SELECT u2.wave_id, u2.pick_mode
FROM (
SELECT DISTINCT wave_id, pick_mode, id
FROM (
SELECT wave_id, pick_mode, id FROM wms_wave_pick_task
UNION ALL
SELECT tw.wave_id, t.pick_mode, t.id
FROM wms_wave_pick_task_wave tw
JOIN wms_wave_pick_task t ON t.id = tw.task_id
) u
) u2
JOIN (
SELECT wave_id, MAX(id) AS max_id
FROM (
SELECT wave_id, id FROM wms_wave_pick_task
UNION ALL
SELECT tw.wave_id, t.id
FROM wms_wave_pick_task_wave tw
JOIN wms_wave_pick_task t ON t.id = tw.task_id
) v
GROUP BY wave_id
) latest ON latest.wave_id = u2.wave_id AND latest.max_id = u2.id
`;
/**
* 列举库内全部订单分表。
* @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 {*} updateResult query 返回结果。
* @return {number} 受影响行数。
*/
function extractAffectedRows(updateResult) {
if (Array.isArray(updateResult)) {
const meta = updateResult[1];
return Number(meta && (meta.affectedRows || meta.affectedCount || meta.rowCount) || 0);
}
if (updateResult && typeof updateResult === 'object') {
return Number(updateResult.affectedRows || updateResult.affectedCount || updateResult.rowCount || 0);
}
return 0;
}
module.exports = {
/**
* 执行迁移:单品单件散单波次订单 wave_scope 置为 4。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
async up(queryInterface) {
const tables = [ BASE_TABLE, ...await listOrderShards(queryInterface) ];
const results = [];
for (const tableName of tables) {
const updateResult = await queryInterface.sequelize.query(`
UPDATE \`${tableName}\` o
JOIN wms_wave_batch wb ON wb.wave_id = o.wave_id
JOIN (
${LATEST_PICK_MODE_SQL}
) pm ON pm.wave_id = o.wave_id
SET o.wave_scope = 4
WHERE o.wave_id > 0
AND wb.wave_type = 2
AND pm.pick_mode = 2
`);
results.push({ tableName, affectedRows: extractAffectedRows(updateResult) });
}
console.log('[20260906100000-backfill-order-wave-scope-single] up results:', JSON.stringify(results));
},
/**
* 回滚迁移:单品单件(wave_scope=4)订单回置为散单(2)。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
async down(queryInterface) {
const tables = [ BASE_TABLE, ...await listOrderShards(queryInterface) ];
const results = [];
for (const tableName of tables) {
const updateResult = await queryInterface.sequelize.query(`
UPDATE \`${tableName}\`
SET wave_scope = 2
WHERE wave_scope = 4
`);
results.push({ tableName, affectedRows: extractAffectedRows(updateResult) });
}
console.log('[20260906100000-backfill-order-wave-scope-single] down results:', JSON.stringify(results));
},
};

View File

@ -0,0 +1,63 @@
'use strict';
const TABLE_NAME = 'wms_workbench';
/**
* Migration: add token_updated_at to wms_workbench
* - token_updated_at: DATETIME NULL,记录工作台 token 最后更新时间。
*
* 背景:定时任务将扫描工作台,若 token 超过 3 个月未更新则强制清除 token 使设备下线,
* 因此需要记录每个工作台 token 的最后更新时间。
*
* 回填策略:
* - 有 token 的行:token_updated_at = updated_at。token 列由 20260903100000 迁移新增,
* 绑定/刷新 token 时同步更新 updated_at,取 updated_at 是当前最接近「token 最后变更」的时间;
* - 无 token 的行:保持 NULL(从未绑定 token,不参与过期扫描)。
* - 回填语句同时显式赋值 updated_at = updated_at:表结构上 updated_at 带
* ON UPDATE CURRENT_TIMESTAMP,显式赋值可阻止其被回填动作顶替为迁移执行时间。
*
* Idempotent: 通过 describeTable 判断后仅补齐缺失部分,回填按幂等条件覆盖。
*/
module.exports = {
/**
* 执行正向迁移:新增 token_updated_at 列并回填存量数据。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {import('sequelize')} Sequelize Sequelize 实例。
* @return {Promise<void>} 无返回值。
*/
up: async (queryInterface, Sequelize) => {
const columns = await queryInterface.describeTable(TABLE_NAME);
if (!columns.token_updated_at) {
await queryInterface.addColumn(TABLE_NAME, 'token_updated_at', {
type: Sequelize.DATE,
allowNull: true,
comment: '工作台 token 最后更新时间(无 token 时为 NULL)',
});
console.log('[token_updated_at] 列已新增');
} else {
console.log('[token_updated_at] 列已存在,跳过新增');
}
const result = await queryInterface.sequelize.query(
`UPDATE ${TABLE_NAME} SET token_updated_at = updated_at, updated_at = updated_at WHERE (token IS NOT NULL AND token != '') AND token_updated_at IS NULL`
);
const affected = Array.isArray(result)
? Number((result[1] && (result[1].affectedRows || result[1].affectedCount || result[1].rowCount)) || 0)
: Number((result && (result.affectedRows || result.affectedCount || result.rowCount)) || 0);
console.log(`[token_updated_at] 回填完成,影响行数: ${affected}`);
},
/**
* 执行回滚迁移:删除 token_updated_at 列(回填数据随之删除)。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
down: async queryInterface => {
const columns = await queryInterface.describeTable(TABLE_NAME);
if (columns.token_updated_at) {
await queryInterface.removeColumn(TABLE_NAME, 'token_updated_at');
console.log('[token_updated_at] 列已删除');
}
},
};

View File

@ -0,0 +1,106 @@
'use strict';
/**
* 订单表增加 intercept_time(拦截时间)字段。
*
* 背景:订单表当前仅维护 intercept_status 状态机,无拦截发生时间点;
* 业务需要直接记录订单进入拦截流程/库内拦截确认的时间,避免依赖
* 操作日志/售后工单反查。新增本列用于拦截时间直查。
*
* 取值约定:DATETIME,可空;订单未进入拦截流程时为 NULL,
* 拦截状态发生关键变更(拦截发起/库内拦截确认)时由业务写入。
*
* 覆盖范围:
* - 基表 wms_order_delivery;
* - 全部仓库分表 wms_order_delivery_{wh}(current)及
* _{wh}_history / _{wh}_dispatch / _{wh}_outsourced。
*
* 幂等:列已存在则跳过。分表模型由 app/model/order_delivery_factory.js
* 运行时 drift 同步兜底,本迁移提前补齐避免运行时 ALTER。
*/
const BASE_TABLE = 'wms_order_delivery';
const SHARD_PATTERN = /^wms_order_delivery_(\d+)(?:_(history|dispatch|outsourced))?$/;
const COLUMN_NAME = 'intercept_time';
/**
* 列举库内全部订单分表。
* @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 = {
/**
* 执行迁移:为基表与全部分表增加 intercept_time 列。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @param {import('sequelize')} Sequelize Sequelize 构造器。
* @return {Promise<void>} 无返回值。
*/
async up(queryInterface, Sequelize) {
const tables = [ BASE_TABLE, ...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.DATE,
allowNull: true,
defaultValue: null,
comment: '拦截时间(进入拦截流程/库内拦截确认时写入)',
});
results.push({ tableName, action: 'added' });
}
console.log('[20260907100000-add-intercept-time-to-order-delivery] up results:', JSON.stringify(results));
},
/**
* 回滚迁移:移除基表与全部分表的 intercept_time 列。
* @param {import('sequelize').QueryInterface} queryInterface 查询接口。
* @return {Promise<void>} 无返回值。
*/
async down(queryInterface) {
const tables = [ BASE_TABLE, ...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('[20260907100000-add-intercept-time-to-order-delivery] down results:', JSON.stringify(results));
},
};

View File

@ -1,4 +1,179 @@
[
{
"version": "2026.09.06-workbench-resetLoginCode-reset-token",
"date": "2026-09-06",
"type": "changed",
"summary": "workbench.resetLoginCode 行为变更:重置登录码时同步重置工作台 token。生成新 64 位 hex token 与 login_code 一并持久化到 wms_workbench(record.update({ login_code, token }));更新库前先删除旧 workbench:token:{旧token} 缓存,旧 token 随即失效;立即回填新 token 信息缓存(复用 buildWorkbenchTokenInfo,含 members/current_wave/current_orders,TTL 300s);返回值新增 token 字段 { id, login_code, token },出口层展开后响应顶层含 id、login_code、token;旧行为「token 不变」相关描述已更新。旧 token 失效后旧会话返回 403,设备端需用新 token 继续工作。",
"methods": [
"workbench.resetLoginCode"
],
"notes": [
"app/service/systems/workbench.js:resetLoginCode(id) 同步重置 token:generateUniqueWorkbenchLoginCode 生成新 login_code、generateWorkbenchToken 生成新 64 位 hex token,先 delCacheAsync 删除旧 workbench:token:{旧token} 缓存(旧 token 随即失效),再 record.update({ login_code, token }) 一并持久化,随后 setCacheAsync 立即回填新 token 信息缓存(buildWorkbenchTokenInfo,含 members/current_wave/current_orders,TTL 300s),返回 { id, login_code, token }",
"app/service/systemMethods/workbench.js:resetLoginCode 薄出口 this.success('重置成功', result) 展开后响应顶层含 id、login_code、token(原仅 id/login_code,本次新增 token)",
"methods/system.json:workbench.resetLoginCode 条目 description 更新(说明 login_code 与 token 同步重置、旧 token 缓存删除使旧 token 随即失效、立即回填新 token 缓存),response 新增 token 字段(string,64 位 hex,必返回),errors 补充 403 备注(旧 token 失效后旧会话返回 403,设备端需用新 token 继续工作);版本 0.3.92 -> 0.3.93(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md:路由与方法清单无变化(5.3 节映射表与函数清单均未涉及行为描述),无需同步",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-workbench-queryOrder",
"date": "2026-09-06",
"type": "changed",
"summary": "工作台模块新增免登录/免权限/免鉴权的 token 自校验只读接口 workbench.queryOrder(条码查询订单):入参 token(必填)+ barcode(必填),仓库与工作台均由服务端从 token 解析注入(body 传入 warehouse_id/workbench_id 一律忽略,禁止前端传值,防止跨仓库查单);响应 data 与 business(queryOrder) 分支一致(barcode/waybill_code/isSandan/store_remark/express/order/items/source_table,散单 order 附 intercept_flag/pack_flag 0/1 标志、团购附 batch 波次总量信息);只读查询不涉及缓存失效;错误码沿用统一口径:无 token 401、token 无效 403、工作台未绑定有效仓库 403,条码为空/未找到运单/未找到订单为业务失败(flag=failure、code=0)。",
"methods": [
"workbench.queryOrder"
],
"notes": [
"app/service/systemMethods/workbench.js:新增 queryOrder 薄出口(调用业务层 queryOrderByToken),systemInit 免登录/免权限/免鉴权白名单均已包含 queryOrder(未声明免日志,保留系统日志)",
"app/service/systems/workbench.js:新增 queryOrderByToken(data):走 resolveWorkbenchContext(token) 统一 token 校验(无 token 401、token 无效 403),解析成功后从 ctx.workbenchWarehouseId 注入仓库(工作台未绑定有效仓库返回 403),复用 _queryOrder 业务实现;只读查询,不涉及缓存失效",
"methods/system.json:工作台模块新增 workbench.queryOrder 条目(isNeedAuth=false、isNeedLogin=false、isNeedRight=false,入参仅 token/barcode,description 说明 warehouse_id/workbench_id 由服务端注入);版本 0.3.91 -> 0.3.92(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md 5.3 节新增 queryOrder 映射行与接口说明;本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-workbench-pack-order-finish-pack-send-weight",
"date": "2026-09-06",
"type": "changed",
"summary": "工作台模块新增 3 个免登录/免权限/免鉴权的 token 自校验接口 workbench.packOrder(打包上报)、workbench.finishPack(打包完成)、workbench.sendWeight(称重上报,重量单位克),并统一公共 token 校验口径:新增 resolveWorkbenchContext(token) 公共校验方法(解析成功写入 ctx.workbenchToken/ctx.workbenchId/ctx.workbenchWarehouseId),无 token 统一返回 code=401(消息「工作台 token 不能为空」)、token 无效/工作台不存在保持 403;受影响的 workbench.getWorkbenchInfo/workbench.bindMember/workbench.removeMember 三个接口「无 token」错误码由 400 调整为 401,bindMember/removeMember 校验顺序变为 token 优先(token 无效且参数缺失的边界场景由 400 变 403)。",
"methods": [
"workbench.packOrder",
"workbench.finishPack",
"workbench.sendWeight",
"workbench.getWorkbenchInfo",
"workbench.bindMember",
"workbench.removeMember"
],
"notes": [
"app/service/systemMethods/workbench.js:新增 packOrder/finishPack/sendWeight 三个薄出口(调用业务层 packOrderByToken/finishPackByToken/sendWeightByToken),systemInit 免登录/免权限/免鉴权白名单均已包含三个方法(未声明免日志,保留系统日志)",
"app/service/systems/workbench.js:新增公共 token 校验方法 resolveWorkbenchContext(token):无 token 统一返回 401(消息「工作台 token 不能为空」),token 无效/工作台不存在(含软删除)返回 403(保持原口径);解析成功后写入 ctx.workbenchToken/ctx.workbenchId/ctx.workbenchWarehouseId 供后续方法使用(按仓库限定查询/写入,禁止跨仓库)",
"新增 packOrderByToken/finishPackByToken/sendWeightByToken:仓库/工作台均由 token 解析上下文注入(body 传入 warehouse_id/workbench_id 被忽略),复用 _packOrder/_finishPack/_sendWeight 业务实现;打包/称重状态变更后失效对应工作台 token 缓存,保证 getWorkbenchInfo 及时返回最新信息",
"行为变更:workbench.getWorkbenchInfo/workbench.bindMember/workbench.removeMember 无 token 时错误码由 400 调整为 401;bindMember/removeMember 校验顺序变为 token 优先(token 无效且参数缺失的边界场景由 400 变 403)",
"methods/system.json:工作台模块新增 workbench.packOrder/workbench.finishPack/workbench.sendWeight 三条目(isNeedAuth=false、isNeedLogin=false、isNeedRight=false),并更新 workbench.getWorkbenchInfo/workbench.bindMember/workbench.removeMember 错误码(400→401);版本 0.3.90 -> 0.3.91(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md 5.3 节新增三个接口映射行与 401 口径说明;本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-workbench-getWorkbenchInfo-wave-items-total",
"date": "2026-09-06",
"type": "changed",
"summary": "workbench.getWorkbenchInfo 响应 data.current_wave 新增 items_total 字段(number):波次商品总件数,口径为商品总件数(非 SKU 品种数),来源为订单分表 wms_order_delivery_{仓库}_{current/dispatch} 的 items_total 列按 wave_id+warehouse_id 求和(与既有 order_count 同款分表口径),带 15s 短缓存兜底;current_wave 其余字段(task_id/wave_id/wave_no/status/order_count/operator_text/start_time)不变,无团购任务时 current_wave 仍为空对象;items_total 随 token 缓存 workbench:token:{token}(TTL 300s)一并缓存,packOrder/finishPack 打包状态变更后主动失效缓存,下一次调用即返回最新数据。",
"methods": [
"workbench.getWorkbenchInfo"
],
"notes": [
"app/service/systems/workbench.js:新增 _sumWaveItemsTotal(并发遍历 current+dispatch 分表 SUM(items_total),按 wave_id+warehouse_id 过滤,单表失败按 0 处理)与 _sumWaveItemsTotalCached(cache:workbench:wave_items_total:{warehouseId}:{waveId},TTL 15s,缓存不可用降级实时统计);buildCurrentPackingInfo 组装 current_wave 时通过 Promise.all 并行统计 order_count 与 items_total,current_wave 新增 items_total 字段",
"getWorkbenchInfoByToken 缓存优先(workbench:token:{token},TTL 300s),缓存值已包含 items_total;_packOrder/_finishPack 打包状态变更后调用 invalidateWorkbenchTokenCacheByWorkbenchId 删除 token 缓存,保证下一次 getWorkbenchInfo 返回最新打包信息",
"methods/system.json:workbench.getWorkbenchInfo description 与 current_wave 对象描述补充 items_total 说明,response 新增 current_wave.items_total 条目(沿用 current_wave.xxx 嵌套命名惯例);版本 0.3.89 -> 0.3.90(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md 5.3 节接口文档行追加本变更记录版本号,当前打包信息行补充 items_total 口径;AI_TOOLBOX.md 无 workbench 相关内容,无需同步",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-workbench-getWorkbenchInfo-current-packing",
"date": "2026-09-06",
"type": "changed",
"summary": "workbench.getWorkbenchInfo 响应 data 新增当前正在打包的波次与订单信息:current_wave(当前正在打包的团购波次:wms_pack_task 中 pack_mode=2 且 wave_id>0 的最新一条未结束任务(status<2)组装,无团购任务时为空对象,含 task_id/wave_id/wave_no/status/order_count/operator_text/start_time,order_count 为 15s 短缓存实时计数)与 current_orders(当前正在打包的订单数组:全部未结束任务按 id 倒序,逐单按 current→dispatch 分表补发货单号,无进行中任务时为空数组,每项含 task_id/order_id/delivery_order_code/wave_id/wave_no/pack_mode/status/pack_quantity/operator_text/start_time);打包信息随 token 缓存 workbench:token:{token}(TTL 300s)一并缓存,packOrder/finishPack 打包状态变更后主动失效缓存,下一次调用即返回最新数据;打包信息查询异常时降级(current_wave 空对象、current_orders 空数组),不影响主信息与 members。",
"methods": [
"workbench.getWorkbenchInfo"
],
"notes": [
"app/service/systems/workbench.js:新增 listCurrentPackTasks(wms_pack_task 按 workbench_id/warehouse_id 过滤 status<2(0=待处理/1=打包中),按 id 倒序)与 buildCurrentPackingInfo(组装 current_wave/current_orders:逐单按 current→dispatch 分表补 delivery_order_code;current_wave 取最新一条 pack_mode=2 且 wave_id>0 的未结束任务,order_count 走 _countWaveOrdersCached 实时计数 + 15s 短缓存;任一环节异常降级为空对象/空数组);buildWorkbenchTokenInfo 统一组装主表字段 + members + 打包信息",
"getWorkbenchInfoByToken 缓存优先(workbench:token:{token},TTL 300s),缓存值同样含打包信息;_packOrder/_finishPack(workbench.business packOrder/finishPack 调度)打包状态变更后调用 invalidateWorkbenchTokenCacheByWorkbenchId 删除 token 缓存,保证下一次 getWorkbenchInfo 返回最新打包中信息",
"methods/system.json:workbench.getWorkbenchInfo description 补充 current_wave/current_orders 与缓存失效行为说明,response 新增 current_wave/current_wave.* 与 current_orders/current_orders[].* 条目;版本 0.3.88 -> 0.3.89(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md 5.3 节接口文档行追加本变更记录版本号;AI_TOOLBOX.md 无 workbench 相关内容,无需同步",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-workbench-getWorkbenchInfo-members",
"date": "2026-09-06",
"type": "changed",
"summary": "workbench.getWorkbenchInfo 响应 data 新增 members 成员数组:成员来自副表 wms_workbench_member 未软删除记录(按 id ASC),元素含 id/user_id/user_name(轻量结构);接口 token 缓存 workbench:token:{token}(TTL 300s)缓存值已包含 members,绑定/移除成员后缓存立即失效,下一次调用即返回最新成员;主表字段与不含 token/login_code 口径不变。",
"methods": [
"workbench.getWorkbenchInfo"
],
"notes": [
"app/service/systems/workbench.js:buildWorkbenchTokenInfo 统一组装主表字段(formatWorkbenchTokenInfo:id/warehouse_id/name/status/type/remark/device_ids/created_at/updated_at,不含 token/login_code)+ members(listWorkbenchMembers 查 wms_workbench_member 未软删除记录,attributes id/user_id/user_name,按 id ASC;查询失败降级空数组)",
"getWorkbenchInfoByToken 缓存优先(workbench:token:{token},TTL 300s)、查库兜底回填缓存;removeWorkbenchMember/bindWorkbenchMember 成功后 delCacheAsync 清除 token 信息缓存,保证下一次调用立即反映最新成员",
"methods/system.json:workbench.getWorkbenchInfo description 补充 members 与缓存行为说明,response 新增 members/members[].id/members[].user_id/members[].user_name 条目;版本 0.3.87 -> 0.3.88(docMeta.version),updatedAt 保持 2026-09-06",
"AI_METHOD_ROUTING.md 5.3 节接口文档行追加本变更记录版本号;AI_TOOLBOX.md 无 workbench 相关内容,无需同步",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "workbench"
},
{
"version": "2026.09.06-index.queryUserByToken",
"date": "2026-09-06",
"type": "added",
"summary": "基础模块新增 index.queryUserByToken:按 ye4s 登录临时码 token 查询用户信息(免登录、免鉴权),命中返回 flag=success、code=200 与 real_name、wms_account_id,未命中返回 code=404 用户不存在,数据库异常返回 code=500。",
"methods": [
"index.queryUserByToken"
],
"notes": [
"app/service/systemMethods/index.js 新增 queryUserByToken:入参 token(ye4s 登录临时码,对应 ye4s 库 ye4s_user 表 tmp_code 字段),为空返回 code 400「token 不能为空」;命中返回 success + real_name(空串兜底)/wms_account_id(null 兜底),未命中返回 code 404「用户不存在」,异常返回 code 500",
"免登录、免鉴权:queryUserByToken 已加入 _noNeedLogin / _noNeedAuth 白名单(systemInit 声明)",
"methods/system.json:基础模块(module=index)新增 index.queryUserByToken 条目(isNeedAuth=false、isNeedLogin=false);版本 0.3.86 -> 0.3.87(docMeta.version),updatedAt 保持 2026-09-06",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "index"
},
{
"version": "2026.09.06-recheckOrder.remove-unprinted-intercepted",
"date": "2026-09-06",
"type": "enhanced",
"summary": "复核链路新增自动清理:更新复核状态后,自动将波次内「已拦截且未打印」的订单移除出波次(回池),拦截解除后可重新抓取发货,避免拦截订单卡死波次完成判定。",
"methods": [
"order.recheckOrder.confirmRecheck",
"order.recheckOrder.batchQuickRecheck",
"order.recheckOrder.batchQuickRecheckByWave"
],
"notes": [
"app/service/systemMethods/order/recheckOrder.js 新增 removeUnprintedInterceptedOrdersFromWave:移除波次内 print_status='none' 且 intercept_status!='none'(空值按 none 处理)的订单(wave_id=0、wave_no/wave_strategy_version/wave_scan_result 清空),调用 wave.deleteOrderWaveIndexByOrderIds 删波次索引,删除 wms_wave_pick_task_order 任务订单关联,回写 wms_wave_batch total_orders/processed_orders 统计,写 ORDER_WAVE_REMOVE 操作日志,并触发 enqueueWaveStrategyQuickScanPostOrderChange 波次策略快扫(拦截未解除时策略仍排除,不会误抓)",
"三个复核入口接入:updateTaskOrderReviewAndTryUnbindCart(confirmRecheck 单订单)、updateTaskOrdersReviewBatch(批量/团购)、_updateTaskOrderReviewInTransaction(batchQuickRecheck/batchQuickRecheckByWave 事务版,清理动作随事务执行并透传事务对象);清理失败仅记录 warn 日志,不影响复核主流程",
"清理先于任务/波次完成判定执行,拦截订单移除后完成判定口径自然收敛,未改动既有完成判定 SQL;清理以 wave_id>0 为条件,幂等可重复触发",
"已打印(print_status!='none')的拦截订单保持不动,避免已贴面单实物与波次记录分离;该类订单仍需人工 wave.batchRemoveOrders 处理",
"单元测试:test/app/service/systemMethods/order/recheckOrder.removeUnprintedIntercepted.test.js(8 用例全通过,ESLint 0/0)"
],
"module": "order.recheckOrder"
},
{
"version": "2026.09.06-stock.report.exportStore-lock-exclusion",
"date": "2026-09-06",
"type": "updated",
"summary": "stock.report.exportStore(货主侧库存报表导出)变更记录口径收紧:变更记录 sheet 只导出出入库流水(INBOUND/OUTBOUND),锁定/解锁(LOCK/UNLOCK)记录一律不导出;export_mode/exportMode 参数对货主侧不再有任何效果(该参数仅仓库侧 stock.report.export 生效)。",
"methods": [
"stock.report.exportStore",
"stock.report.export"
],
"notes": [
"app/service/systems/storage/report.js export():isStoreMode(货主侧)分支固定追加 t.transaction_type NOT IN ('LOCK','UNLOCK'),无视 exportMode;仓库侧维持 export_mode='item' 时含 LOCK、否则排除 LOCK 的既有行为",
"methods/system.json:stock.report.exportStore 移除 export_mode/exportMode 参数条目,method description 补充“变更记录只含出入库流水(LOCK/UNLOCK 不导出)”与“export_mode/exportMode 不支持也不生效”;stock.report.export 的 export_mode 参数描述标注“仅仓库侧接口生效”,method description 补充“仓库侧”;版本 0.3.85 -> 0.3.86(docMeta.version),updatedAt 保持 2026-09-06",
"本次任务仅同步文档,未修改任何业务代码"
],
"module": "stock.report"
},
{
"version": "2026.09.06-order.list.waveScope",
"date": "2026-09-06",
"type": "updated",
"summary": "order.list 订单列表 where 新增 wave_scope 波次范围虚拟筛选字段(订单表 wave_scope 字段直接过滤)",
"methods": [
"order.list"
],
"notes": [
"订单表(wms_order_delivery 与各仓库 current/history/dispatch/outsourced 分表)新增 wave_scope 字段:tinyint NOT NULL DEFAULT 0,取值 0=未分配波次 1=大团购 2=散单 3=小团购 4=单品单件。",
"波次生成写入订单表时同步维护 wave_scope(app/service/systemMethods/order/wave.js resolveWaveScopeByWaveMeta):大团购=wave_type=1&source=0,小团购=wave_type=1&source=2,单品单件=wave_type=2&pickMode=2(策略 batch_mode=1),其余有波次为散单;移出波次重置为 0。",
"order.list / 订单导出 where.wave_scope 直接按订单表 wave_scope 字段过滤(app/service/systemMethods/order/base.js buildWaveScopeFilterCondition),不再反查 wms_wave_batch 波次ID;支持单个值、数组多选与 { operator: in, value: [...] } 结构,非法值(非 0-4 整数)返回 400。",
"数据库迁移:database/migrations/20260905100000-add-wave-scope-to-order-delivery.js(加列)、database/migrations/20260905130000-backfill-order-wave-scope.js(存量按口径回填,幂等)。",
"列表响应 raw 行暂不输出 wave_scope 字段(ORDER_LIST_BASE_ATTRIBUTES 未包含),仅作为筛选条件使用。"
],
"module": "order"
},
{
"version": "2026.09.05-storageTransaction-list-detail",
"date": "2026-09-05",

File diff suppressed because it is too large Load Diff

View File

@ -154,17 +154,18 @@ function main() {
`TARGET_PORT=${targetPort}`,
'PORT_PID=$(ss -tlnp 2>/dev/null | awk -v p=":$TARGET_PORT " \'index($0, p) { print $0 }\' | grep -oP \'pid=\\K[0-9]+\' | head -1 || true)',
'if [ -n "$PORT_PID" ]; then',
` echo "检测到端口 $TARGET_PORT 被进程 $PORT_PID 占用,强制停止..."`,
' kill -9 "$PORT_PID" 2>/dev/null || true',
' sleep 1',
' echo "检测到端口 $TARGET_PORT 被进程 $PORT_PID 占用,发送优雅停止信号..."',
' kill "$PORT_PID" 2>/dev/null || true',
' sleep 30',
' PORT_PID_CHECK=$(ss -tlnp 2>/dev/null | awk -v p=":$TARGET_PORT " \'index($0, p) { print $0 }\' | grep -oP \'pid=\\K[0-9]+\' | head -1 || true)',
' if [ -n "$PORT_PID_CHECK" ]; then',
` echo "[WARN] 端口 $TARGET_PORT 仍有残留进程 $PORT_PID_CHECK,尝试再次强制停止..."`,
' echo "[WARN] 端口 $TARGET_PORT 仍有残留进程 $PORT_PID_CHECK,强制停止..."',
' kill -9 "$PORT_PID_CHECK" 2>/dev/null || true',
' fuser -k "$TARGET_PORT/tcp" 2>/dev/null || true',
' fi',
` echo "端口 $TARGET_PORT 已释放"`,
' echo "端口 $TARGET_PORT 已释放"',
'else',
` echo "端口 $TARGET_PORT 空闲,无需清理"`,
' echo "端口 $TARGET_PORT 空闲,无需清理"',
'fi',
].join('\n');
@ -288,7 +289,7 @@ function main() {
'else',
' echo "正在停止旧实例 ($OLD_VERSION): $OLD_PIDS"',
' kill $OLD_PIDS || true',
' sleep 3',
' sleep 30',
' OLD_PIDS_REMAIN=$(ps -eo pid=,args= | awk -v root="$OLD_DIR" \'index($0, root) && $2 ~ /node$/ { print $1 }\')',
' if [ -n "$OLD_PIDS_REMAIN" ]; then',
' echo "旧实例 ($OLD_VERSION) 仍有残留进程,强制停止: $OLD_PIDS_REMAIN"',

View File

@ -2,7 +2,7 @@
const assert = require('node:assert/strict');
const StorageReportService = require('../../../../app/service/systems/storage/report');
const StorageReportMethodService = require('../../../../app/service/systemMethods/storage/report');
const StockReportMethodService = require('../../../../app/service/systemMethods/stock/report');
/**
* 构建 storage.report service 测试桩。
@ -42,6 +42,11 @@ function createReportServiceHarness(options = {}) {
return options.storeRows || [];
},
},
StoreWarehouse: {
async findAll() {
return options.storeWarehouseRows || [];
},
},
LocationSpace: {
async findAll() {
return options.spaceRows || [];
@ -59,6 +64,9 @@ function createReportServiceHarness(options = {}) {
QueryTypes: {
SELECT: 'SELECT',
},
Op: {
in: 'IN',
},
},
},
logger: {
@ -68,6 +76,21 @@ function createReportServiceHarness(options = {}) {
},
service: {
systems: {
stockWarehouse: {
async getStockDetails() {
const barcodeMap = new Map();
for (const bc of options.barcodeRows || []) {
if (!barcodeMap.has(bc.stock_id)) {
barcodeMap.set(bc.stock_id, []);
}
barcodeMap.get(bc.stock_id).push({ barcode: bc.barcode });
}
return (options.stockRows || []).map(row => ({
...row,
barcodes: barcodeMap.get(row.id) || [],
}));
},
},
excel: {
async generateAndUpload(exportOptions) {
calls.exports.push(exportOptions);
@ -91,7 +114,7 @@ function createReportServiceHarness(options = {}) {
/**
* 构建 storage.report method 测试桩。
* @param {Object} options 自定义参数
* @return {{methodService: StorageReportMethodService, captured: Object, cacheStore: Map<string, Object>}} method 与调用记录
* @return {{methodService: StockReportMethodService, captured: Object, cacheStore: Map<string, Object>}} method 与调用记录
*/
function createReportMethodHarness(options = {}) {
const captured = {
@ -143,7 +166,7 @@ function createReportMethodHarness(options = {}) {
},
};
const methodService = new StorageReportMethodService(ctx);
const methodService = new StockReportMethodService(ctx);
methodService.prepareWhereContext = function prepareWhereContext() {
return {
whereValue: {
@ -230,9 +253,14 @@ describe('test/app/service/systems/storage.report.test.js', () => {
assert.match(calls.queries[2].sql, /FROM wms_stock_transaction t/);
assert.match(calls.queries[2].sql, /before_quantity/);
assert.doesNotMatch(calls.queries[2].sql, /storage_id/);
// 回归断言:intervalEdge 两条标量子查询必须带 stock/store 维度关联,防止同秒跨 SKU 串行
assert.match(calls.queries[2].sql, /t2\.stock_id = g\.stock_id AND t2\.store_id = g\.store_id/);
assert.match(calls.queries[2].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
assert.match(calls.queries[3].sql, /FROM wms_stock_transaction t/);
assert.match(calls.queries[3].sql, /created_at < :startTime/);
assert.match(calls.queries[3].sql, /after_quantity/);
// 回归断言:preStart 标量子查询同样必须带 stock/store 维度关联
assert.match(calls.queries[3].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
});
it('should keep space dimension with pre-start-last-after for begin and in-range-last-after for end', async () => {
@ -290,6 +318,12 @@ describe('test/app/service/systems/storage.report.test.js', () => {
assert.match(calls.queries[1].sql, /GROUP BY t.stock_id, COALESCE\(t.space_id, 0\), t.store_id/);
assert.match(calls.queries[2].sql, /FROM wms_storage_transaction t/);
assert.match(calls.queries[3].sql, /FROM wms_storage_transaction t/);
// 回归断言:by_space 口径下 intervalEdge/preStart 子查询需同时带 space + stock/store 关联
assert.match(calls.queries[2].sql, /COALESCE\(t2.space_id, 0\) = g.space_id/);
assert.match(calls.queries[2].sql, /t2\.stock_id = g\.stock_id AND t2\.store_id = g\.store_id/);
assert.match(calls.queries[2].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
assert.match(calls.queries[3].sql, /COALESCE\(t3.space_id, 0\) = g.space_id/);
assert.match(calls.queries[3].sql, /t3\.stock_id = g\.stock_id AND t3\.store_id = g\.store_id/);
});
it('should return base space keys with zero fallback when by_space is true and interval has no transactions', async () => {
@ -341,6 +375,8 @@ describe('test/app/service/systems/storage.report.test.js', () => {
inbound_total: 0,
outbound_total: 0,
store_name: '货主M',
warehouse_id: 0,
warehouse_name: '',
item_name: '商品M',
barcode: '',
item_code: 'SKU-M',
@ -358,6 +394,8 @@ describe('test/app/service/systems/storage.report.test.js', () => {
inbound_total: 0,
outbound_total: 0,
store_name: '货主M',
warehouse_id: 0,
warehouse_name: '',
item_name: '商品N',
barcode: '',
item_code: 'SKU-N',
@ -397,6 +435,8 @@ describe('test/app/service/systems/storage.report.test.js', () => {
inbound_total: 0,
outbound_total: 0,
store_name: '货主X',
warehouse_id: 0,
warehouse_name: '',
item_name: '商品X',
barcode: '',
item_code: 'SKU-X',
@ -498,7 +538,7 @@ describe('test/app/service/systems/storage.report.test.js', () => {
},
};
const methodService = new StorageReportMethodService(ctx);
const methodService = new StockReportMethodService(ctx);
methodService.prepareWhereContext = function prepareWhereContext() {
return {
whereValue: {
@ -754,7 +794,8 @@ describe('test/app/service/systems/storage.report.test.js', () => {
assert.equal(detailRow.item_code, 'SKU-X');
assert.equal(detailRow.item_name, '商品X');
assert.equal(detailRow.barcode, 'BC-X-1');
assert.equal(detailRow.space_name, 'A01位');
// 变更记录明细列白名单(detailColumns)不含库位字段,space_name 不应出现在明细行中
assert.equal(detailRow.space_name, undefined);
assert.equal(detailRow.quantity, 2);
assert.equal(detailRow.before_locked_quantity, 1);
assert.equal(detailRow.after_locked_quantity, 1);
@ -768,4 +809,159 @@ describe('test/app/service/systems/storage.report.test.js', () => {
assert.equal(transferInRow.transaction_type, '移库入');
assert.equal(unknownTypeRow.transaction_type, 'custom_type');
});
it('should always exclude LOCK and UNLOCK on store mode export regardless of exportMode', async () => {
const { service, calls } = createReportServiceHarness({
warehouseId: 1000000, // store 模式下 ctx.user.store_id 即货主 ID
queryResults: [
[
{ stock_id: 701, store_id: 1000000, warehouse_id: 100000, quantity: 37, item_code: 'SKU-X', item_name: '商品X' },
],
[
{ stock_id: 701, store_id: 1000000, inbound_total: 2, outbound_total: 1 },
],
[
{ id: 1, stock_id: 701, space_id: 0, store_id: 1000000, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
],
[
{ id: 10, stock_id: 701, space_id: 0, store_id: 1000000, after_quantity: 9, created_at: '2026-04-30 23:00:00' },
],
[
{
id: 1001,
created_at: '2026-05-01 12:00:00',
transaction_type: 'LOCK',
store_id: 1000000,
stock_id: 701,
space_id: 0,
quantity: 1,
before_quantity: 10,
after_quantity: 10,
before_locked_quantity: 0,
after_locked_quantity: 1,
batch_no: '',
inventory_type: '',
order_type: null,
order_no: null,
order_id: null,
receiving_id: null,
entry_order_id: null,
operator_name: '',
remark: '',
},
],
],
stockRows: [
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
],
barcodeRows: [
{ stock_id: 701, barcode: 'BC-X-1' },
],
storeRows: [
{ id: 1000000, company_name: '货主X' },
],
});
// 货主侧即使传 exportMode='item',也必须无条件排除 LOCK/UNLOCK
const result = await service.export(
'2026-05-01 00:00:00',
'2026-05-01 23:59:59',
false,
[],
null,
'item',
'store'
);
assert.ok(result.filename.endsWith('.xlsx'));
const detailQuery = calls.queries[4];
assert.match(detailQuery.sql, /transaction_type NOT IN \(:excludeStoreTypes\)/);
assert.deepEqual(detailQuery.options.replacements.excludeStoreTypes, [ 'LOCK', 'UNLOCK' ]);
assert.doesNotMatch(detailQuery.sql, /excludeLockType/);
});
it('should keep warehouse mode lock filter behavior unchanged', async () => {
const baseQueryResults = [
[
{ stock_id: 701, store_id: 901, warehouse_id: 100000, quantity: 37, item_code: 'SKU-X', item_name: '商品X' },
],
[
{ stock_id: 701, store_id: 901, inbound_total: 2, outbound_total: 1 },
],
[
{ id: 1, stock_id: 701, space_id: 0, store_id: 901, before_quantity: 10, after_quantity: 11, created_at: '2026-05-01 12:00:00' },
],
[
{ id: 10, stock_id: 701, space_id: 0, store_id: 901, after_quantity: 9, created_at: '2026-04-30 23:00:00' },
],
[
{
id: 1001,
created_at: '2026-05-01 12:00:00',
transaction_type: 'LOCK',
store_id: 901,
stock_id: 701,
space_id: 0,
quantity: 1,
before_quantity: 10,
after_quantity: 10,
before_locked_quantity: 0,
after_locked_quantity: 1,
batch_no: '',
inventory_type: '',
order_type: null,
order_no: null,
order_id: null,
receiving_id: null,
entry_order_id: null,
operator_name: '',
remark: '',
},
],
];
const { service, calls } = createReportServiceHarness({
queryResults: [ ...baseQueryResults, ...baseQueryResults ],
stockRows: [
{ id: 701, item_name: '商品X', item_code: 'SKU-X' },
],
barcodeRows: [
{ stock_id: 701, barcode: 'BC-X-1' },
],
storeRows: [
{ id: 901, company_name: '货主X' },
],
});
// 仓库模式默认口径:排除 LOCK
await service.export(
'2026-05-01 00:00:00',
'2026-05-01 23:59:59',
false,
[ 901 ],
null,
'',
'warehouse'
);
const defaultDetail = calls.queries[4];
assert.match(defaultDetail.sql, /transaction_type != :excludeLockType/);
assert.equal(defaultDetail.options.replacements.excludeLockType, 'LOCK');
assert.doesNotMatch(defaultDetail.sql, /excludeStoreTypes/);
// 仓库模式 item 口径:保留 LOCK(行为与改动前一致)
await service.export(
'2026-05-01 00:00:00',
'2026-05-01 23:59:59',
false,
[ 901 ],
null,
'item',
'warehouse'
);
const itemDetail = calls.queries[9];
assert.doesNotMatch(itemDetail.sql, /excludeLockType/);
assert.doesNotMatch(itemDetail.sql, /excludeStoreTypes/);
});
});