WMS_MAIN/app/service/systems/workbench.js

4126 lines
163 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const Service = require('egg').Service;
const crypto = require('node:crypto');
const { isInterceptedOrderStatus } = require('../../lib/intercept_guard');
/** @type {string} 工作台波次订单实时计数缓存 key 前缀(最终 key:{前缀}:{warehouseId}:{waveId}) */
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} 工作台波次商品 SKU 聚合缓存 key 前缀(最终 key:{前缀}:{warehouseId}:{waveId}) */
const WAVE_ITEMS_SUMMARY_CACHE_KEY_PREFIX = 'cache:workbench:wave_items_summary';
/** @type {number} 工作台波次商品 SKU 聚合缓存 TTL(秒),TTL 内分表聚合只执行一次 */
const WAVE_ITEMS_SUMMARY_CACHE_TTL_SECONDS = 15;
/** @type {string} 工作台绑定会话缓存 key 前缀(client_code 维度,最终 key:{前缀}{clientCode}) */
const WORKBENCH_BIND_CLIENT_CACHE_PREFIX = 'workbench:bind:client:';
/** @type {string} 工作台绑定码缓存 key 前缀(code 维度,供 bind 反查会话,最终 key:{前缀}{code}) */
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 信息缓存有效期(秒) */
const WORKBENCH_TOKEN_CACHE_TTL_SECONDS = 300;
/** @type {number} 工作台绑定长轮询超时(毫秒) */
const WORKBENCH_BIND_LONG_POLL_TIMEOUT_MS = 60000;
/** @type {number} 工作台绑定长轮询检查间隔(毫秒) */
const WORKBENCH_BIND_POLL_INTERVAL_MS = 1000;
/** @type {string} 工作台登录码前缀(登录码总长度 64 位) */
const WORKBENCH_LOGIN_CODE_PREFIX = 'wblc';
/** @type {number} 工作台登录码随机段长度(64 - 前缀长度 = 60 位十六进制) */
const WORKBENCH_LOGIN_CODE_RANDOM_HEX_LENGTH = 64 - WORKBENCH_LOGIN_CODE_PREFIX.length;
/** @type {string} 工作台绑定码 / client_code 字符集 */
const WORKBENCH_BIND_CODE_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
/** @type {number} 工作台绑定码 / client_code 长度 */
const WORKBENCH_BIND_CODE_LENGTH = 6;
/** @type {string} 摄像头 OSD 叠加文字缓存 key 前缀(最终 key:osd_{workbenchId}) */
const OSD_CACHE_KEY_PREFIX = 'osd_';
/** @type {number} 摄像头 OSD 叠加文字缓存有效期(秒) */
const OSD_CACHE_TTL_SECONDS = 3600;
/** @type {string} 打包任务结束(空闲态)时的摄像头 OSD 叠加文字 */
const OSD_IDLE_TEXT = '无任务';
class WorkbenchService extends Service {
/**
* 查询工作台列表(仓库隔离 + 软删除过滤)
* @param {Object} params - { pagination, where }
* @returns {Promise<{list: Array, pagination: Object}>}
*/
async list(params = {}) {
const { ctx } = this;
const { Op } = ctx.app.Sequelize;
const warehouseId = ctx.user.store_id;
const { pagination = {}, where = {} } = params;
const page = Math.max(1, parseInt(pagination.page) || 1);
const pageSize = Math.min(200, Math.max(1, parseInt(pagination.pageSize) || 20));
const queryWhere = {
warehouse_id: warehouseId,
};
// 白名单字段筛选
if (where.name) {
queryWhere.name = { [Op.like]: `%${where.name}%` };
}
if (where.status !== undefined && where.status !== null && where.status !== '') {
queryWhere.status = parseInt(where.status);
}
const { count, rows } = await ctx.model.Workbench.findAndCountAll({
where: queryWhere,
attributes: { exclude: [ 'token' ] },
order: [['created_at', 'DESC']],
offset: (page - 1) * pageSize,
limit: pageSize,
});
return {
list: rows,
pagination: {
page,
pageSize,
total: count,
totalPages: Math.ceil(count / pageSize),
hasPrevious: page > 1,
hasNext: page * pageSize < count,
},
};
}
/**
* 查询单个工作台详情
* @param {number} id - 工作台 ID
* @returns {Promise<Object>}
*/
async detail(id) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
attributes: { exclude: [ 'token' ] },
});
if (!record) {
throw new Error('工作台不存在或无权访问');
}
return record;
}
/**
* 创建工作台
* @param {Object} data - { name, type, status, device_ids, remark }
* @returns {Promise<Object>}
*/
async create(data) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
if (!data.name || !String(data.name).trim()) {
throw new Error('工作台名称不能为空');
}
const record = await ctx.model.Workbench.create({
warehouse_id: warehouseId,
name: String(data.name).trim(),
type: data.type || 'personal',
status: data.status !== undefined ? parseInt(data.status) : 1,
device_ids: data.device_ids || null,
login_code: await this.generateUniqueWorkbenchLoginCode(),
remark: data.remark ? String(data.remark).trim() : null,
});
return record;
}
/**
* 更新工作台
* @param {number} id - 工作台 ID
* @param {Object} data - 要更新的字段 { name, type, status, device_ids, remark }
* @returns {Promise<Object>}
*/
async update(id, data) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权操作');
}
const updateFields = {};
if (data.name !== undefined) updateFields.name = String(data.name).trim();
if (data.type !== undefined) updateFields.type = data.type;
if (data.status !== undefined) updateFields.status = parseInt(data.status);
if (data.device_ids !== undefined) updateFields.device_ids = data.device_ids;
if (data.remark !== undefined) updateFields.remark = data.remark ? String(data.remark).trim() : null;
if (Object.keys(updateFields).length === 0) {
throw new Error('没有需要更新的字段');
}
await record.update(updateFields);
return record;
}
/**
* 软删除工作台
* @param {number} id - 工作台 ID
* @returns {Promise<void>}
*/
async delete(id) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权操作');
}
await record.destroy(); // paranoid: true → 自动设置 deleted_at
}
/**
* 绑定/解绑摄像头到工作台
* @param {number} id - 工作台 ID
* @param {number[]} cameraIds - 摄像头 ID 数组,传空数组或 null 表示解绑
* @returns {Promise<Object>}
*/
async bindCamera(id, cameraIds) {
const { ctx } = this;
const warehouseId = ctx.user.store_id;
const record = await ctx.model.Workbench.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!record) throw new Error('工作台不存在或无权操作');
const ids = Array.isArray(cameraIds) ? cameraIds : [];
if (ids.length > 0) {
const cameras = await ctx.model.Camera.findAll({
where: { id: ids, warehouse_id: warehouseId },
attributes: ['id'],
});
const validIds = cameras.map(c => c.id);
const invalidIds = ids.filter(cid => !validIds.includes(cid));
if (invalidIds.length > 0) {
throw new Error(`摄像头 ${invalidIds.join(', ')} 不存在或无权操作`);
}
}
await record.update({ device_ids: ids.length > 0 ? ids : null });
return record;
}
/**
* 工作台业务入口
* @param {string} name - 业务名称(如 queryOrder)
* @param {*} data - 业务数据
* @returns {Promise<Object>}
*/
async business(name, data) {
const { ctx } = this;
ctx.logger.info('[Systems.Workbench.business] 收到业务调度 name=%s data=%j', name, data);
switch (name) {
case 'queryOrder':
case 'query':
return await this._queryOrder(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':
return await this._sendWeight(data || {});
case '':
default:
throw new Error(`不支持的业务类型: ${name}`);
}
}
/**
* 凭打包上下文 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 分表)
*
* current 与 dispatch 两张分表的 COUNT 相互独立,使用 Promise.all 并发执行,
* 将缓存未命中时的实时统计耗时从两张表串行累加压缩为单表耗时级别;
* 单张分表查询失败时按 0 处理,不影响另一张表的统计结果。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的订单总数
*/
async _countWaveOrders(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 counts = await Promise.all(tableOrders.map(async entry => {
try {
const model = await entry.getModel();
if (!model) return 0;
return await model.count({ where: { wave_id: waveId, warehouse_id: warehouseId } });
} catch (_err) { return 0; }
}));
return counts.reduce((total, count) => total + count, 0);
}
/**
* 团购波次订单实时计数(带 Redis 短 TTL 缓存兜底)
*
* 分表 COUNT 无可用索引时扫描行数大、耗时长(生产实测 680~730ms/次)。
* wave_batch.total_orders 为多处异步维护的快照值,存在漂移风险,不能直接替代实时计数,
* 因此对实时计数结果按 (warehouseId, waveId) 维度做短 TTL 缓存:
* TTL 内重复查询直接命中缓存,缓存不可用或读取失败时降级为实时统计。
*
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<number>} 波次下 current + dispatch 两张分表的订单总数
*/
async _countWaveOrdersCached(warehouseId, waveId) {
const { ctx, app } = this;
const cacheKey = `${WAVE_ORDER_COUNT_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._countWaveOrdersCached] 读取缓存失败,降级为实时计数: %s', cacheReadErr.message);
}
}
const total = await this._countWaveOrders(warehouseId, waveId);
if (app && typeof app.setCacheAsync === 'function') {
try {
await app.setCacheAsync(cacheKey, total, WAVE_ORDER_COUNT_CACHE_TTL_SECONDS);
} catch (cacheWriteErr) {
ctx.logger.warn('[Workbench._countWaveOrdersCached] 写入缓存失败,不影响本次返回: %s', cacheWriteErr.message);
}
}
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 处理),
* 团购打包日志只写给非拦截订单,拦截订单跳过。
* @param {number} warehouseId
* @param {number} waveId
* @param {boolean} [excludeIntercepted=true] 是否排除拦截订单
* @returns {Promise<number[]>}
*/
async _getWaveOrderIds(warehouseId, waveId, excludeIntercepted = true) {
const { ctx } = this;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
const orderIds = [];
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const where = { wave_id: waveId, warehouse_id: warehouseId };
if (excludeIntercepted) {
where.intercept_status = { [ctx.app.Sequelize.Op.in]: [ 'none', null ] };
}
const rows = await model.findAll({
where,
attributes: [ 'id' ],
raw: true,
});
orderIds.push(...rows.map(r => r.id));
} catch (_err) { continue; }
}
return [ ...new Set(orderIds) ];
}
/**
* 打包任务字段白名单:只有这些字段的变化才会记入操作日志
*/
PACK_OPLOG_FIELD_WHITELIST = new Set([
'pack_mode',
'pack_quantity',
'item_quantity',
'sku_count',
'workbench_id',
'wave_no',
]);
/**
* 打包任务字段中文翻译
*/
PACK_OPLOG_FIELD_LABEL = {
pack_mode: '打包模式',
pack_quantity: '打包数量',
item_quantity: '商品总数量',
sku_count: '商品种类数',
workbench_id: '工作台',
wave_no: '波次号',
};
/**
* 打包任务字段值翻译
*/
PACK_OPLOG_VALUE_LABEL = {
pack_mode: { 1: '散单', 2: '团购' },
};
/**
* 构建打包操作日志的变更描述。
* 工作台展示名称而非 ID(名称缺失时降级为 ID)。
* @param {Object} packData 打包数据
* @param {string} [workbenchName] 工作台名称
* @returns {string} 变更描述
*/
_buildPackChangeSummary(packData, workbenchName) {
const whitelist = this.PACK_OPLOG_FIELD_WHITELIST;
const fieldLabel = this.PACK_OPLOG_FIELD_LABEL;
const valueLabel = this.PACK_OPLOG_VALUE_LABEL;
const parts = [];
for (const [ key, value ] of Object.entries(packData)) {
if (!whitelist.has(key) || value === undefined || value === null) continue;
const label = fieldLabel[key] || key;
let valStr;
if (key === 'workbench_id') {
valStr = workbenchName || String(value);
} else {
valStr = (valueLabel[key] && valueLabel[key][value] !== undefined)
? valueLabel[key][value]
: String(value);
}
parts.push(`${label}: ${valStr}`);
}
return parts.join(',');
}
/**
* 写入打包操作日志。
* - 散单:写入单个订单操作日志
* - 团购:批量写入波次下所有订单的操作日志
* 写入失败不影响主流程。
*
* @param {Object} options
* @param {number} options.warehouseId 仓库ID
* @param {number} options.orderId 当前订单ID
* @param {number} options.waveId 波次ID
* @param {string} options.waveNo 波次号
* @param {number} options.isSandan 是否散单(1=散单 0=团购)
* @param {Object} options.packData 打包数据(用于变更描述)
* @param {Array<Object>} options.users 打包人员列表
* @param {string} [options.workbenchName] 工作台名称(日志展示用,缺失时展示工作台ID)
*/
async _writePackOperationLog({ warehouseId, orderId, waveId, waveNo, isSandan, packData, users, workbenchName }) {
const { ctx } = this;
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (!operationLogService || typeof operationLogService.createOperationLogs !== 'function') {
return;
}
// 操作人信息:从 users 中取第一个作为主操作人
const operator = {
id: users && users[0] ? String(users[0].wms_account_id || users[0].id || '') : null,
name: users && users[0] ? (users[0].real_name || '') : null,
};
const changeSummary = this._buildPackChangeSummary(packData, workbenchName);
const operationCode = isSandan === 1 ? 'ORDER_PACK' : 'ORDER_PACK_GROUP';
const isFinish = Number(packData && packData.status) >= 2;
const actionText = isFinish ? '打包完成' : '开始打包';
if (isSandan === 1) {
// 散单:写入单个订单操作日志
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `散单${actionText}:${changeSummary}`,
},
}]);
ctx.logger.info('[Workbench._writePackOperationLog] 散单操作日志已写入 orderId=%d', orderId);
} else {
// 团购:批量写入波次下所有非拦截订单的操作日志(拦截订单跳过,不写日志)
if (!waveId || waveId <= 0) {
// 无波次ID时按散单处理
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `${actionText}:${changeSummary}`,
},
}]);
return;
}
const waveOrderIds = await this._getWaveOrderIds(warehouseId, waveId);
if (waveOrderIds.length === 0) {
// 波次下无订单,只写当前订单
await operationLogService.createOperationLogs([{
businessType: 'order',
businessId: String(orderId),
operationCode,
operator,
extras: {
warehouseId,
message: `${actionText}(波次 ${waveNo || waveId}):${changeSummary}`,
},
}]);
return;
}
const messagePrefix = `${isFinish ? '团购打包完成' : '团购开始打包'}(波次 ${waveNo || waveId},共${waveOrderIds.length}单):`;
const payloads = waveOrderIds.map(oid => ({
businessType: 'order',
businessId: String(oid),
operationCode,
operator,
extras: {
warehouseId,
message: `${messagePrefix}${changeSummary}`,
},
}));
await operationLogService.createOperationLogs(payloads);
ctx.logger.info('[Workbench._writePackOperationLog] 团购操作日志已批量写入 waveNo=%s orderCount=%d',
waveNo || waveId, waveOrderIds.length);
}
} catch (e) {
ctx.logger.warn('[Workbench._writePackOperationLog] 写入操作日志失败,不影响主流程', {
error: e && e.message,
orderId,
waveId,
warehouseId,
});
}
}
/**
* 更新订单打包状态字段(散单按订单ID更新单笔,团购按波次批量更新),
* 并同步补确认打印状态:扫描打包代表面单已真实存在,确认打印状态未写入
* (confirm_print_status 为 none/null)时补为 fin(团购按波次补、散单按单补),
* 补后递增统计版本号驱动 confirmPrintUnclaimedWaveCount 长轮询。
* 遍历 current + dispatch 分表,异常仅记录日志不影响主流程。
* 团购批量更新时跳过拦截订单(intercept_status 空值按 none 处理)。
*
* @param {number} warehouseId 仓库ID
* @param {Object} options
* @param {number} options.orderId 订单ID(散单使用)
* @param {number} options.waveId 波次ID(>0 时按团购批量更新)
* @param {number|string} options.packStatus 任务状态数值(1=打包中 2=已完成)
* @param {string} [options.caller] 调用方标识(仅用于日志)
* @returns {Promise<string>} 实际写入的 pack_status 值
*/
async _updateOrderPackStatus(warehouseId, { orderId, waveId, packStatus, caller = 'Workbench' }) {
const { ctx } = this;
const statusNum = parseInt(packStatus);
// 任务状态 <2(0待处理/1打包中)或未传一律视为打包中;>=2 视为已完成
const orderPackStatus = (Number.isNaN(statusNum) || statusNum < 2) ? 'padding' : 'fin';
const orderUpdateData = { pack_status: orderPackStatus };
// 扫描打包即代表面单已真实存在:确认打印状态未写入时补上(团购按波次补、散单按单补)
const confirmUpdateData = { confirm_print_status: 'fin' };
const confirmBackfillWhere = {
confirm_print_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
};
let confirmBackfilled = false;
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
if (waveId > 0) {
// 团购:批量更新波次下所有未拦截订单
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: {
wave_id: waveId,
warehouse_id: warehouseId,
intercept_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
},
});
if (affected[0] > 0) {
ctx.logger.info('[%s._updateOrderPackStatus] 团购批量更新订单打包状态 waveId=%d pack_status=%s table=%s affected=%d',
caller, waveId, orderPackStatus, entry.label, affected[0]);
}
// 波次补确认打印状态(仅未写入的订单)
const confirmAffected = await model.update(confirmUpdateData, {
where: {
wave_id: waveId,
warehouse_id: warehouseId,
intercept_status: { [ctx.app.Sequelize.Op.in]: [ 'none', null ] },
...confirmBackfillWhere,
},
});
if (confirmAffected[0] > 0) {
confirmBackfilled = true;
ctx.logger.info('[%s._updateOrderPackStatus] 团购波次补确认打印状态 waveId=%d table=%s affected=%d',
caller, waveId, entry.label, confirmAffected[0]);
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
}
}
} else {
// 散单:按订单ID更新单个订单
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const affected = await model.update(orderUpdateData, {
where: { id: orderId, warehouse_id: warehouseId },
});
if (affected[0] > 0) {
ctx.logger.info('[%s._updateOrderPackStatus] 更新订单打包状态 orderId=%d pack_status=%s table=%s',
caller, orderId, orderPackStatus, entry.label);
// 按单补确认打印状态(仅未写入时)
try {
const confirmAffected = await model.update(confirmUpdateData, {
where: {
id: orderId,
warehouse_id: warehouseId,
...confirmBackfillWhere,
},
});
if (confirmAffected[0] > 0) {
confirmBackfilled = true;
ctx.logger.info('[%s._updateOrderPackStatus] 散单补确认打印状态 orderId=%d table=%s',
caller, orderId, entry.label);
}
} catch (confirmErr) {
ctx.logger.warn('[%s._updateOrderPackStatus] 补确认打印状态失败 orderId=%d table=%s: %s',
caller, orderId, entry.label, confirmErr.message);
}
break;
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
}
}
}
// 补了确认打印后递增统计版本号,驱动 confirmPrintUnclaimedWaveCount 长轮询
if (confirmBackfilled) {
try {
const waveService = ctx.service
&& ctx.service.systemMethods
&& ctx.service.systemMethods.order
&& ctx.service.systemMethods.order.wave;
if (waveService && typeof waveService.bumpConfirmPrintUnclaimedWaveVersion === 'function') {
await waveService.bumpConfirmPrintUnclaimedWaveVersion(warehouseId);
}
} catch (err) {
ctx.logger.warn('[%s._updateOrderPackStatus] 统计版本号递增失败: %s', caller, err.message);
}
}
return orderPackStatus;
}
/**
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录。
* 兼容一单多号(主单号/子单号):传入 waybill_code 时按「订单 + 运单号」维度
* 记录打包流水与去重,主/子单号流水互不覆盖;未传时保持订单维度(兼容旧设备端)。
* 打包人:上报了 users(business 旧链路)以上报为准,未上报(token+key 新链路)自动回填工作台绑定成员。
* @param {Object} params - { delivery_order_code, wave_no, warehouse_id, workbench_id, status, pack_time, waybill_code, users }
* @param {string} [params.waybill_code] 扫描打包的运单号(可选,用于运单维度记录流水)
* @returns {Promise<Object>}
*/
async _packOrder(params) {
const { ctx } = this;
const { delivery_order_code: deliveryOrderCode, wave_no: waveNo,
warehouse_id: inputWarehouseId, workbench_id: workbenchIdRaw,
status: packStatus, pack_time: packTime,
wave_total_orders: waveTotalOrders,
items_count: itemsCount,
items_total: itemsTotal,
waybill_code: waybillCodeParam,
users: usersParam } = params;
if (!deliveryOrderCode) throw new Error('发货单号不能为空');
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
// 防护 NaN:parseInt 对非数字字符串返回 NaN,会导致 Sequelize 生成非法 SQL
const workbenchId = (workbenchIdRaw !== undefined && workbenchIdRaw !== null && workbenchIdRaw !== '')
? parseInt(workbenchIdRaw)
: null;
const validWorkbenchId = (workbenchId !== null && !isNaN(workbenchId) && workbenchId > 0)
? workbenchId
: null;
const packTimeMs = packTime ? Number(packTime) * 1000 : Date.now();
// 步骤1:查找订单
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
let orderRow = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model) continue;
const row = await model.findOne({
where: { delivery_order_code: deliveryOrderCode, warehouse_id: warehouseId },
raw: true,
});
if (row) { orderRow = row; break; }
} catch (_err) { continue; }
}
if (!orderRow) throw new Error(`未找到发货单 [${deliveryOrderCode}]`);
const orderId = orderRow.id;
const waveId = orderRow.wave_id || 0;
const actualWaveNo = waveNo || orderRow.wave_no || '';
// 步骤2:获取波次信息,判断散单/团购
let waveType = null;
let totalOrders = 0;
let isSandan = 1;
if (waveId > 0) {
try {
const waveBatch = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: ['wave_type', 'total_orders'],
raw: true,
});
if (waveBatch) {
waveType = waveBatch.wave_type;
isSandan = Number(waveType) === 1 ? 0 : 1;
// 实时统计波次订单数(而非依赖 wave_batch.total_orders 快照)
totalOrders = await this._countWaveOrders(warehouseId, waveId);
}
} catch (_err) { /* ignore */ }
}
// 拦截流程中的订单不允许打包:
// - 散单:直接拒绝(保持原行为);
// - 团购波次:静默跳过并视为完成(返回完成结构,不带任何提示字段),
// 不创建打包任务、不写操作日志,不阻断波次整体提交完成。
if (isInterceptedOrderStatus(orderRow.intercept_status)) {
if (isSandan === 0) {
ctx.logger.info('[Workbench._packOrder] 团购波次拦截订单静默跳过 waveId=%d waveNo=%s orderId=%d deliveryOrderCode=%s',
waveId, actualWaveNo, orderId, deliveryOrderCode);
return {
order_id: orderId,
delivery_order_code: deliveryOrderCode,
wave_no: actualWaveNo,
isSandan: 0,
pack_mode: 2,
status: 2,
batch: { wave_id: waveId, wave_no: actualWaveNo, wave_type: waveType, total_orders: totalOrders },
};
}
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 = '';
if (validWorkbenchId) {
try {
const wb = await ctx.model.Workbench.findByPk(validWorkbenchId, {
attributes: [ 'name', 'device_ids' ],
raw: true,
});
deviceIds = wb && wb.device_ids ? wb.device_ids : null;
workbenchName = (wb && wb.name) || '';
} catch (_err) { /* ignore */ }
}
// 步骤4:同一工作台有新的打包任务时,关闭上一个未结束的任务
// 旧任务关闭会先把 OSD 复位为「无任务」,该 Promise 由步骤7.5 串行等待,避免复位覆盖新任务文字
let previousTaskOsdResetPromise = null;
if (validWorkbenchId) {
const previousTask = await ctx.model.PackTask.findOne({
where: {
workbench_id: validWorkbenchId,
warehouse_id: warehouseId,
order_id: { [ctx.app.Sequelize.Op.ne]: orderId },
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
});
if (previousTask) {
const previousEndTime = await this.resolvePackTaskEndTime(previousTask, new Date(packTimeMs));
await previousTask.update({ end_time: previousEndTime, status: 2 });
ctx.logger.info('[Workbench._packOrder] 关闭上一个未结束任务 taskId=%d orderId=%d workbenchId=%d',
previousTask.id, previousTask.order_id, validWorkbenchId);
// 同步旧任务关联订单打包状态(与 _finishPack 语义一致,避免旧订单 pack_status 停留打包中)
const prevIsGroupTask = Number(previousTask.pack_mode) === 2;
const prevTaskWaveId = prevIsGroupTask ? Number(previousTask.wave_id || 0) : 0;
await this._updateOrderPackStatus(warehouseId, {
orderId: Number(previousTask.order_id || 0),
waveId: prevTaskWaveId,
packStatus: 2,
caller: 'Workbench._packOrder.closePrevious',
});
// 旧任务已结束:OSD 复位为「无任务」(不阻塞请求,步骤7.5 会等其完成后再下发新任务文字)
previousTaskOsdResetPromise = this._resetPackOsd({
warehouseId,
workbenchId: validWorkbenchId,
});
}
}
// 步骤5:去重 — 散单按 order_id(未传运单号时)/order_id+waybill_code(传运单号时)
// 物理删除旧记录,团购按 wave_no 物理删除旧记录;
// 一单多号场景按运单维度去重,主单号/子单号的打包流水互不覆盖;
// 传运单号时同时清理同订单历史订单级(waybill_code 为空)旧流水,
// 避免空值幽灵记录导致其它运单被误判为已打包。
if (isSandan === 1) {
// 散单去重:先收集旧任务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: sandanDedupeWhere,
attributes: ['id'],
raw: true,
paranoid: false,
});
if (oldTasks.length > 0) {
const oldTaskIds = oldTasks.map(t => t.id);
await ctx.model.PackTaskPacker.destroy({
where: { pack_task_id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
await ctx.model.PackTask.destroy({
where: { id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
ctx.logger.info('[Workbench._packOrder] 散单去重:物理删除 %d 条旧记录 orderId=%d', oldTasks.length, orderId);
}
} else {
// 团购:按 wave_no 去重,先收集旧任务ID清理关联打包人,再物理移除旧任务
if (actualWaveNo) {
const oldTasks = await ctx.model.PackTask.findAll({
where: { wave_no: actualWaveNo, warehouse_id: warehouseId },
attributes: ['id'],
raw: true,
paranoid: false,
});
if (oldTasks.length > 0) {
const oldTaskIds = oldTasks.map(t => t.id);
await ctx.model.PackTaskPacker.destroy({
where: { pack_task_id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
await ctx.model.PackTask.destroy({
where: { id: { [ctx.app.Sequelize.Op.in]: oldTaskIds } },
force: true,
});
ctx.logger.info('[Workbench._packOrder] 团购去重:物理删除 %d 条旧记录 waveNo=%s', oldTasks.length, actualWaveNo);
}
}
}
// 步骤6:创建新的打包任务
// 设备端未传/非法 status 一律归一化为 1(打包中),避免 NaN 入库与日志异常
const parsedPackStatus = Number.parseInt(packStatus, 10);
const normalizedPackStatus = Number.isFinite(parsedPackStatus) ? parsedPackStatus : 1;
// 服务端复查落库口径:打包数量/商品总件数/商品种类数均以服务端为准,
// 散单取订单分表(orderRow),团购取波次实时统计(totalOrders + 波次商品 SKU 聚合),
// 设备端上报值仅作交叉校验日志,不直接落库,防止前端输入失真。
let packQuantity = 1;
let packItemQuantity = Number(orderRow.items_total) || 0;
let packSkuCount = Number(orderRow.items_count) || 0;
if (isSandan === 0) {
// 团购:打包数量 = 波次实时订单数(步骤2 已统计,异常兜底 1)
packQuantity = Number.isFinite(totalOrders) && totalOrders > 0 ? totalOrders : 1;
// 团购:商品总件数/商品种类数 = 波次商品 SKU 聚合(15s 短缓存兜底,异常降级为扫描订单值)
let waveItemsSummary = [];
try {
waveItemsSummary = await this._fetchWaveItemsSummary(warehouseId, waveId);
} catch (summaryErr) {
ctx.logger.warn('[Workbench._packOrder] 波次商品聚合失败,商品件数降级为扫描订单值: %s', summaryErr.message);
}
if (Array.isArray(waveItemsSummary) && waveItemsSummary.length > 0) {
packSkuCount = waveItemsSummary.length;
const waveItemsTotal = waveItemsSummary.reduce((sum, item) => sum + (Number(item.plan_qty) || 0), 0);
if (waveItemsTotal > 0) {
packItemQuantity = waveItemsTotal;
}
}
}
// 交叉校验:设备端上报值与服务端复查不一致时仅记日志,落库以服务端为准
const deviceWaveTotal = (waveTotalOrders !== undefined && waveTotalOrders !== null && waveTotalOrders !== '')
? parseInt(waveTotalOrders)
: 0;
const deviceItemsTotal = (itemsTotal !== undefined && itemsTotal !== null && itemsTotal !== '')
? parseInt(itemsTotal)
: 0;
const deviceItemsCount = (itemsCount !== undefined && itemsCount !== null && itemsCount !== '')
? parseInt(itemsCount)
: 0;
if (isSandan === 0 && Number.isFinite(deviceWaveTotal) && deviceWaveTotal > 0 && deviceWaveTotal !== packQuantity) {
ctx.logger.info('[Workbench._packOrder] 打包数量复查不一致 waveId=%d 设备端=%d 服务端=%d(以服务端为准)',
waveId, deviceWaveTotal, packQuantity);
}
if (Number.isFinite(deviceItemsTotal) && deviceItemsTotal > 0 && deviceItemsTotal !== packItemQuantity) {
ctx.logger.info('[Workbench._packOrder] 商品总件数复查不一致 orderId=%d waveId=%d 设备端=%d 服务端=%d(以服务端为准)',
orderId, waveId, deviceItemsTotal, packItemQuantity);
}
if (Number.isFinite(deviceItemsCount) && deviceItemsCount > 0 && deviceItemsCount !== packSkuCount) {
ctx.logger.info('[Workbench._packOrder] 商品种类数复查不一致 orderId=%d waveId=%d 设备端=%d 服务端=%d(以服务端为准)',
orderId, waveId, deviceItemsCount, packSkuCount);
}
const packData = {
order_id: orderId,
warehouse_id: warehouseId,
workbench_id: validWorkbenchId,
wave_id: waveId,
wave_no: actualWaveNo,
waybill_code: packWaybillCode, // 散单运单维度打包时记录运单号;未传运单号(旧设备端)或团购保持 null
pack_mode: isSandan === 0 ? 2 : 1, // 1=散单 2=团购
status: normalizedPackStatus,
pack_quantity: packQuantity,
item_quantity: packItemQuantity,
sku_count: packSkuCount,
start_time: new Date(packTimeMs),
end_time: normalizedPackStatus >= 2 ? new Date(packTimeMs) : null,
device_ids: deviceIds,
};
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, {
orderId,
waveId: isSandan === 1 ? 0 : waveId,
packStatus: packData.status,
caller: 'Workbench._packOrder',
});
// 步骤7:写入打包人员信息
// 上报了 users(business 旧链路)时以上报为准;未上报(token+key 新链路)时
// 自动回填该工作台绑定成员(成员登入/登出链路 bindMember/removeMember 已持久化到 wms_workbench_member)。
let users = Array.isArray(usersParam) && usersParam.length > 0 ? usersParam : [];
if (users.length === 0 && 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 对
// NULL 不生效,避免多人打包(account_id 全为 0)时违反唯一约束导致主流程中断。
// 真实账号仍按 account_id 去重;无账号时按姓名去重。
const seenPackerKeys = new Set();
const packerRecords = [];
for (const user of users) {
const accountIdRaw = user.wms_account_id != null
? user.wms_account_id
: (user.id != null ? user.id : null);
const accountId = accountIdRaw != null ? (parseInt(accountIdRaw) || null) : null;
const accountName = user.real_name || '';
const dedupeKey = accountId !== null ? `id:${accountId}` : `name:${accountName}`;
if (seenPackerKeys.has(dedupeKey)) continue;
seenPackerKeys.add(dedupeKey);
packerRecords.push({
pack_task_id: packTask.id,
account_id: accountId,
account_name: accountName,
seq: packerRecords.length,
});
}
if (packerRecords.length > 0) {
await ctx.model.PackTaskPacker.bulkCreate(packerRecords);
}
operatorText = users.map(u => u.real_name || '').filter(Boolean).join(',');
// 回写 operator_text 到打包任务
await packTask.update({ operator_text: operatorText });
ctx.logger.info('[Workbench._packOrder] 写入 %d 个打包人员 operatorText=%s', users.length, operatorText);
}
// 步骤7.5:下发 OSD 叠加到工作台绑定的摄像头(带 Redis 缓存去重)
const cameraIds = Array.isArray(deviceIds) ? deviceIds : [];
if (cameraIds.length > 0) {
let osdText = '';
if (isSandan === 1) {
// 散单:优先打包时传入的运单号(一单多号时展示当前打包运单),
// 未传时查订单首个运单,兜底发货单号
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}单`;
}
// 缓存写入 + 逐台摄像头下发整体异步执行,不阻塞打包主流程
const applyOsd = async () => {
// 写入 OSD 缓存
try {
const osdCacheKey = `${OSD_CACHE_KEY_PREFIX}${validWorkbenchId}`;
await this.app.setCacheAsync(osdCacheKey, osdText, OSD_CACHE_TTL_SECONDS);
ctx.logger.info('[Workbench._packOrder] OSD缓存已写入 workbenchId=%d text=%s',
validWorkbenchId, osdText);
} catch (cacheErr) {
ctx.logger.warn('[Workbench._packOrder] OSD缓存写入失败 workbenchId=%d err=%s',
validWorkbenchId, cacheErr.message);
}
const OsdClient = require('../../lib/osd_client');
const osdClient = new OsdClient(ctx);
try {
await Promise.all(cameraIds.map(async cameraId => {
try {
const camera = await ctx.model.Camera.findOne({
where: { id: cameraId, warehouse_id: warehouseId },
raw: true,
});
if (!camera || !camera.ip) return;
const result = await osdClient.setOsd({
camera,
warehouseId,
text: osdText,
});
if (!result.success) {
ctx.logger.warn('[Workbench._packOrder] OSD下发失败 cameraId=%d error=%s',
cameraId, result.error || '打印服务返回异常');
}
} catch (err) {
ctx.logger.warn('[Workbench._packOrder] OSD下发异常 cameraId=%d err=%s', cameraId, err.message);
}
}));
} catch (err) {
ctx.logger.warn('[Workbench._packOrder] OSD批量下发异常 err=%s', err.message);
}
};
// 若本请求关闭了上一个未结束任务,需等 OSD 复位为「无任务」完成后再下发新任务文字
const osdTask = previousTaskOsdResetPromise
? previousTaskOsdResetPromise.then(applyOsd)
: applyOsd();
osdTask.catch(err => {
ctx.logger.warn('[Workbench._packOrder] OSD下发流程异常 err=%s', err.message);
});
}
// 步骤8:写入操作日志(散单写单个订单,团购批量写波次所有订单)
await this._writePackOperationLog({
warehouseId,
orderId,
waveId,
waveNo: actualWaveNo,
isSandan,
packData,
users,
workbenchName,
});
const result = {
task_id: packTask.id,
order_id: orderId,
delivery_order_code: deliveryOrderCode,
wave_no: actualWaveNo,
isSandan,
pack_mode: packData.pack_mode,
status: packData.status,
};
// 团购单附加波次总量
if (isSandan === 0) {
result.batch = { wave_id: waveId, wave_no: actualWaveNo, wave_type: waveType, total_orders: totalOrders };
}
return result;
}
/**
* 按仓库配置的打包最大时长约束任务结束时间。
* 候选结束时间超过 开始时间+上限时长 时,截断为上限时间点。
* 未配置有效时长或开始时间非法时不做约束,原样返回。
*
* @param {Object} packTask 打包任务实例(需含 warehouse_id / pack_mode / start_time)
* @param {Date|string} endTime 候选结束时间
* @return {Promise<Date>} 约束后的结束时间
*/
async resolvePackTaskEndTime(packTask, endTime) {
const { ctx } = this;
const candidate = endTime instanceof Date ? endTime : new Date(endTime);
if (!packTask || !Number.isFinite(candidate.getTime())) {
return endTime;
}
const startMs = new Date(packTask.start_time).getTime();
if (!Number.isFinite(startMs)) {
return endTime;
}
const isGroup = Number(packTask.pack_mode) === 2;
let limitMinutes = null;
try {
const warehouseId = Number(packTask.warehouse_id || 0);
const subjectConfig = await ctx.service.systems.deliveryOrder.getStoreSubjectConfig(warehouseId);
const rawMinutes = isGroup
? subjectConfig.group_order_pack_max_minutes
: subjectConfig.single_order_pack_max_minutes;
limitMinutes = Number(rawMinutes);
} catch (error) {
ctx.logger.warn('[Workbench.resolvePackTaskEndTime] 读取仓库配置失败: %s', error.message);
}
// 未配置有效时长时不约束结束时间
if (!Number.isInteger(limitMinutes) || limitMinutes <= 0) {
return endTime;
}
const maxEndMs = startMs + limitMinutes * 60 * 1000;
if (candidate.getTime() > maxEndMs) {
const cappedEndTime = new Date(maxEndMs);
ctx.logger.info(
'[Workbench.resolvePackTaskEndTime] 结束时间超过打包上限,截断为上限时间 taskId=%d packMode=%s limitMinutes=%d end=%s',
packTask.id,
isGroup ? 'group' : 'single',
limitMinutes,
cappedEndTime.toISOString()
);
return cappedEndTime;
}
return endTime;
}
/**
* 工作台打包完成:传入工作台ID,查找最后一个未结束的打包任务并结束
* @param {Object} params - { workbench_id, warehouse_id }
* @returns {Promise<Object>}
*/
async _finishPack(params) {
const { ctx } = this;
const { workbench_id: workbenchIdRaw, warehouse_id: inputWarehouseId } = params;
if (!inputWarehouseId) throw new Error('仓库ID不能为空');
const warehouseId = parseInt(inputWarehouseId);
const workbenchId = (workbenchIdRaw !== undefined && workbenchIdRaw !== null && workbenchIdRaw !== '')
? parseInt(workbenchIdRaw)
: null;
const validWorkbenchId = (workbenchId !== null && !isNaN(workbenchId) && workbenchId > 0)
? workbenchId
: null;
if (!validWorkbenchId) throw new Error('工作台ID不能为空');
// 查找该工作台最后一个未结束的打包任务(按 id 倒序取最新)
const lastTask = await ctx.model.PackTask.findOne({
where: {
workbench_id: validWorkbenchId,
warehouse_id: warehouseId,
status: { [ctx.app.Sequelize.Op.lt]: 2 },
},
order: [[ 'id', 'DESC' ]],
});
if (!lastTask) {
ctx.logger.info('[Workbench._finishPack] 工作台 %d 无未结束的打包任务', validWorkbenchId);
return { workbench_id: validWorkbenchId, finished: false, message: '无未结束的打包任务' };
}
const now = new Date();
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);
// 打包任务结束:复位工作台摄像头 OSD 为「无任务」(异步执行,不阻塞主流程)
this._resetPackOsd({ warehouseId, workbenchId: validWorkbenchId }).catch(err => {
ctx.logger.warn('[Workbench._finishPack] OSD复位异常 workbenchId=%d err=%s',
validWorkbenchId, err.message);
});
// 同步更新关联订单打包状态:散单更新单笔订单,团购批量更新波次下所有未拦截订单
const isGroupTask = Number(lastTask.pack_mode) === 2;
const taskOrderId = Number(lastTask.order_id || 0);
const taskWaveId = isGroupTask ? Number(lastTask.wave_id || 0) : 0;
await this._updateOrderPackStatus(warehouseId, {
orderId: taskOrderId,
waveId: taskWaveId,
packStatus: 2,
caller: 'Workbench._finishPack',
});
// 写入完成操作日志(团购批量写波次订单,操作人取自任务记录 operator_text)
let workbenchName = '';
try {
const wb = await ctx.model.Workbench.findByPk(validWorkbenchId, {
attributes: [ 'name' ],
raw: true,
});
workbenchName = (wb && wb.name) || '';
} catch (_err) { /* ignore */ }
const operatorText = String(lastTask.operator_text || '');
await this._writePackOperationLog({
warehouseId,
orderId: taskOrderId,
waveId: taskWaveId,
waveNo: lastTask.wave_no || '',
isSandan: isGroupTask ? 0 : 1,
packData: {
pack_mode: lastTask.pack_mode,
status: 2,
pack_quantity: lastTask.pack_quantity,
item_quantity: lastTask.item_quantity,
sku_count: lastTask.sku_count,
workbench_id: validWorkbenchId,
wave_no: lastTask.wave_no,
},
users: operatorText ? [{ real_name: operatorText }] : [],
workbenchName,
});
return {
workbench_id: validWorkbenchId,
finished: true,
task_id: lastTask.id,
order_id: lastTask.order_id,
end_time: endTime,
};
}
/**
* 打包任务结束后复位工作台摄像头 OSD 叠加文字为「无任务」。
* 覆盖所有结束路径:工作台手动结束(_finishPack)、新任务关闭旧任务(_packOrder)、
* 定时任务自动结束(packTaskAutoFinish)。
* - 回写 Redis osd_{workbenchId} 缓存为「无任务」,避免缓存残留上一个任务文字;
* - 逐台摄像头下发「无任务」,失败仅打印告警,不影响打包主流程;
* - 内部已捕获全部异常,永不 reject。
*
* @param {Object} params - { warehouseId, workbenchId }
* @return {Promise<void>} 无返回值
*/
async _resetPackOsd(params = {}) {
const { ctx } = this;
const warehouseId = parseInt(params.warehouseId);
const workbenchId = parseInt(params.workbenchId);
if (!Number.isInteger(warehouseId) || warehouseId <= 0) return;
if (!Number.isInteger(workbenchId) || workbenchId <= 0) return;
// 1. 回写 OSD 缓存为「无任务」,与摄像头实际叠加文字保持一致
try {
await this.app.setCacheAsync(
`${OSD_CACHE_KEY_PREFIX}${workbenchId}`,
OSD_IDLE_TEXT,
OSD_CACHE_TTL_SECONDS
);
} catch (cacheErr) {
ctx.logger.warn('[Workbench._resetPackOsd] OSD缓存写入失败 workbenchId=%d err=%s',
workbenchId, cacheErr.message);
}
// 2. 查询工作台绑定的摄像头
let deviceIds = null;
try {
const wb = await ctx.model.Workbench.findByPk(workbenchId, {
attributes: [ 'device_ids' ],
raw: true,
});
deviceIds = wb && wb.device_ids ? wb.device_ids : null;
} catch (err) {
ctx.logger.warn('[Workbench._resetPackOsd] 读取工作台绑定设备失败 workbenchId=%d err=%s',
workbenchId, err.message);
return;
}
const cameraIds = Array.isArray(deviceIds) ? deviceIds : [];
if (cameraIds.length === 0) return;
const OsdClient = require('../../lib/osd_client');
const osdClient = new OsdClient(ctx);
await Promise.all(cameraIds.map(async cameraId => {
try {
const camera = await ctx.model.Camera.findOne({
where: { id: cameraId, warehouse_id: warehouseId },
raw: true,
});
if (!camera || !camera.ip) return;
const result = await osdClient.setOsd({
camera,
warehouseId,
text: OSD_IDLE_TEXT,
});
if (!result.success) {
ctx.logger.warn('[Workbench._resetPackOsd] OSD复位失败 cameraId=%d error=%s',
cameraId, result.error || '打印服务返回异常');
}
} catch (err) {
ctx.logger.warn('[Workbench._resetPackOsd] OSD复位异常 cameraId=%d err=%s', cameraId, err.message);
}
}));
ctx.logger.info('[Workbench._resetPackOsd] 打包任务结束,OSD已复位为「%s」workbenchId=%d cameras=%d',
OSD_IDLE_TEXT, workbenchId, cameraIds.length);
}
/**
* 称重上报:条码(sn) → 运单号 → 更新称重重量
* 支持散单直接更新和团购波次批量称重
* @param {Object} params - { barcode, weight(克), warehouseId }
* @returns {Promise<Object>} weighing_weight/total_weight 单位为 g
*/
async _sendWeight(params) {
const { ctx } = this;
const { barcode, weight, warehouseId: inputWarehouseId } = params;
// 参数校验
if (!barcode || !String(barcode).trim()) {
throw new Error('条码(sn)不能为空');
}
if (weight === null || weight === undefined || String(weight).trim() === '') {
throw new Error('重量(weight)不能为空');
}
if (!inputWarehouseId) {
throw new Error('仓库ID不能为空');
}
const normalizedBarcode = String(barcode).trim();
const warehouseId = parseInt(inputWarehouseId);
// 校验重量格式(入参单位:克),必须大于0
const weightText = String(weight).trim();
if (!/^\d+$/.test(weightText)) {
throw new Error('重量格式非法,必须为正整数(单位 g)');
}
const weightGram = Number(weightText);
if (!Number.isFinite(weightGram) || weightGram <= 0) {
throw new Error('重量必须大于0');
}
// DB 存储单位已统一为 g,无需转换
const normalizedWeight = weightGram;
// 步骤1:条码 → 运单记录(按 waybill_code + warehouse_id 精确匹配)
const expressRow = await ctx.model.OrderExpress.findOne({
where: {
waybill_code: normalizedBarcode,
warehouse_id: warehouseId,
delete_at: null,
},
attributes: [ 'id', 'order_id', 'waybill_code', 'business_key' ],
raw: true,
});
if (!expressRow) {
throw new Error(`未找到条码 [${normalizedBarcode}] 对应的运单记录`);
}
const orderId = Number(expressRow.order_id);
// 步骤2:遍历 current → history → dispatch 分表查找订单及波次信息
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'history', getModel: () => orderDeliveryFactory.getHistoryModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
// 序列表定位优先:命中则先查对应分表,未命中(存量订单)按原顺序回退遍历
try {
if (orderDeliveryFactory && typeof orderDeliveryFactory.getOrderLocation === 'function') {
const preferredLocation = await orderDeliveryFactory.getOrderLocation(orderId, warehouseId);
if (preferredLocation) {
tableOrders.sort((a, b) => (a.label === preferredLocation ? -1 : b.label === preferredLocation ? 1 : 0));
}
}
} catch (_err) { /* 定位失败,保持原遍历顺序 */ }
let orderRow = null;
let orderDeliveryModel = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
attributes: [ 'id', 'wave_id', 'wave_no', 'items_weight', 'intercept_status' ],
raw: true,
});
if (row) {
orderRow = row;
orderDeliveryModel = model;
break;
}
} catch (_err) {
ctx.logger.warn('[Workbench._sendWeight] 查询表 %s 失败: %s', entry.label, _err.message);
continue;
}
}
if (!orderRow) {
throw new Error(`未找到运单对应的订单 [id=${orderId}, warehouse=${warehouseId}]`);
}
// 拦截流程中的订单不允许称重
if (isInterceptedOrderStatus(orderRow.intercept_status)) {
throw new Error(`订单已被拦截,无法称重 [${normalizedBarcode}]`);
}
const waveId = Number(orderRow.wave_id || 0);
// 步骤3:散单(wave_id=0)→ 仅更新该运单的称重重量
if (waveId === 0) {
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{ where: { id: Number(expressRow.id) } }
);
ctx.logger.info('[Workbench._sendWeight] 散单称重 barcode=%s orderId=%d weightG=%s',
normalizedBarcode, orderId, normalizedWeight);
// 写入操作日志
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
order_id: orderId,
weighing_weight: normalizedWeight,
items_weight: Number(orderRow.items_weight || 0),
mode: 'single',
};
}
// 步骤4:查询波次类型,判断是否为团购波次
const waveRow = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'wave_id', 'wave_no', 'wave_type' ],
raw: true,
});
// 非团购波次 → 降级为散单逻辑
if (!waveRow || Number(waveRow.wave_type) !== 1) {
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{ where: { id: Number(expressRow.id) } }
);
ctx.logger.info('[Workbench._sendWeight] 非团购波次称重 barcode=%s orderId=%d weightG=%s waveType=%s',
normalizedBarcode, orderId, normalizedWeight, waveRow ? waveRow.wave_type : 'N/A');
// 写入操作日志
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
order_id: orderId,
weighing_weight: normalizedWeight,
items_weight: Number(orderRow.items_weight || 0),
mode: 'single',
};
}
// 步骤5:团购波次(wave_type=1)→ 批量更新波次下所有运单的称重重量
const { Op } = ctx.app.Sequelize;
const waveOrders = await orderDeliveryModel.findAll({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: [ 'id', 'intercept_status' ],
raw: true,
});
if (!waveOrders || waveOrders.length === 0) {
throw new Error('波次下未找到订单');
}
// 波次内拦截订单不参与批量称重
const interceptedWaveOrderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
const orderIds = (Array.isArray(waveOrders) ? waveOrders : [])
.filter(o => !isInterceptedOrderStatus(o && o.intercept_status))
.map(o => Number(o.id));
if (interceptedWaveOrderIds.length > 0) {
ctx.logger.info('[Workbench._sendWeight] 波次内拦截订单不参与称重 waveId=%d orderIds=%s',
waveId, interceptedWaveOrderIds.join(','));
}
const totalCount = orderIds.length;
await ctx.model.OrderExpress.update(
{ weighing_weight: normalizedWeight },
{
where: {
order_id: { [Op.in]: orderIds },
delete_at: null,
warehouse_id: warehouseId,
},
}
);
ctx.logger.info('[Workbench._sendWeight] 团购波次批量称重 barcode=%s waveId=%d waveNo=%s orderCount=%d weightG=%s',
normalizedBarcode, waveId, waveRow.wave_no, totalCount, normalizedWeight);
// 写入操作日志(团购波次:逐订单批量写入)
await this._writeWeighOpLog({
orderId,
barcode: normalizedBarcode,
weightGram,
normalizedWeight,
warehouseId,
waveId,
waveNo: String(waveRow.wave_no || ''),
waveOrderIds: orderIds,
});
return {
barcode: normalizedBarcode,
waybill_code: normalizedBarcode,
wave_id: waveId,
wave_no: String(waveRow.wave_no || ''),
weighing_weight: normalizedWeight,
total_weight: normalizedWeight * totalCount,
order_count: totalCount,
items_weight: Number(orderRow.items_weight || 0),
mode: 'wave',
};
}
/**
* 写入称重操作日志(内部方法,失败不影响主流程)
* @param {Object} opts
* @param {number} opts.orderId 触发订单ID
* @param {string} opts.barcode 条码/运单号
* @param {number} opts.weightGram 称重重量(克)
* @param {number} opts.normalizedWeight 称重重量(克)
* @param {number} opts.warehouseId 仓库ID
* @param {number} [opts.waveId] 波次ID(团购时传入)
* @param {string} [opts.waveNo] 波次号
* @param {number[]} [opts.waveOrderIds] 波次下所有订单ID(团购时传入,逐条写日志)
*/
async _writeWeighOpLog(opts = {}) {
const { ctx } = this;
const {
orderId, barcode, weightGram, normalizedWeight, warehouseId,
waveId, waveNo, waveOrderIds,
} = opts;
try {
const operationLogService = ctx.service && ctx.service.systems && ctx.service.systems.operationLog;
if (!operationLogService || typeof operationLogService.createOperationLogs !== 'function') {
return;
}
const isWave = waveId && waveId > 0 && Array.isArray(waveOrderIds) && waveOrderIds.length > 0;
const operator = { id: '', name: 'system' };
if (isWave) {
// 团购波次:逐订单批量写入操作日志
const orderCount = waveOrderIds.length;
const message = `工作台团购波次称重 ${normalizedWeight}g,波次 ${waveNo || waveId},共 ${orderCount} 单,触发条码 ${barcode}`;
const payloads = waveOrderIds.map(oid => ({
businessType: 'order',
businessId: String(oid),
operationCode: 'ORDER_WEIGH',
operator,
extras: {
warehouseId,
message,
barcode,
weightGram,
weighingWeight: normalizedWeight,
waveId,
waveNo: waveNo || '',
orderCount,
},
}));
await operationLogService.createOperationLogs(payloads);
ctx.logger.info('[Workbench._writeWeighOpLog] 团购称重操作日志已批量写入 waveId=%d orderCount=%d',
waveId, orderCount);
} else {
// 散单:单条操作日志
const payload = {
businessType: 'order',
businessId: String(orderId),
operationCode: 'ORDER_WEIGH',
operator,
extras: {
warehouseId,
message: `工作台称重 ${normalizedWeight}g,条码 ${barcode}`,
barcode,
weightGram,
weighingWeight: normalizedWeight,
orderId,
},
};
await operationLogService.createOperationLogs([ payload ]);
ctx.logger.info('[Workbench._writeWeighOpLog] 散单称重操作日志已写入 orderId=%d barcode=%s',
orderId, barcode);
}
} catch (e) {
ctx.logger.warn('[Workbench._writeWeighOpLog] 写入操作日志失败,不影响主流程', {
error: e && e.message,
orderId,
barcode,
});
}
}
/**
* 实时聚合波次商品明细(无缓存,供 _fetchWaveItemsSummary 调用)。
* 口径:波次下全部未拦截订单(current + dispatch 分表)的商品明细行按 SKU 聚合计划数量
* (stock_id 优先作聚合键,缺省按 item_code+item_name),并合并 stock 详情(条码/图片/包装要求/是否需要复核);
* 任一环节异常均降级返回空数组,不抛错。
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<Array<Object>>} 波次商品聚合数组(结构与散单 items 一致,另附 is_wave_summary=true)
*/
async _aggregateWaveItems(warehouseId, waveId) {
const { ctx } = this;
try {
const orderIds = await this._getWaveOrderIds(warehouseId, waveId, true);
if (!orderIds || orderIds.length === 0) return [];
const orderItemsFactory = ctx.model.OrderItemsFactory;
const itemTables = [
{ getModel: () => orderItemsFactory.getCurrentModel(warehouseId) },
{ getModel: () => orderItemsFactory.getDispatchModel(warehouseId) },
];
const itemRows = [];
for (const entry of itemTables) {
try {
const model = await entry.getModel();
if (!model) continue;
const rows = await model.findAll({
where: { order_id: { [ctx.app.Sequelize.Op.in]: orderIds } },
attributes: [
'id', 'order_id', 'item_id', 'item_code', 'item_name',
'plan_qty', 'actual_price', 'stock_id', 'order_line_no',
'inventory_type',
],
raw: true,
});
itemRows.push(...rows);
} catch (_err) { continue; }
}
if (itemRows.length === 0) return [];
// 按 SKU 聚合(stock_id 优先作聚合键,缺省按 item_code+item_name)
const aggregateMap = new Map();
for (const row of itemRows) {
const stockId = Number(row.stock_id || 0);
const itemCode = String(row.item_code || '').trim();
const itemName = String(row.item_name || '').trim();
const key = stockId > 0 ? `stock:${stockId}` : `code:${itemCode}||${itemName}`;
if (!key) continue;
const planQty = Number(row.plan_qty || 0);
if (!aggregateMap.has(key)) {
aggregateMap.set(key, {
stock_id: stockId,
item_id: row.item_id,
item_code: itemCode,
item_name: itemName,
plan_qty: 0,
inventory_type: row.inventory_type || '',
});
}
aggregateMap.get(key).plan_qty += planQty;
}
const aggregates = Array.from(aggregateMap.values());
const stockIds = [ ...new Set(aggregates.map(a => a.stock_id).filter(id => id > 0)) ];
const stockMap = new Map();
if (stockIds.length > 0) {
try {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(stockIds, { warehouseId });
for (const detail of stockDetails) {
stockMap.set(Number(detail.id), detail);
}
} catch (stockErr) {
ctx.logger.warn('[Workbench._aggregateWaveItems] 查询 stock 详情失败: %s', stockErr.message);
}
}
return aggregates.map(agg => {
const stock = stockMap.get(agg.stock_id) || {};
return {
id: 0,
order_id: 0,
item_id: agg.item_id,
item_code: agg.item_code || stock.item_code || '',
item_name: agg.item_name || stock.item_name || '',
plan_qty: agg.plan_qty,
actual_price: null,
stock_id: agg.stock_id,
order_line_no: '',
inventory_type: agg.inventory_type || '',
sku_property: stock.sku_property || '',
stock_unit: stock.stock_unit || '',
barcodes: stock.barcodes || [],
image_url: stock.image_url || [],
packing_requirements: String(stock.packing_requirements || '').trim(),
need_recheck: String(stock.need_recheck || 'Y').trim(),
is_wave_summary: true,
};
});
} catch (err) {
ctx.logger.warn('[Workbench._aggregateWaveItems] 聚合波次商品失败 waveId=%d: %s', waveId, err.message);
return [];
}
}
/**
* 团购波次商品 SKU 聚合汇总(带 Redis 短 TTL 缓存兜底,供 getWorkbenchInfo 团购任务 items 返回)。
* 波次商品明细量大(动辄数百单),逐单返回明细开销高且无必要,
* 因此按 (warehouseId, waveId) 维度做 15s 短缓存(与 _countWaveOrdersCached/_sumWaveItemsTotalCached 同款):
* TTL 内重复查询直接命中缓存,缓存不可用或读取失败时降级为实时聚合。
* @param {number} warehouseId 仓库ID
* @param {number} waveId 波次ID
* @return {Promise<Array<Object>>} 波次商品汇总数组(异常降级为空数组)
*/
async _fetchWaveItemsSummary(warehouseId, waveId) {
const { ctx, app } = this;
const cacheKey = `${WAVE_ITEMS_SUMMARY_CACHE_KEY_PREFIX}:${warehouseId}:${waveId}`;
if (app && typeof app.getCacheAsync === 'function') {
try {
const cached = await app.getCacheAsync(cacheKey);
if (Array.isArray(cached)) {
return cached;
}
} catch (cacheReadErr) {
ctx.logger.warn('[Workbench._fetchWaveItemsSummary] 读取缓存失败,降级为实时聚合: %s', cacheReadErr.message);
}
}
const items = await this._aggregateWaveItems(warehouseId, waveId);
if (app && typeof app.setCacheAsync === 'function') {
try {
await app.setCacheAsync(cacheKey, items, WAVE_ITEMS_SUMMARY_CACHE_TTL_SECONDS);
} catch (cacheWriteErr) {
ctx.logger.warn('[Workbench._fetchWaveItemsSummary] 写入缓存失败,不影响本次返回: %s', cacheWriteErr.message);
}
}
return items;
}
/**
* 查询订单商品明细并合并 stock 详情(供 _queryOrder 与 buildCurrentPackingInfo 复用)。
* - 商品明细来自 OrderItemsFactory 分表(sourceTable=dispatch 查配送明细表,其余查 current);
* - stock 详情(条码/图片/包装要求等)经 stockWarehouse.getStockDetails 批量查询(自带缓存);
* - 任一环节异常均降级返回空数组,不抛错。
* @param {number} orderId 订单ID
* @param {number} warehouseId 仓库ID
* @param {string} [sourceTable] 订单所在分表(dispatch|current),决定明细分表选择
* @return {Promise<Array<Object>>} 商品明细数组(含 item_code/item_name/plan_qty/barcodes/image_url 等)
*/
async _fetchOrderItemsDetail(orderId, warehouseId, sourceTable) {
const { ctx } = this;
let items = [];
try {
const getItemsModel = sourceTable === 'dispatch'
? () => ctx.model.OrderItemsFactory.getDispatchModel(warehouseId)
: () => ctx.model.OrderItemsFactory.getCurrentModel(warehouseId);
const itemsModel = await getItemsModel();
if (itemsModel) {
const orderItems = await itemsModel.findAll({
where: { order_id: orderId },
attributes: [
'id', 'order_id', 'item_id', 'item_code', 'item_name',
'plan_qty', 'actual_price', 'stock_id', 'order_line_no',
'inventory_type', 'item_snapshot',
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
if (orderItems.length > 0) {
// 收集所有 stock_id,批量查询 stock 详情(带缓存)
const stockIds = [ ...new Set(
orderItems.map(item => Number(item.stock_id)).filter(id => id > 0)
) ];
/** @type {Map<number, Object>} */
const stockMap = new Map();
if (stockIds.length > 0) {
try {
const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails(
stockIds,
{ warehouseId }
);
for (const detail of stockDetails) {
stockMap.set(Number(detail.id), detail);
}
} catch (stockErr) {
ctx.logger.warn('[Workbench._fetchOrderItemsDetail] 查询 stock 详情失败: %s', stockErr.message);
}
}
// 组装 items,合并 stock 信息
items = orderItems.map(item => {
const stockId = Number(item.stock_id);
const stock = stockMap.get(stockId) || {};
return {
id: item.id,
order_id: item.order_id,
item_id: item.item_id,
item_code: item.item_code || stock.item_code || '',
item_name: item.item_name || stock.item_name || '',
plan_qty: item.plan_qty,
actual_price: item.actual_price,
stock_id: stockId,
order_line_no: item.order_line_no || '',
inventory_type: item.inventory_type || '',
sku_property: stock.sku_property || '',
stock_unit: stock.stock_unit || '',
barcodes: stock.barcodes || [],
image_url: stock.image_url || '',
packing_requirements: String(stock.packing_requirements || '').trim(),
need_recheck: String(stock.need_recheck || 'Y').trim(),
};
});
}
}
} catch (itemsErr) {
ctx.logger.warn('[Workbench._fetchOrderItemsDetail] 查询订单商品失败 orderId=%d: %s', orderId, itemsErr.message);
}
return items;
}
/**
* 条码查订单:条码 → wms_order_express → 待处理/配送订单详情。
* 散单(isSandan=1)时在响应 order 对象中额外返回 intercept_flag / pack_flag 两个 0/1 标志:
* 拦截状态(intercept_status)不等于 none 时 intercept_flag=1,否则 0;
* pack_flag 按运单维度判定(该运单号已有打包流水为 1,主/子单号互不影响)。
* order 对象始终包含 picker_id / picker_name:通过 wave_id 关联拣货任务取拣货人,
* 散单无波次或未分配拣货人时为 null / 空串。
* 查询成功时生成一次性打包上下文 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, 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('条码不能为空');
}
if (!inputWarehouseId || !String(inputWarehouseId).trim()) {
throw new Error('仓库ID不能为空');
}
const normalizedBarcode = String(barcode).trim();
const warehouseId = parseInt(inputWarehouseId);
// 步骤1:条码 → order_id + warehouse_id(必须限制仓库)
const expressRecord = await ctx.model.OrderExpress.findOne({
where: {
waybill_code: normalizedBarcode,
warehouse_id: warehouseId,
status: 1,
},
attributes: ['order_id', 'warehouse_id', 'waybill_code', 'logistics_name', 'weighing_weight', 'package_material_name_snapshot'],
raw: true,
});
if (!expressRecord) {
throw new Error(`未找到条码 [${normalizedBarcode}] 对应的运单记录`);
}
const { order_id: orderId, waybill_code: waybillCode } = expressRecord;
// 步骤2:序列表定位优先(命中则先查对应分表),未命中按 current → dispatch 回退遍历
const orderDeliveryFactory = ctx.model.OrderDeliveryFactory;
const tableOrders = [
{ label: 'current', getModel: () => orderDeliveryFactory.getCurrentModel(warehouseId) },
{ label: 'dispatch', getModel: () => orderDeliveryFactory.getDispatchModel(warehouseId) },
];
try {
if (orderDeliveryFactory && typeof orderDeliveryFactory.getOrderLocation === 'function') {
const preferredLocation = await orderDeliveryFactory.getOrderLocation(orderId, warehouseId);
if (preferredLocation) {
tableOrders.sort((a, b) => (a.label === preferredLocation ? -1 : b.label === preferredLocation ? 1 : 0));
}
}
} catch (locErr) {
ctx.logger.warn('[Workbench._queryOrder] 序列表定位失败,按默认顺序遍历: %s', locErr.message);
}
let orderRow = null;
let sourceTable = null;
for (const entry of tableOrders) {
try {
const model = await entry.getModel();
if (!model || typeof model.findOne !== 'function') continue;
const row = await model.findOne({
where: { id: orderId, warehouse_id: warehouseId },
raw: true,
});
if (row) {
orderRow = row;
sourceTable = entry.label;
break;
}
} catch (_err) {
ctx.logger.warn('[Workbench._queryOrder] 查询表 %s 失败: %s', entry.label, _err.message);
continue;
}
}
if (!orderRow) {
throw new Error(`未在待处理或配送表中找到订单 [id=${orderId}, warehouse=${warehouseId}]`);
}
ctx.logger.info('[Workbench._queryOrder] 条码=%s 命中 orderId=%d source=%s',
normalizedBarcode, orderId, sourceTable);
// 步骤3:判断波次类型(散单 vs 团购),团购需返回波次总量
let waveType = null;
let totalBatchOrders = 0;
let isSandan = 1; // 默认散单
const waveId = orderRow.wave_id;
if (waveId && Number(waveId) > 0) {
try {
// 查询波次信息
const waveBatch = await ctx.model.WaveBatch.findOne({
where: { wave_id: waveId, warehouse_id: warehouseId },
attributes: ['wave_id', 'wave_type', 'total_orders'],
raw: true,
});
if (waveBatch) {
waveType = waveBatch.wave_type;
// wave_type=1 → 团购单(isSandan=0); 其他(2=散单等) → 散单(isSandan=1)
if (Number(waveType) === 1) {
isSandan = 0;
// 仅团购单组装波次总量:实时统计带短 TTL 缓存;
// 散单不再触发分表 COUNT,避免 680ms+ 的无用扫描
totalBatchOrders = await this._countWaveOrdersCached(warehouseId, waveId);
} else {
isSandan = 1;
}
}
} catch (waveErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询波次信息失败 waveId=%d: %s', waveId, waveErr.message);
}
}
// 步骤4:查询订单商品明细 + 关联 stock 详情(带缓存,公共方法 _fetchOrderItemsDetail)
const items = await this._fetchOrderItemsDetail(orderId, warehouseId, sourceTable);
// 步骤5:查询货主备注(从合约表 store_warehouse.store_remask)
let storeRemark = '';
const storeId = Number(orderRow.store_id || 0);
if (storeId > 0) {
try {
const swRow = await ctx.model.StoreWarehouse.findOne({
where: { store_id: storeId, warehouse_id: warehouseId },
attributes: ['store_remask'],
raw: true,
});
storeRemark = (swRow && swRow.store_remask) ? String(swRow.store_remask).trim() : '';
} catch (swErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询货主备注失败 storeId=%d: %s', storeId, swErr.message);
}
}
// 步骤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 interceptFlag = normalizedInterceptStatus === '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;
}
}
// 步骤6.5:查询拣货人(通过波次关联拣货任务;散单无波次时为 null/空串)
let pickerId = null;
let pickerName = '';
if (waveId && Number(waveId) > 0) {
try {
const pickerRows = await ctx.model.query(
`
SELECT t.pick_user_id, t.pick_user_name
FROM wms_wave_pick_task_wave tw
INNER JOIN wms_wave_pick_task t ON t.id = tw.task_id
WHERE tw.wave_id = :waveId
AND tw.warehouse_id = :warehouseId
AND t.pick_user_id IS NOT NULL
ORDER BY t.create_time DESC
LIMIT 1
`,
{
replacements: { waveId: Number(waveId), warehouseId },
type: ctx.model.QueryTypes.SELECT,
}
);
const pickerRow = Array.isArray(pickerRows) && pickerRows.length > 0 ? pickerRows[0] : null;
if (pickerRow && pickerRow.pick_user_id != null) {
pickerId = Number(pickerRow.pick_user_id);
pickerName = String(pickerRow.pick_user_name || '').trim();
}
} catch (pickerErr) {
ctx.logger.warn('[Workbench._queryOrder] 查询拣货人失败 waveId=%d: %s', waveId, pickerErr.message);
}
}
const result = {
barcode: normalizedBarcode,
waybill_code: waybillCode,
isSandan,
store_remark: storeRemark,
express: {
logistics_name: expressRecord.logistics_name,
weighing_weight: expressRecord.weighing_weight,
package_material_name: expressRecord.package_material_name_snapshot || '',
},
order: {
id: orderRow.id,
delivery_order_code: orderRow.delivery_order_code,
order_type: orderRow.order_type,
warehouse_id: orderRow.warehouse_id,
store_id: orderRow.store_id,
status: orderRow.status,
step: orderRow.step,
wave_id: orderRow.wave_id,
wave_no: orderRow.wave_no,
post_status: orderRow.post_status,
pick_status: orderRow.pick_status,
pack_status: orderRow.pack_status,
intercept_status: orderRow.intercept_status,
recheck_status: orderRow.recheck_status,
outbound_status: orderRow.outbound_status,
items_count: orderRow.items_count,
items_total: orderRow.items_total,
items_weight: orderRow.items_weight,
source_platform_code: orderRow.source_platform_code,
logistics_name: orderRow.logistics_name,
picker_id: pickerId,
picker_name: pickerName,
create_at: orderRow.create_at,
updated_at: orderRow.updated_at,
},
items,
source_table: sourceTable,
};
// 散单附加拦截/打包 0/1 标志(原始状态字段仍保留在 order 中,不破坏既有调用方)
if (isSandan === 1) {
result.order.intercept_flag = interceptFlag;
result.order.pack_flag = packFlag;
}
// 团购单附加波次总量信息
if (isSandan === 0) {
result.batch = {
wave_id: waveId,
wave_no: orderRow.wave_no,
wave_type: waveType,
total_orders: totalBatchOrders,
};
}
// 步骤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}`;
}
// ==================== 绑定码 / 登录码 / 令牌 ====================
/**
* 工作台绑定会话缓存 key(client_code 维度)
* @param {string} clientCode 客户端编码
* @return {string} 缓存 key
*/
getWorkbenchBindClientCacheKey(clientCode) {
return `${WORKBENCH_BIND_CLIENT_CACHE_PREFIX}${clientCode}`;
}
/**
* 工作台绑定码缓存 key(code 维度)
* @param {string} code 绑定码
* @return {string} 缓存 key
*/
getWorkbenchBindCodeCacheKey(code) {
return `${WORKBENCH_BIND_CODE_CACHE_PREFIX}${code}`;
}
/**
* 工作台 token 信息缓存 key
* @param {string} token 工作台令牌
* @return {string} 缓存 key
*/
getWorkbenchTokenCacheKey(token) {
return `${WORKBENCH_TOKEN_CACHE_PREFIX}${token}`;
}
/**
* 生成指定字符集与长度的随机串。
* @param {string} charset 字符集
* @param {number} length 长度
* @return {string} 随机串
*/
generateRandomChars(charset, length) {
let result = '';
for (let i = 0; i < length; i++) {
result += charset[crypto.randomInt(0, charset.length)];
}
return result;
}
/**
* 生成工作台令牌(64 位十六进制)。
* @return {string} token
*/
generateWorkbenchToken() {
return crypto.randomBytes(32).toString('hex');
}
/**
* 生成工作台登录码(前缀 wblc + 60 位十六进制随机段,总长度 64 位)。
* @return {string} login_code
*/
generateWorkbenchLoginCode() {
return WORKBENCH_LOGIN_CODE_PREFIX
+ crypto.randomBytes(WORKBENCH_LOGIN_CODE_RANDOM_HEX_LENGTH / 2).toString('hex');
}
/**
* 标准化绑定码 / client_code:去空格转大写,仅接受 6 位大写字母+数字。
* @param {string} code 原始编码
* @return {string|null} 标准化结果,非法返回 null
*/
normalizeWorkbenchBindCode(code) {
const normalized = typeof code === 'string' ? code.trim().toUpperCase() : '';
if (!/^[A-Z0-9]{6}$/.test(normalized)) {
return null;
}
return normalized;
}
/**
* 生成全局唯一的登录码(查库去重,最多 5 次尝试)。
* @return {Promise<string>} 唯一登录码
*/
async generateUniqueWorkbenchLoginCode() {
const { ctx } = this;
for (let attempt = 0; attempt < 5; attempt++) {
const code = this.generateWorkbenchLoginCode();
const exists = await ctx.model.Workbench.findOne({
where: { login_code: code },
attributes: [ 'id' ],
raw: true,
});
if (!exists) {
return code;
}
}
throw new Error('生成登录码失败,请稍后重试');
}
/**
* 生成唯一的 client_code(缓存去重)。
* @param {number} [maxAttempts=200] 最大尝试次数
* @return {Promise<string>} 唯一 client_code
*/
async createUniqueWorkbenchClientCode(maxAttempts = 200) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
const code = this.generateRandomChars(WORKBENCH_BIND_CODE_CHARSET, WORKBENCH_BIND_CODE_LENGTH);
const cacheKey = this.getWorkbenchBindClientCacheKey(code);
const exists = await this.app.getCacheAsync(cacheKey);
if (!exists) {
return code;
}
}
throw new Error('生成客户端编码失败,请稍后重试');
}
/**
* 生成唯一的绑定码(缓存去重)。
* @param {number} [maxAttempts=200] 最大尝试次数
* @return {Promise<string>} 唯一绑定码
*/
async createUniqueWorkbenchBindCode(maxAttempts = 200) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
const code = this.generateRandomChars(WORKBENCH_BIND_CODE_CHARSET, WORKBENCH_BIND_CODE_LENGTH);
const cacheKey = this.getWorkbenchBindCodeCacheKey(code);
const exists = await this.app.getCacheAsync(cacheKey);
if (!exists) {
return code;
}
}
throw new Error('生成绑定码失败,请稍后重试');
}
/**
* 构建绑定会话状态。
* @param {string} clientCode 客户端编码
* @param {string} code 绑定码
* @param {Object} [extra={}] 附加字段
* @return {Object} 会话状态
*/
buildWorkbenchBindState(clientCode, code, extra = {}) {
return {
client_code: clientCode,
code,
status: 'pending',
workbench_id: null,
token: null,
updated_at: new Date().toISOString(),
expires_at: Date.now() + WORKBENCH_BIND_CACHE_TTL_SECONDS * 1000,
...extra,
};
}
/**
* 按缓存剩余时间计算 TTL(秒)。
* @param {number} expiresAt 过期时间戳(毫秒)
* @param {number} [fallbackTtl] 兜底 TTL
* @return {number} 剩余秒数(至少 1 秒)
*/
getWorkbenchBindRemainingSeconds(expiresAt, fallbackTtl = WORKBENCH_BIND_CACHE_TTL_SECONDS) {
const ts = Number(expiresAt);
if (!Number.isFinite(ts) || ts <= 0) {
return fallbackTtl;
}
return Math.max(1, Math.ceil((ts - Date.now()) / 1000));
}
/**
* 写入绑定会话状态(client_code 与 code 两个维度)。
* @param {Object} state 会话状态
* @param {number} [ttl] 过期秒数
* @return {Promise<void>}
*/
async setWorkbenchBindState(state, ttl = WORKBENCH_BIND_CACHE_TTL_SECONDS) {
if (!state || !state.client_code || !state.code) {
return;
}
await Promise.all([
this.app.setCacheAsync(this.getWorkbenchBindClientCacheKey(state.client_code), state, ttl),
this.app.setCacheAsync(this.getWorkbenchBindCodeCacheKey(state.code), state, ttl),
]);
}
/**
* 创建新的绑定会话(新 client_code + 新绑定码)。
* @return {Promise<{client_code: string, code: string, state: Object}>} 会话信息
*/
async createWorkbenchBindSession() {
const clientCode = await this.createUniqueWorkbenchClientCode();
const code = await this.createUniqueWorkbenchBindCode();
const state = this.buildWorkbenchBindState(clientCode, code);
await this.setWorkbenchBindState(state, WORKBENCH_BIND_CACHE_TTL_SECONDS);
return { client_code: clientCode, code, state };
}
/**
* 为已有 client_code 重新生成绑定码并更新缓存(旧绑定码缓存同步失效)。
* @param {string} clientCode 客户端编码
* @param {Object|null} [previousState] 旧会话状态,含旧绑定码时删除旧 code 维度缓存
* @return {Promise<{code: string, state: Object}>} 新绑定码与会话状态
*/
async refreshWorkbenchBindCode(clientCode, previousState = null) {
const oldCode = previousState && typeof previousState.code === 'string' ? previousState.code : '';
if (oldCode) {
try {
await this.app.delCacheAsync(this.getWorkbenchBindCodeCacheKey(oldCode));
} catch (delErr) {
this.app.coreLogger.warn(`删除旧工作台绑定码缓存失败: ${delErr.message}`);
}
}
const code = await this.createUniqueWorkbenchBindCode();
const state = this.buildWorkbenchBindState(clientCode, code);
await this.setWorkbenchBindState(state, WORKBENCH_BIND_CACHE_TTL_SECONDS);
return { code, state };
}
/**
* 格式化绑定码接口返回数据。
* @param {Object} state 会话状态
* @return {Object} 对外数据
*/
formatWorkbenchBindData(state) {
const expiresAt = Number(state.expires_at || 0);
return {
client_code: state.client_code || '',
code: state.code || '',
status: state.status || 'pending',
workbench_id: state.workbench_id || null,
token: state.token || null,
updated_at: state.updated_at || new Date().toISOString(),
expires_at: expiresAt > 0 ? expiresAt : null,
expire_after_ms: expiresAt > 0 ? Math.max(0, expiresAt - Date.now()) : 0,
};
}
/**
* 等待绑定完成(轮询 client_code 维度缓存状态)。
* @param {string} clientCode 客户端编码
* @param {number} [timeoutMs] 超时毫秒
* @return {Promise<{timed_out: boolean, state: Object|null}>} 等待结果
*/
async waitForWorkbenchBindComplete(clientCode, timeoutMs = WORKBENCH_BIND_LONG_POLL_TIMEOUT_MS) {
const startedAt = Date.now();
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
while (Date.now() - startedAt < timeoutMs) {
await sleep(WORKBENCH_BIND_POLL_INTERVAL_MS);
let state = null;
try {
state = await this.app.getCacheAsync(this.getWorkbenchBindClientCacheKey(clientCode));
} catch (error) {
this.app.coreLogger.warn(`读取工作台绑定缓存失败: ${error.message}`);
}
if (state && state.status === 'bound' && state.token) {
return { timed_out: false, state };
}
}
return { timed_out: true, state: null };
}
/**
* 获取工作台绑定码(供 index.getWorkbenchBindCode)。
* - 不传 client_code:创建新会话并返回 client_code + 绑定码;
* - 传 client_code 且缓存存在:等待绑定完成返回 token,超时则重新生成绑定码后返回;
* - 传 client_code 但缓存不存在:重新生成绑定码后返回。
* @param {Object} [data={}] - { clientCode | client_code }
* @return {Promise<Object>} { success, code, data, message }
*/
async getWorkbenchBindCode(data = {}) {
const { app } = this;
try {
const rawClientCode = typeof data.clientCode === 'string'
? data.clientCode
: (typeof data.client_code === 'string' ? data.client_code : '');
const hasInputClientCode = !!rawClientCode && rawClientCode.trim().length > 0;
if (!hasInputClientCode) {
const session = await this.createWorkbenchBindSession();
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(session.state),
message: '工作台绑定码已生成',
};
}
const clientCode = this.normalizeWorkbenchBindCode(rawClientCode);
if (!clientCode) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '无效的客户端编码格式',
};
}
const clientCacheKey = this.getWorkbenchBindClientCacheKey(clientCode);
let cachedState = null;
try {
cachedState = await app.getCacheAsync(clientCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台绑定码缓存失败: ${cacheErr.message}`);
}
// 传入 client_code 但缓存不存在:按新会话处理,重新生成绑定码后返回。
if (!cachedState) {
const refreshed = await this.refreshWorkbenchBindCode(clientCode);
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(refreshed.state),
message: '绑定码缓存已过期,已重新生成',
};
}
// 绑定已完成:直接返回 token。
if (cachedState.status === 'bound' && cachedState.token) {
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(cachedState),
message: '绑定成功',
};
}
// 长轮询等待绑定完成。
const waitResult = await this.waitForWorkbenchBindComplete(clientCode, WORKBENCH_BIND_LONG_POLL_TIMEOUT_MS);
if (!waitResult.timed_out && waitResult.state && waitResult.state.status === 'bound' && waitResult.state.token) {
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(waitResult.state),
message: '绑定成功',
};
}
// 超时兜底:重读一次缓存,避免刷新瞬间恰好绑定完成而覆盖结果。
try {
cachedState = await app.getCacheAsync(clientCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台绑定码缓存失败: ${cacheErr.message}`);
}
if (cachedState && cachedState.status === 'bound' && cachedState.token) {
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(cachedState),
message: '绑定成功',
};
}
// 超时:重新生成绑定码后才返回数据(旧绑定码缓存同步失效)。
const refreshed = await this.refreshWorkbenchBindCode(clientCode, cachedState);
return {
success: true,
code: 200,
data: this.formatWorkbenchBindData(refreshed.state),
message: '等待绑定超时,已刷新绑定码',
};
} catch (error) {
app.coreLogger.error(`获取工作台绑定码失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '获取工作台绑定码失败,请稍后重试',
};
}
}
/**
* 格式化工作台主表字段(不含 token、login_code 敏感字段,不含成员列表)。
* 成员列表由 buildWorkbenchTokenInfo 统一组装。
* @param {Object} record 工作台记录(模型实例或普通对象)
* @return {Object} 工作台主表对外信息
*/
formatWorkbenchTokenInfo(record) {
const plain = record && typeof record.get === 'function'
? record.get({ plain: true })
: (record || {});
return {
id: plain.id,
warehouse_id: plain.warehouse_id,
name: plain.name,
status: plain.status,
type: plain.type,
remark: plain.remark,
device_ids: plain.device_ids,
created_at: plain.created_at,
updated_at: plain.updated_at,
};
}
/**
* 查询工作台未软删除的成员列表(轻量字段,供缓存组装与接口返回)。
* @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:全部未结束打包任务列表(含发货单号、波次号、任务状态、商品件数/SKU 数等):
* 散单任务(pack_mode=1)items 为单笔订单商品明细(含条码/图片/包装要求/是否需要复核);
* 团购任务(pack_mode=2)items 为波次商品 SKU 聚合汇总(波次内全部未拦截订单按 SKU 聚合计划数量,15s 短缓存兜底,
* 元素另附 is_wave_summary=true),供工作台退出/刷新后恢复任务上下文。
* 任一环节异常均降级为空对象/空数组/空明细,不影响主信息返回。
* @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 = '';
let orderRow = null;
let sourceTable = '';
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', 'order_type', 'store_id', 'items_count', 'items_total' ],
raw: true,
});
if (row) {
deliveryOrderCode = row.delivery_order_code || '';
orderRow = row;
sourceTable = entry.label;
break;
}
} catch (_err) { continue; }
}
const isGroup = Number(task.pack_mode) === 2;
// 散单任务补充单笔订单商品明细;团购任务补充波次商品 SKU 聚合汇总(15s 短缓存兜底),
// 均供工作台退出/刷新后恢复任务上下文(异常降级为空数组)
let items = [];
if (!isGroup && Number(task.order_id || 0) > 0 && sourceTable) {
try {
items = await this._fetchOrderItemsDetail(Number(task.order_id), warehouseId, sourceTable);
} catch (itemsErr) {
ctx.logger.warn('[Workbench.buildCurrentPackingInfo] 查询散单商品明细失败 orderId=%d: %s',
Number(task.order_id), itemsErr.message);
}
} else if (isGroup && Number(task.wave_id || 0) > 0) {
try {
items = await this._fetchWaveItemsSummary(warehouseId, Number(task.wave_id));
} catch (itemsErr) {
ctx.logger.warn('[Workbench.buildCurrentPackingInfo] 查询团购波次商品汇总失败 waveId=%d: %s',
Number(task.wave_id), itemsErr.message);
}
}
// 散单任务补齐货主备注与运单信息(物流公司/称重重量/包材名称,与 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,
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),
item_quantity: Number(task.item_quantity || 0),
sku_count: Number(task.sku_count || 0),
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,
operator_text: task.operator_text || '',
start_time: task.start_time,
});
// 团购任务(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 }
*/
async bindWorkbench(data = {}) {
const { ctx, app } = this;
try {
const warehouseId = ctx.user && ctx.user.store_id;
const rawCode = typeof data.code === 'string' ? data.code : '';
const code = this.normalizeWorkbenchBindCode(rawCode);
const workbenchId = Number(data.id ?? data.workbench_id ?? data.workbenchId);
if (!code) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '绑定码格式无效',
};
}
if (!Number.isInteger(workbenchId) || workbenchId <= 0) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '工作台ID不能为空或无效',
};
}
const codeCacheKey = this.getWorkbenchBindCodeCacheKey(code);
let codeState = null;
try {
codeState = await app.getCacheAsync(codeCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台绑定码缓存失败: ${cacheErr.message}`);
}
if (!codeState || codeState.status === 'bound') {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '绑定码不存在或已过期',
};
}
const record = await ctx.model.Workbench.findOne({
where: { id: workbenchId, warehouse_id: warehouseId },
});
if (!record) {
return {
success: false,
code: 0,
statusCode: 404,
data: null,
message: '工作台不存在或无权操作',
};
}
const newToken = this.generateWorkbenchToken();
const oldToken = typeof record.token === 'string' ? record.token : '';
// 若工作台已有 token,删除旧 token 缓存。
if (oldToken && oldToken !== newToken) {
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(oldToken));
}
await record.update({ token: newToken, token_updated_at: new Date() });
// 写入 token → 工作台信息缓存(含成员列表)。
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(newToken),
await this.buildWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
// 更新绑定会话状态,供长轮询侧返回 token。
const remainingTtl = this.getWorkbenchBindRemainingSeconds(codeState.expires_at, WORKBENCH_BIND_CACHE_TTL_SECONDS);
const boundState = {
...codeState,
status: 'bound',
workbench_id: record.id,
token: newToken,
updated_at: new Date().toISOString(),
};
await this.setWorkbenchBindState(boundState, remainingTtl);
return {
success: true,
code: 200,
data: {
id: record.id,
workbench_id: record.id,
token: newToken,
},
message: '绑定成功',
};
} catch (error) {
app.coreLogger.error(`工作台绑定失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '工作台绑定失败,请稍后重试',
};
}
}
/**
* 通过 token 获取工作台信息(供 workbench.getWorkbenchInfo)。
* 统一走 resolveWorkbenchContext 校验:无 token 返回失败(401)、token 无效返回失败(403);
* 缓存优先(workbench:token:{token}),未命中查库并回填缓存;
* 缓存与返回数据均包含未软删除成员列表 members 与当前打包信息。
* @param {Object} [data={}] - { token }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
async getWorkbenchInfoByToken(data = {}) {
const { app } = this;
try {
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
// 统一 token 校验(无 token 401、无效 403),解析成功后写入 ctx 备用
const resolved = await this.resolveWorkbenchContext(rawToken);
if (!resolved.success) return resolved;
// 缓存优先:命中直接返回(含 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
);
}
return { success: true, code: 200, data: info, message: 'ok' };
} catch (error) {
app.coreLogger.error(`通过 token 获取工作台信息失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '获取工作台信息失败,请稍后重试',
};
}
}
/**
* 统计数值保留 2 位小数(四舍五入)。
* @param {number} value 原始数值
* @return {number} 保留 2 位小数后的数值
*/
_round2(value) {
return Math.round(Number(value) * 100) / 100;
}
/**
* 格式化时间为 'YYYY-MM-DD HH:mm:ss'(本地时间,供接口返回展示)。
* @param {Date} date 日期对象
* @return {string} 格式化后的时间字符串
*/
_formatPackCountTime(date) {
const pad = n => String(n).padStart(2, '0');
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+ `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
}
/**
* 计算打包统计时间窗口(班次口径):
* 本地时间当日 08:00 至次日 08:00(左闭右开);
* 当前本地时间早于 08:00 时,窗口为昨日 08:00 至今日 08:00。
* @return {{startTime: Date, endTime: Date}} 窗口起止时间
*/
buildWorkbenchPackCountTimeRange() {
const now = new Date();
let startTime = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 8, 0, 0, 0);
if (now.getTime() < startTime.getTime()) {
startTime = new Date(startTime.getTime() - 86400000);
}
return { startTime, endTime: new Date(startTime.getTime() + 86400000) };
}
/**
* 通过 token 获取当前工作台的班次打包统计(供 workbench.getWorkbenchCount)。
*
* 统一走 resolveWorkbenchContext 校验:无 token 返回 401、token 无效返回 403;
* 仓库与工作台均由 token 解析注入,禁止前端传值。
*
* 统计窗口:本地时间当日 08:00 → 次日 08:00;当前时间早于 08:00 时为昨日 08:00 → 今日 08:00。
* - 个人工作台(type=personal):统计「涉及本人」的打包数据(本人 = 工作台成员 user_id,
* 范围 = 本工作台产生的任务 ∪ 本人作为打包人参与的任务),返回:
* group_wave_count 团购波次数量(pack_mode=2 且 wave_id>0 去重)、
* group_order_count 团购订单数量(团购任务 pack_quantity 求和)、
* single_order_count 散单数量(pack_mode=1 任务数)、
* group_single_ratio 团散(团购波次数/散单数,保留 2 位小数,散单为 0 时 null)、
* avg_piece_count 均件数(本人打包任务按 订单数量/人数 折算后求和,保留 2 位小数:
* 本人作为打包人参与的任务按任务实际打包人数均分,本工作台单人任务整单计入)。
* - 团体工作台(type=group):统计「涉及本工作台」的打包数据,返回:
* group_wave_count 团购波次数量、group_order_count 团购订单数量(团购任务 pack_quantity 快照求和)、
* single_order_count 散单数量。
*
* 只查 wms_pack_task / wms_pack_task_packer,全部走现有/配套索引
* (idx_warehouse_create_time / idx_workbench_create_time / uix_pack_task_account),
* 不做订单分表实时统计,避免慢 SQL。
*
* @param {Object} [data={}] - { token }
* @return {Promise<Object>} { success, code, data, message, statusCode }
*/
async getWorkbenchCountByToken(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
try {
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
// 统一 token 校验(无 token 401、无效 403),解析成功后写入 ctx 备用
const resolved = await this.resolveWorkbenchContext(rawToken);
if (!resolved.success) return resolved;
const workbench = resolved.data;
const workbenchId = Number(workbench.id);
const warehouseId = Number(workbench.warehouse_id || 0);
const isGroup = workbench.type === 'group';
const { startTime, endTime } = this.buildWorkbenchPackCountTimeRange();
// 窗口内打包任务:团体工作台只取本工作台(走 idx_workbench_create_time),
// 个人工作台取本仓库窗口内全部任务(走 idx_warehouse_create_time)再按人过滤。
const taskWhere = {
warehouse_id: warehouseId,
create_time: { [Op.gte]: startTime, [Op.lt]: endTime },
};
if (isGroup) {
taskWhere.workbench_id = workbenchId;
}
const tasks = await ctx.model.PackTask.findAll({
where: taskWhere,
attributes: [ 'id', 'wave_id', 'pack_mode', 'pack_quantity', 'workbench_id' ],
raw: true,
});
// 团体工作台:按本工作台任务直接统计
if (isGroup) {
const groupTasks = tasks.filter(task => Number(task.pack_mode) === 2);
const singleTasks = tasks.filter(task => Number(task.pack_mode) === 1);
const waveIdSet = new Set(groupTasks.map(task => Number(task.wave_id)).filter(id => id > 0));
const groupOrderCount = groupTasks.reduce((sum, task) => sum + (Number(task.pack_quantity) || 0), 0);
return {
success: true,
code: 200,
data: {
workbench_id: workbenchId,
workbench_type: workbench.type,
time_range: {
start_time: this._formatPackCountTime(startTime),
end_time: this._formatPackCountTime(endTime),
},
group_wave_count: waveIdSet.size,
group_order_count: groupOrderCount,
single_order_count: singleTasks.length,
},
message: 'ok',
};
}
// 个人工作台:本人 = 工作台成员 user_id(个人工作台通常只有一名成员)
let personUserId = null;
try {
const members = await this.listWorkbenchMembers(workbenchId);
const userIds = members
.map(member => Number(member.user_id))
.filter(id => Number.isInteger(id) && id > 0);
personUserId = userIds.length > 0 ? userIds[0] : null;
} catch (memberErr) {
ctx.logger.warn('[Workbench.getWorkbenchCount] 查询工作台成员失败,按本工作台任务统计: %s', memberErr.message);
}
// 本工作台产生的任务
const workbenchTaskIds = new Set(
tasks.filter(task => Number(task.workbench_id) === workbenchId).map(task => Number(task.id))
);
// 本人作为打包人参与的任务(分批 IN 查询,避免单次 IN 列表过长)
const participatedTaskIds = new Set();
const taskIds = tasks.map(task => Number(task.id));
if (personUserId !== null && taskIds.length > 0) {
const batchSize = 500;
for (let offset = 0; offset < taskIds.length; offset += batchSize) {
const idChunk = taskIds.slice(offset, offset + batchSize);
const packerRows = await ctx.model.PackTaskPacker.findAll({
where: { pack_task_id: { [Op.in]: idChunk }, account_id: personUserId },
attributes: [ 'pack_task_id' ],
raw: true,
});
for (const row of packerRows) {
participatedTaskIds.add(Number(row.pack_task_id));
}
}
}
// 统计对象任务集合:本工作台任务 ∪ 本人作为打包人参与的任务
const personalTaskIdSet = new Set([ ...workbenchTaskIds, ...participatedTaskIds ]);
// 统计各任务的打包人数(供均件数折算使用)
const packerCountMap = new Map();
if (personalTaskIdSet.size > 0) {
const personalIds = [ ...personalTaskIdSet ];
const batchSize = 500;
for (let offset = 0; offset < personalIds.length; offset += batchSize) {
const idChunk = personalIds.slice(offset, offset + batchSize);
const packerRows = await ctx.model.PackTaskPacker.findAll({
where: { pack_task_id: { [Op.in]: idChunk } },
attributes: [ 'pack_task_id' ],
raw: true,
});
for (const row of packerRows) {
const key = Number(row.pack_task_id);
packerCountMap.set(key, (packerCountMap.get(key) || 0) + 1);
}
}
}
const personalTasks = tasks.filter(task => personalTaskIdSet.has(Number(task.id)));
const groupTasks = personalTasks.filter(task => Number(task.pack_mode) === 2);
const singleTasks = personalTasks.filter(task => Number(task.pack_mode) === 1);
const waveIdSet = new Set(groupTasks.map(task => Number(task.wave_id)).filter(id => id > 0));
const groupOrderCount = groupTasks.reduce((sum, task) => sum + (Number(task.pack_quantity) || 0), 0);
// 均件数:本人打包的每个任务按 订单数量/人数 折算后求和(保留 2 位小数):
// 本人作为打包人参与的任务按任务实际打包人数均分(缺省 1);
// 本工作台任务未记录到本人时视为单人打包(整单计入本人)。
let avgPieceCount = 0;
for (const task of personalTasks) {
const taskId = Number(task.id);
const orderCount = Number(task.pack_mode) === 2 ? (Number(task.pack_quantity) || 0) : 1;
if (orderCount <= 0) continue;
if (participatedTaskIds.has(taskId)) {
const packerCount = packerCountMap.get(taskId) || 1;
avgPieceCount += orderCount / packerCount;
} else if (workbenchTaskIds.has(taskId)) {
avgPieceCount += orderCount;
}
}
const singleOrderCount = singleTasks.length;
const groupWaveCount = waveIdSet.size;
return {
success: true,
code: 200,
data: {
workbench_id: workbenchId,
workbench_type: workbench.type,
time_range: {
start_time: this._formatPackCountTime(startTime),
end_time: this._formatPackCountTime(endTime),
},
group_wave_count: groupWaveCount,
group_order_count: groupOrderCount,
single_order_count: singleOrderCount,
group_single_ratio: singleOrderCount > 0 ? this._round2(groupWaveCount / singleOrderCount) : null,
avg_piece_count: this._round2(avgPieceCount),
},
message: 'ok',
};
} catch (error) {
app.coreLogger.error(`获取工作台打包统计失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '获取工作台打包统计失败,请稍后重试',
};
}
}
/**
* 通过 login_code 获取工作台 token(供 index.LoginWorkbenchByCode)。
* 按 wms_workbench.login_code 查询;查无工作台返回失败(403);
* 工作台尚无 token 时自动生成并持久化(等价于补绑定),
* 生成并持久化 token 时同步更新 token_updated_at,供 token 超期强制下线定时任务判定。
* 回填的 token 信息缓存包含成员列表 members。
* @param {Object} [data={}] - { loginCode | login_code }
* @return {Promise<Object>} { success, code, data, message }
*/
async loginWorkbenchByCode(data = {}) {
const { ctx, app } = this;
try {
const rawLoginCode = typeof data.loginCode === 'string'
? data.loginCode.trim()
: (typeof data.login_code === 'string' ? data.login_code.trim() : '');
if (!rawLoginCode) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: 'login_code 不能为空',
};
}
const record = await ctx.model.Workbench.findOne({
where: { login_code: rawLoginCode },
});
if (!record) {
return {
success: false,
code: 0,
statusCode: 403,
data: null,
message: '工作台不存在或登录码无效',
};
}
let token = typeof record.token === 'string' ? record.token : '';
if (!token) {
token = this.generateWorkbenchToken();
await record.update({ token, token_updated_at: new Date() });
}
await app.setCacheAsync(
this.getWorkbenchTokenCacheKey(token),
await this.buildWorkbenchTokenInfo(record),
WORKBENCH_TOKEN_CACHE_TTL_SECONDS
);
return {
success: true,
code: 200,
data: {
id: record.id,
workbench_id: record.id,
name: record.name,
token,
},
message: '登录成功',
};
} catch (error) {
app.coreLogger.error(`通过登录码获取工作台 token 失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '工作台登录失败,请稍后重试',
};
}
}
/**
* 重置工作台登录码(供 workbench.resetLoginCode)。
* 重置登录码的同时重置工作台 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, token: string}>} 新登录码与新 token
*/
async resetLoginCode(id) {
const { ctx, app } = this;
const warehouseId = ctx.user.store_id;
const workbenchId = Number(id);
if (!Number.isInteger(workbenchId) || workbenchId <= 0) {
throw new Error('工作台ID不能为空或无效');
}
const record = await ctx.model.Workbench.findOne({
where: { id: workbenchId, warehouse_id: warehouseId },
});
if (!record) {
throw new Error('工作台不存在或无权操作');
}
const loginCode = await this.generateUniqueWorkbenchLoginCode();
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() });
// 立即回填新 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 校验入口,供免登录免鉴权的 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 resolveWorkbenchContext(token) {
const { ctx, app } = this;
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 {
cached = await app.getCacheAsync(tokenCacheKey);
} catch (cacheErr) {
app.coreLogger.warn(`读取工作台 token 缓存失败: ${cacheErr.message}`);
}
let record = null;
if (cached && cached.id) {
record = await ctx.model.Workbench.findOne({
where: { id: cached.id },
});
}
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 鉴权)。
* 推荐 key 模式:前端先经 workbench.queryOrder 扫码拿到 key(20 分钟有效),
* 打包只传 token + key,订单信息一律由后端从缓存拉取(防篡改);
* 不传 key 时旧参数模式兼容(过渡期保留,后续版本将移除)。
* 仓库与工作台均由 token 解析注入,禁止前端传值。
* 打包状态变更后由 _packOrder 内部主动失效 token 缓存,保证 getWorkbenchInfo 及时返回最新信息。
* @param {Object} [data={}] - { token, key }(推荐)或旧参数模式 { token, delivery_order_code, ... }
* @return {Promise<Object>} { success, code, data, message, statusCode }
* success=true 时 data 为 _packOrder 返回的任务信息;失败时 statusCode 为 401/403/400
*/
async packOrderByToken(data = {}) {
const { ctx } = this;
// 新链路(token+key / 旧参数过渡)一律不接收 users:打包人由 _packOrder 自动回填工作台绑定成员。
// 仅 business(packOrder) 旧链路支持上报 users。
const { token, key, users: _ignoredUsers, ...legacyParams } = 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: '工作台未绑定有效仓库',
};
}
// 新 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,
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,
workbench_id: ctx.workbenchId,
});
return { success: true, code: 200, data: result, message: 'ok' };
}
/**
* 标准化成员行 ID 列表:支持数组、单值、逗号分隔字符串,去重后仅保留正整数。
* @param {*} ids 原始行 ID 入参
* @return {number[]} 标准化后的行 ID 列表
*/
normalizeWorkbenchMemberIds(ids) {
const source = Array.isArray(ids) ? ids : (ids === undefined || ids === null ? [] : [ ids ]);
const values = [];
source.forEach(item => {
if (typeof item === 'string' && item.includes(',')) {
item.split(',').forEach(part => values.push(part.trim()));
} else {
values.push(item);
}
});
return [ ...new Set(values
.map(item => Number(item))
.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 }
*/
async removeWorkbenchMember(data = {}) {
const { ctx, app } = this;
try {
// 统一 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) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '成员行ID不能为空或无效',
};
}
const workbench = resolved.data;
const rows = await ctx.model.WorkbenchMember.findAll({
where: { id: memberIds, workbench_id: workbench.id },
attributes: [ 'id' ],
});
const matchedIds = rows.map(row => row.id);
if (matchedIds.length === 0) {
return {
success: false,
code: 0,
statusCode: 404,
data: null,
message: '未找到可移除的成员',
};
}
await ctx.model.WorkbenchMember.destroy({
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));
return {
success: true,
code: 200,
data: {
removed: matchedIds.length,
ids: matchedIds,
auto_finished_pack: autoFinishedPack,
},
message: '移除成功',
};
} catch (error) {
app.coreLogger.error(`移除工作台成员失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '移除工作台成员失败,请稍后重试',
};
}
}
/**
* 绑定工作台成员(供 workbench.bindMember,免登录免鉴权,以工作台 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, statusCode }
*/
async bindWorkbenchMember(data = {}) {
const { ctx, app } = this;
try {
// 统一 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
: (typeof data.user_name === 'string'
? data.user_name
: (typeof data.name === 'string' ? data.name : ''));
const userName = rawUserName.trim();
if (!userName) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '姓名不能为空',
};
}
const rawUserId = data.userId ?? data.user_id;
const userId = rawUserId === null || rawUserId === undefined || rawUserId === ''
? null
: Number(rawUserId);
if (userId !== null && (!Number.isInteger(userId) || userId <= 0)) {
return {
success: false,
code: 0,
statusCode: 400,
data: null,
message: '用户ID无效',
};
}
const workbench = resolved.data;
const member = await ctx.model.WorkbenchMember.create({
workbench_id: workbench.id,
user_id: userId,
user_name: userName,
});
// 成员变更后清除 token 信息缓存,下次获取工作台信息立即反映最新成员。
await app.delCacheAsync(this.getWorkbenchTokenCacheKey(rawToken));
return {
success: true,
code: 200,
data: {
id: member.id,
workbench_id: member.workbench_id,
user_id: member.user_id,
user_name: member.user_name,
},
message: '绑定成功',
};
} catch (error) {
app.coreLogger.error(`绑定工作台成员失败: ${error.message}`);
return {
success: false,
code: 0,
data: null,
message: '绑定工作台成员失败,请稍后重试',
};
}
}
}
module.exports = WorkbenchService;