feat(workbench): 打包链路重构:运单维度流水、成员自动回填与登出自动结束、token+key 消费模式、getWorkbenchInfo 字段补齐

This commit is contained in:
liufumingren 2026-09-21 02:28:04 +08:00
parent e76a6e3fa4
commit f06dc3d765
2 changed files with 444 additions and 35 deletions

View File

@ -224,8 +224,11 @@ class WorkbenchService extends MainService {
}
/**
* 工作台打包上报(免登录、免鉴权,以工作台 token 鉴权,仓库与工作台由服务端注入)
* 推荐只传 token + key(key 来自 workbench.queryOrder 响应,20 分钟有效,
* 订单参数由后端从缓存拉取防篡改);不传 key 时旧参数模式过渡兼容。
* @param {Object} data - {
* token, delivery_order_code, wave_no, status, pack_time,
* token, key,
* delivery_order_code, wave_no, status, pack_time,
* wave_total_orders, items_count, items_total, users
* }
*/
@ -234,6 +237,7 @@ class WorkbenchService extends MainService {
try {
const {
token,
key,
delivery_order_code: deliveryOrderCode,
wave_no: waveNo,
status,
@ -245,6 +249,7 @@ class WorkbenchService extends MainService {
} = data || {};
const result = await service.systems.workbench.packOrderByToken({
token,
key,
delivery_order_code: deliveryOrderCode,
wave_no: waveNo,
status,

View File

@ -24,6 +24,12 @@ const WORKBENCH_BIND_CLIENT_CACHE_PREFIX = 'workbench:bind:client:';
const WORKBENCH_BIND_CODE_CACHE_PREFIX = 'workbench:bind:code:';
/** @type {string} 工作台 token → 信息缓存 key 前缀(最终 key:workbench:token:{token}) */
const WORKBENCH_TOKEN_CACHE_PREFIX = 'workbench:token:';
/** @type {string} 工作台打包上下文缓存 key 前缀(最终 key:{前缀}{key},key 由 queryOrder 返回) */
const WORKBENCH_PACK_CTX_CACHE_PREFIX = 'workbench:packctx:';
/** @type {number} 工作台打包上下文缓存有效期(秒,queryOrder 扫码后 packOrder 消费窗口) */
const WORKBENCH_PACK_CTX_CACHE_TTL_SECONDS = 1200;
/** @type {string} 工作台打包上下文 key 前缀 */
const WORKBENCH_PACK_CTX_KEY_PREFIX = 'wpck';
/** @type {number} 工作台绑定码缓存有效期(秒) */
const WORKBENCH_BIND_CACHE_TTL_SECONDS = 120;
/** @type {number} 工作台 token 信息缓存有效期(秒) */
@ -242,8 +248,23 @@ class WorkbenchService extends Service {
case 'queryOrder':
case 'query':
return await this._queryOrder(data || {});
case 'packOrder':
return await this._packOrder(data || {});
case 'packOrder': {
// 新 key 模式:只凭 key 从后端缓存取订单信息(防篡改);
// 不传 key 时旧参数模式兼容(过渡期保留)。
const bizData = data || {};
const bizKey = String(bizData.key || '').trim();
if (bizKey) {
const cachedCtx = await this._loadPackCtx(bizData);
return await this._packOrder({
delivery_order_code: cachedCtx.delivery_order_code,
wave_no: cachedCtx.wave_no,
waybill_code: cachedCtx.waybill_code,
warehouse_id: Number(cachedCtx.warehouse_id || 0),
workbench_id: cachedCtx.workbench_id != null ? Number(cachedCtx.workbench_id) : null,
});
}
return await this._packOrder(bizData);
}
case 'finishPack':
return await this._finishPack(data || {});
case 'sendWeight':
@ -254,6 +275,31 @@ class WorkbenchService extends Service {
}
}
/**
* 凭打包上下文 key 从缓存拉取打包参数(queryOrder 扫码时写入,20 分钟有效)。
* 只信任后端缓存内容,body 其它字段一律忽略(防篡改)。
* @param {Object} data - { key }
* @return {Promise<Object>} 缓存内容(warehouse_id/workbench_id/order_id/delivery_order_code/wave_no/waybill_code/is_sandan)
* @throws {Error} key 缺失或上下文过期
*/
async _loadPackCtx(data = {}) {
const { app } = this;
const ctxKey = String((data && data.key) || '').trim();
if (!ctxKey) {
throw new Error('缺少打包上下文 key,请先扫码');
}
let cachedCtx = null;
try {
cachedCtx = await app.getCacheAsync(this.getWorkbenchPackCtxCacheKey(ctxKey));
} catch (cacheErr) {
app.coreLogger.warn(`读取打包上下文缓存失败: ${cacheErr.message}`);
}
if (!cachedCtx || !Number(cachedCtx.order_id)) {
throw new Error('打包上下文已过期,请重新扫码');
}
return cachedCtx;
}
/**
* 实时统计波次下的订单数量(并发遍历 current + dispatch 分表)
*
@ -729,8 +775,12 @@ class WorkbenchService extends Service {
}
/**
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录
* @param {Object} params - { delivery_order_code, wave_no, warehouse_id, workbench_id, status, pack_time }
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录。
* 兼容一单多号(主单号/子单号):传入 waybill_code 时按「订单 + 运单号」维度
* 记录打包流水与去重,主/子单号流水互不覆盖;未传时保持订单维度(兼容旧设备端)。
* 打包人一律取该工作台绑定成员(wms_workbench_member),不再接收 users 入参。
* @param {Object} params - { delivery_order_code, wave_no, warehouse_id, workbench_id, status, pack_time, waybill_code }
* @param {string} [params.waybill_code] 扫描打包的运单号(可选,用于运单维度记录流水)
* @returns {Promise<Object>}
*/
async _packOrder(params) {
@ -741,7 +791,7 @@ class WorkbenchService extends Service {
wave_total_orders: waveTotalOrders,
items_count: itemsCount,
items_total: itemsTotal,
users: usersParam } = params;
waybill_code: waybillCodeParam } = params;
if (!deliveryOrderCode) throw new Error('发货单号不能为空');
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
@ -823,6 +873,39 @@ class WorkbenchService extends Service {
throw new Error(`订单已被拦截,无法打包 [${deliveryOrderCode}]`);
}
// 步骤2.5:解析运单号归属(仅散单,兼容一单多号:主单号 business_key=1 / 子单号 business_key>1)。
// 设备端扫描打包传入运单号时,按「订单 + 运单号」维度记录打包流水,
// 避免同一订单下主/子单号打包互相覆盖(散单去重)或被误判为已打包;
// 团购为波次维度打包,不使用运单号。
let packWaybillCode = null;
if (isSandan === 1 && waybillCodeParam) {
const normalizedWaybill = String(waybillCodeParam).trim();
if (normalizedWaybill) {
try {
const waybillRow = await ctx.model.OrderExpress.findOne({
where: {
order_id: orderId,
warehouse_id: warehouseId,
waybill_code: normalizedWaybill,
status: 1,
},
attributes: [ 'waybill_code', 'business_key' ],
raw: true,
});
if (waybillRow) {
packWaybillCode = waybillRow.waybill_code;
ctx.logger.info('[Workbench._packOrder] 按运单维度打包 orderId=%d waybill=%s business_key=%d',
orderId, packWaybillCode, Number(waybillRow.business_key) || 1);
} else {
ctx.logger.warn('[Workbench._packOrder] 运单号不属于该订单,降级为订单维度打包 orderId=%d waybill=%s',
orderId, normalizedWaybill);
}
} catch (waybillErr) {
ctx.logger.warn('[Workbench._packOrder] 运单归属解析失败,降级为订单维度打包: %s', waybillErr.message);
}
}
}
// 步骤3:获取工作台 device_ids 与名称(名称用于操作日志展示)
let deviceIds = null;
let workbenchName = '';
@ -873,11 +956,22 @@ class WorkbenchService extends Service {
}
}
// 步骤5:去重 — 散单按 order_id 物理删除旧记录,团购按 wave_no 物理删除旧记录
// 步骤5:去重 — 散单按 order_id(未传运单号时)/order_id+waybill_code(传运单号时)
// 物理删除旧记录,团购按 wave_no 物理删除旧记录;
// 一单多号场景按运单维度去重,主单号/子单号的打包流水互不覆盖;
// 传运单号时同时清理同订单历史订单级(waybill_code 为空)旧流水,
// 避免空值幽灵记录导致其它运单被误判为已打包。
if (isSandan === 1) {
// 散单:按 order_id 去重,先收集旧任务ID清理关联打包人,再物理移除旧任务
// 散单去重:先收集旧任务ID清理关联打包人,再物理移除旧任务
const sandanDedupeWhere = { order_id: orderId, warehouse_id: warehouseId };
if (packWaybillCode) {
sandanDedupeWhere[ctx.app.Sequelize.Op.or] = [
{ waybill_code: packWaybillCode },
{ waybill_code: null },
];
}
const oldTasks = await ctx.model.PackTask.findAll({
where: { order_id: orderId, warehouse_id: warehouseId },
where: sandanDedupeWhere,
attributes: ['id'],
raw: true,
paranoid: false,
@ -978,7 +1072,7 @@ class WorkbenchService extends Service {
workbench_id: validWorkbenchId,
wave_id: waveId,
wave_no: actualWaveNo,
waybill_code: null, // 后续可从 order_express 补
waybill_code: packWaybillCode, // 散单运单维度打包时记录运单号;未传运单号(旧设备端)或团购保持 null
pack_mode: isSandan === 0 ? 2 : 1, // 1=散单 2=团购
status: normalizedPackStatus,
pack_quantity: packQuantity,
@ -1006,7 +1100,26 @@ class WorkbenchService extends Service {
});
// 步骤7:写入打包人员信息
const users = Array.isArray(usersParam) ? usersParam : [];
// 打包人一律取该工作台绑定成员(成员登入/登出链路 bindMember/removeMember 已持久化到
// wms_workbench_member,数据源单一,前端不再上报 users 入参)。
let users = [];
if (validWorkbenchId) {
try {
const members = await this.listWorkbenchMembers(validWorkbenchId);
users = members.map(m => ({
wms_account_id: m.user_id != null ? m.user_id : null,
id: m.user_id != null ? m.user_id : null,
real_name: m.user_name || '',
}));
if (users.length > 0) {
ctx.logger.info('[Workbench._packOrder] 自动回填工作台绑定成员 %d 人 workbenchId=%d',
users.length, validWorkbenchId);
}
} catch (memberErr) {
// 成员查询失败不阻断打包主流程,打包人保持为空
ctx.logger.warn('[Workbench._packOrder] 查询工作台绑定成员失败,打包人保持为空: %s', memberErr.message);
}
}
let operatorText = '';
if (users.length > 0) {
// account_id 未知时写 null(表列允许 NULL):唯一索引 uix_pack_task_account 对
@ -1044,13 +1157,18 @@ class WorkbenchService extends Service {
if (cameraIds.length > 0) {
let osdText = '';
if (isSandan === 1) {
// 散单:用运单号
const expressRecord = await ctx.model.OrderExpress.findOne({
where: { order_id: orderId, warehouse_id: warehouseId },
attributes: ['waybill_code'],
raw: true,
});
osdText = (expressRecord && expressRecord.waybill_code) || deliveryOrderCode;
// 散单:优先打包时传入的运单号(一单多号时展示当前打包运单),
// 未传时查订单首个运单,兜底发货单号
let osdWaybill = packWaybillCode;
if (!osdWaybill) {
const expressRecord = await ctx.model.OrderExpress.findOne({
where: { order_id: orderId, warehouse_id: warehouseId },
attributes: ['waybill_code'],
raw: true,
});
osdWaybill = (expressRecord && expressRecord.waybill_code) || '';
}
osdText = osdWaybill || deliveryOrderCode;
} else {
// 团购:波次号+总量
osdText = `波次${actualWaveNo} 共${totalOrders}单`;
@ -1918,16 +2036,24 @@ class WorkbenchService extends Service {
}
/**
* 条码查订单:条码 → wms_order_express → 待处理/配送订单详情
* 条码查订单:条码 → wms_order_express → 待处理/配送订单详情。
* 散单(isSandan=1)时在响应 order 对象中额外返回 intercept_flag / pack_flag 两个 0/1 标志:
* 拦截状态(intercept_status)不等于 none 时 intercept_flag=1,否则 0;
* 打包状态(pack_status)不等于 none 时 pack_flag=1,否则 0。
* @param {Object} params - { barcode, warehouseId }
* @return {Promise<Object>} 查询结果 { barcode, waybill_code, isSandan, store_remark, express, order, items, source_table, batch? }
* pack_flag 按运单维度判定(该运单号已有打包流水为 1,主/子单号互不影响)。
* 查询成功时生成一次性打包上下文 key(20 分钟有效)写入 Redis,
* 响应附 key 供 workbench.packOrder 消费,打包参数由后端维护防篡改。
* @param {Object} params - { barcode, warehouseId, workbenchId }
* @return {Promise<Object>} 查询结果 { key, barcode, waybill_code, isSandan, store_remark, express, order, items, source_table, batch? }
*/
async _queryOrder(params) {
const { ctx } = this;
const { barcode, warehouseId: inputWarehouseId } = params;
const { barcode, warehouseId: inputWarehouseId, workbench_id: workbenchIdRaw } = params;
const workbenchId = (workbenchIdRaw !== undefined && workbenchIdRaw !== null && workbenchIdRaw !== '')
? parseInt(workbenchIdRaw)
: null;
const validQueryWorkbenchId = (workbenchId !== null && !isNaN(workbenchId) && workbenchId > 0)
? workbenchId
: null;
if (!barcode || !String(barcode).trim()) {
throw new Error('条码不能为空');
@ -2053,11 +2179,38 @@ class WorkbenchService extends Service {
}
}
// 步骤6:散单标志位计算(拦截/打包状态空值归一化为 none,非 none 记 1,否则 0)
// 步骤6:散单标志位计算
// - 拦截标志:订单级拦截状态(空值归一化为 none,非 none 记 1,否则 0);
// - 打包标志:按运单维度判定(一单多号场景下主单号/子单号互不影响)——
// 查询该运单号是否已有打包流水(wms_pack_task.waybill_code),
// 历史订单级流水(waybill_code 为空)兜底命中;
// 避免用订单级 pack_status(任一运单打包即非 none)导致「主单号打包后子单号被误判为已打包」。
// 团购(isSandan=0)不返回该标志,不执行查询。
const normalizedInterceptStatus = String(orderRow.intercept_status || '').trim() || 'none';
const normalizedPackStatus = String(orderRow.pack_status || '').trim() || 'none';
const interceptFlag = normalizedInterceptStatus === 'none' ? 0 : 1;
const packFlag = normalizedPackStatus === 'none' ? 0 : 1;
let packFlag = 0;
if (isSandan === 1) {
try {
const waybillPackTask = await ctx.model.PackTask.findOne({
where: {
warehouse_id: warehouseId,
order_id: orderId,
[ctx.app.Sequelize.Op.or]: [
{ waybill_code: waybillCode },
{ waybill_code: null },
],
},
attributes: [ 'id' ],
raw: true,
});
packFlag = waybillPackTask ? 1 : 0;
} catch (packTaskErr) {
// 打包流水查询失败时降级为订单级 pack_status 判定,避免阻断查询
ctx.logger.warn('[Workbench._queryOrder] 查询运单打包流水失败 orderId=%d: %s', orderId, packTaskErr.message);
const normalizedPackStatus = String(orderRow.pack_status || '').trim() || 'none';
packFlag = normalizedPackStatus === 'none' ? 0 : 1;
}
}
const result = {
barcode: normalizedBarcode,
@ -2113,9 +2266,50 @@ class WorkbenchService extends Service {
};
}
// 步骤7:生成打包上下文 key 写入缓存(20 分钟有效),packOrder 凭 key 拉取参数。
// 缓存内容为打包所需参数(订单号/波次号/运单号/归属仓库与工作台),由后端维护防篡改;
// 写入失败仅告警不阻断查询,key 仍返回(消费端读取失败会提示重新扫码)。
const packCtxKey = this.generatePackCtxKey();
const packCtx = {
warehouse_id: warehouseId,
workbench_id: validQueryWorkbenchId,
order_id: orderRow.id,
delivery_order_code: orderRow.delivery_order_code,
wave_no: orderRow.wave_no || '',
waybill_code: waybillCode,
is_sandan: isSandan,
};
try {
await ctx.app.setCacheAsync(
this.getWorkbenchPackCtxCacheKey(packCtxKey),
packCtx,
WORKBENCH_PACK_CTX_CACHE_TTL_SECONDS
);
result.key = packCtxKey;
} catch (cacheErr) {
ctx.logger.warn('[Workbench._queryOrder] 写入打包上下文缓存失败 key=%s: %s', packCtxKey, cacheErr.message);
}
return result;
}
/**
* 生成打包上下文 key(前缀 wpck + 随机段)。
* @return {string} 打包上下文 key
*/
generatePackCtxKey() {
return WORKBENCH_PACK_CTX_KEY_PREFIX + this.generateRandomChars(WORKBENCH_BIND_CODE_CHARSET, 32);
}
/**
* 打包上下文缓存 key。
* @param {string} ctxKey 打包上下文 key(queryOrder 响应返回)
* @return {string} Redis 缓存 key
*/
getWorkbenchPackCtxCacheKey(ctxKey) {
return `${WORKBENCH_PACK_CTX_CACHE_PREFIX}${ctxKey}`;
}
// ==================== 绑定码 / 登录码 / 令牌 ====================
/**
@ -2618,6 +2812,54 @@ class WorkbenchService extends Service {
}
}
// 散单任务补齐货主备注与运单信息(物流公司/称重重量/包材名称,与 workbench.queryOrder 的
// store_remark/express 口径一致,供前端填充展示;团购为波次维度不适用,保持空)。
let storeRemark = '';
let express = null;
if (!isGroup && Number(task.order_id || 0) > 0) {
const orderId = Number(task.order_id);
const storeId = Number((orderRow && orderRow.store_id) || 0);
const [ swRow, expressRow ] = await Promise.all([
storeId > 0
? ctx.model.StoreWarehouse.findOne({
where: { store_id: storeId, warehouse_id: warehouseId },
attributes: [ 'store_remask' ],
raw: true,
}).catch(swErr => {
ctx.logger.warn('[Workbench.buildCurrentPackingInfo] 查询货主备注失败 orderId=%d: %s', orderId, swErr.message);
return null;
})
: Promise.resolve(null),
(async () => {
const expressWhere = {
order_id: orderId,
warehouse_id: warehouseId,
status: 1,
};
if (task.waybill_code) {
expressWhere.waybill_code = task.waybill_code;
}
return await ctx.model.OrderExpress.findOne({
where: expressWhere,
attributes: [ 'waybill_code', 'logistics_name', 'weighing_weight', 'package_material_name_snapshot' ],
raw: true,
});
})().catch(expressErr => {
ctx.logger.warn('[Workbench.buildCurrentPackingInfo] 查询运单信息失败 orderId=%d: %s', orderId, expressErr.message);
return null;
}),
]);
storeRemark = (swRow && swRow.store_remask) ? String(swRow.store_remask).trim() : '';
if (expressRow) {
express = {
waybill_code: expressRow.waybill_code || '',
logistics_name: expressRow.logistics_name || '',
weighing_weight: expressRow.weighing_weight,
package_material_name: expressRow.package_material_name_snapshot || '',
};
}
}
currentOrders.push({
task_id: task.id,
order_id: task.order_id,
@ -2632,6 +2874,8 @@ class WorkbenchService extends Service {
waybill_code: task.waybill_code || '',
order_type: (orderRow && orderRow.order_type) || '',
store_id: Number((orderRow && orderRow.store_id) || 0),
store_remark: storeRemark,
express,
items_count: Number((orderRow && orderRow.items_count) || 0),
items_total: Number((orderRow && orderRow.items_total) || 0),
items,
@ -3378,19 +3622,18 @@ class WorkbenchService extends Service {
/**
* 工作台打包上报(供 workbench.packOrder,免登录免鉴权,以工作台 token 鉴权)。
* warehouse_id/workbench_id 均由 token 解析出的工作台上下文注入,禁止前端传入,
* 防止跨仓库/跨工作台写数据;其余入参与 business(packOrder) 分支一致。
* 推荐 key 模式:前端先经 workbench.queryOrder 扫码拿到 key(20 分钟有效),
* 打包只传 token + key,订单信息一律由后端从缓存拉取(防篡改);
* 不传 key 时旧参数模式兼容(过渡期保留,后续版本将移除)。
* 仓库与工作台均由 token 解析注入,禁止前端传值。
* 打包状态变更后由 _packOrder 内部主动失效 token 缓存,保证 getWorkbenchInfo 及时返回最新信息。
* @param {Object} [data={}] - {
* token, delivery_order_code, wave_no, status, pack_time,
* wave_total_orders, items_count, items_total, users
* }
* @param {Object} [data={}] - { token, key }(推荐)或旧参数模式 { token, delivery_order_code, ... }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _packOrder 返回的任务信息;失败时 statusCode 为 401/403
* success=true 时 data 为 _packOrder 返回的任务信息;失败时 statusCode 为 401/403/400
*/
async packOrderByToken(data = {}) {
const { ctx } = this;
const { token, ...packParams } = data || {};
const { token, key, ...legacyParams } = data || {};
const resolved = await this.resolveWorkbenchContext(token);
if (!resolved.success) return resolved;
@ -3406,6 +3649,50 @@ class WorkbenchService extends Service {
};
}
// 新 key 模式优先;不传 key 时旧参数模式兼容(过渡期保留)
const ctxKey = String(key || '').trim();
let packParams;
if (ctxKey) {
let cachedCtx = null;
try {
cachedCtx = await this._loadPackCtx({ key: ctxKey });
} catch (loadErr) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: loadErr.message || '打包上下文已过期,请重新扫码',
};
}
// 归属校验:防跨仓库/跨工作台消费他人扫码上下文
if (Number(cachedCtx.warehouse_id || 0) !== Number(warehouseId)) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '打包上下文与当前仓库不匹配',
};
}
if (cachedCtx.workbench_id != null && Number(cachedCtx.workbench_id) !== Number(ctx.workbenchId)) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '打包上下文与当前工作台不匹配',
};
}
packParams = {
delivery_order_code: cachedCtx.delivery_order_code,
wave_no: cachedCtx.wave_no,
waybill_code: cachedCtx.waybill_code,
};
} else {
packParams = legacyParams || {};
}
const result = await this._packOrder({
...packParams,
warehouse_id: warehouseId,
@ -3505,7 +3792,11 @@ class WorkbenchService extends Service {
};
}
const result = await this._queryOrder({ barcode, warehouseId });
const result = await this._queryOrder({
barcode,
warehouseId,
workbench_id: ctx.workbenchId,
});
return { success: true, code: 200, data: result, message: 'ok' };
}
@ -3529,11 +3820,105 @@ class WorkbenchService extends Service {
.filter(n => Number.isInteger(n) && n > 0)) ];
}
/**
* 成员全部登出后自动结束该工作台所有未结束的打包任务。
* 与 _finishPack 语义一致:每个任务置 status=2 并写 end_time,
* 同步回写订单打包状态(散单按订单、团购按波次,并补确认打印状态),
* 写完成操作日志、复位 OSD、失效 token 缓存。
* 单个任务处理失败仅告警不阻断,整体异常吞掉不抛出,不影响移除成员主流程。
* @param {Object} params - { workbenchId, warehouseId }
* @return {Promise<{finished: number, task_ids: number[]}>} 已结束任务数与ID列表
*/
async _finishAllPackTasksByMemberLogout({ workbenchId, warehouseId }) {
const { ctx } = this;
const validWorkbenchId = Number(workbenchId || 0);
const validWarehouseId = Number(warehouseId || 0);
if (!Number.isInteger(validWorkbenchId) || validWorkbenchId <= 0) {
return { finished: 0, task_ids: [] };
}
try {
const tasks = await ctx.model.PackTask.findAll({
where: {
workbench_id: validWorkbenchId,
warehouse_id: validWarehouseId,
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
order: [[ 'id', 'DESC' ]],
});
if (!tasks || tasks.length === 0) {
ctx.logger.info('[Workbench._finishAllPackTasksByMemberLogout] 工作台 %d 无未结束的打包任务', validWorkbenchId);
return { finished: 0, task_ids: [] };
}
const now = new Date();
const finishedTaskIds = [];
for (const task of tasks) {
try {
const endTime = await this.resolvePackTaskEndTime(task, now);
await task.update({ end_time: endTime, status: 2 });
finishedTaskIds.push(task.id);
const isGroupTask = Number(task.pack_mode) === 2;
await this._updateOrderPackStatus(validWarehouseId, {
orderId: Number(task.order_id || 0),
waveId: isGroupTask ? Number(task.wave_id || 0) : 0,
packStatus: 2,
caller: 'Workbench._finishAllPackTasksByMemberLogout',
});
// 写完成操作日志(操作人取自任务记录 operator_text)
try {
const operatorText = String(task.operator_text || '');
await this._writePackOperationLog({
warehouseId: validWarehouseId,
orderId: Number(task.order_id || 0),
waveId: isGroupTask ? Number(task.wave_id || 0) : 0,
waveNo: task.wave_no || '',
isSandan: isGroupTask ? 0 : 1,
packData: {
pack_mode: task.pack_mode,
status: 2,
pack_quantity: task.pack_quantity,
item_quantity: task.item_quantity,
sku_count: task.sku_count,
workbench_id: validWorkbenchId,
wave_no: task.wave_no,
},
users: operatorText ? [{ real_name: operatorText }] : [],
workbenchName: '',
});
} catch (logErr) {
ctx.logger.warn('[Workbench._finishAllPackTasksByMemberLogout] 写操作日志失败 taskId=%d: %s', task.id, logErr.message);
}
} catch (taskErr) {
ctx.logger.warn('[Workbench._finishAllPackTasksByMemberLogout] 结束任务失败 taskId=%d: %s', task.id, taskErr.message);
}
}
// OSD 复位为「无任务」(异步执行,不阻塞主流程)
this._resetPackOsd({ warehouseId: validWarehouseId, workbenchId: validWorkbenchId }).catch(err => {
ctx.logger.warn('[Workbench._finishAllPackTasksByMemberLogout] OSD复位异常 workbenchId=%d err=%s', validWorkbenchId, err.message);
});
// 打包任务已结束,失效 token 缓存,保证 getWorkbenchInfo 尽快返回最新打包信息
await this.invalidateWorkbenchTokenCacheByWorkbenchId(validWorkbenchId);
ctx.logger.info('[Workbench._finishAllPackTasksByMemberLogout] 成员全部登出,自动结束打包任务 %d 个 workbenchId=%d',
finishedTaskIds.length, validWorkbenchId);
return { finished: finishedTaskIds.length, task_ids: finishedTaskIds };
} catch (err) {
ctx.logger.warn('[Workbench._finishAllPackTasksByMemberLogout] 自动结束打包任务失败 workbenchId=%d: %s', validWorkbenchId, err.message);
return { finished: 0, task_ids: [] };
}
}
/**
* 移除工作台成员(供 workbench.removeMember,免登录免鉴权,以工作台 token 鉴权)。
* 统一走 resolveWorkbenchContext 校验:无 token 返回失败(401)、token 无效返回失败(403);
* 解析成功后仅删除归属于该工作台的成员行(软删除),
* 并清除对应 token 信息缓存,保证接口尽快返回最新成员。
* 移除后若该工作台已无任何成员,自动结束其所有未结束的打包任务
* (与 _finishPack 语义一致,响应附 auto_finished_pack)。
* @param {Object} [data={}] - { ids, token }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
@ -3577,6 +3962,24 @@ class WorkbenchService extends Service {
where: { id: matchedIds, workbench_id: workbench.id },
});
// 成员全部登出(剩余成员为 0)时,自动结束该工作台未结束的打包任务,
// 同步订单打包状态、写操作日志、复位 OSD(与 _finishPack 语义一致)。
let autoFinishedPack = { finished: 0, task_ids: [] };
try {
const remainingCount = await ctx.model.WorkbenchMember.count({
where: { workbench_id: workbench.id },
});
if (remainingCount === 0) {
autoFinishedPack = await this._finishAllPackTasksByMemberLogout({
workbenchId: workbench.id,
warehouseId: Number(workbench.warehouse_id || 0),
});
}
} catch (memberCountErr) {
// 剩余成员统计或自动结束失败仅告警,不阻断成员移除主流程
app.coreLogger.warn(`成员登出后自动结束打包检查失败: ${memberCountErr.message}`);
}
// 成员变更后清除 token 信息缓存,下次获取工作台信息立即反映最新成员。
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(rawToken));
@ -3586,6 +3989,7 @@ class WorkbenchService extends Service {
data: {
removed: matchedIds.length,
ids: matchedIds,
auto_finished_pack: autoFinishedPack,
},
message: '移除成功',
};