2272 lines
80 KiB
JavaScript
2272 lines
80 KiB
JavaScript
'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 前缀(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 {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;
|
||
|
||
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.barcode) {
|
||
queryWhere.barcode = { [Op.like]: `%${where.barcode}%` };
|
||
}
|
||
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, barcode, status, 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(),
|
||
barcode: data.barcode ? String(data.barcode).trim() : null,
|
||
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, barcode, status, 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.barcode !== undefined) updateFields.barcode = data.barcode ? String(data.barcode).trim() : null;
|
||
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':
|
||
return await this._packOrder(data || {});
|
||
case 'finishPack':
|
||
return await this._finishPack(data || {});
|
||
case 'sendWeight':
|
||
return await this._sendWeight(data || {});
|
||
case '':
|
||
default:
|
||
throw new Error(`不支持的业务类型: ${name}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 实时统计波次下的订单数量(并发遍历 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;
|
||
}
|
||
|
||
/**
|
||
* 获取波次下所有订单ID(遍历 current + dispatch 分表)
|
||
* @param {number} warehouseId
|
||
* @param {number} waveId
|
||
* @returns {Promise<number[]>}
|
||
*/
|
||
async _getWaveOrderIds(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 orderIds = [];
|
||
for (const entry of tableOrders) {
|
||
try {
|
||
const model = await entry.getModel();
|
||
if (!model) continue;
|
||
const rows = await model.findAll({
|
||
where: { wave_id: waveId, warehouse_id: warehouseId },
|
||
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',
|
||
'status',
|
||
'pack_quantity',
|
||
'item_quantity',
|
||
'sku_count',
|
||
'workbench_id',
|
||
'wave_no',
|
||
]);
|
||
|
||
/**
|
||
* 打包任务字段中文翻译
|
||
*/
|
||
PACK_OPLOG_FIELD_LABEL = {
|
||
pack_mode: '打包模式',
|
||
status: '任务状态',
|
||
pack_quantity: '打包数量',
|
||
item_quantity: '商品总数量',
|
||
sku_count: '商品种类数',
|
||
workbench_id: '工作台',
|
||
wave_no: '波次号',
|
||
};
|
||
|
||
/**
|
||
* 打包任务字段值翻译
|
||
*/
|
||
PACK_OPLOG_VALUE_LABEL = {
|
||
pack_mode: { 1: '散单', 2: '团购' },
|
||
status: { 0: '待处理', 1: '打包中', 2: '已完成', 3: '异常' },
|
||
};
|
||
|
||
/**
|
||
* 构建打包操作日志的变更描述。
|
||
* @param {Object} packData 打包数据
|
||
* @returns {string} 变更描述
|
||
*/
|
||
_buildPackChangeSummary(packData) {
|
||
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;
|
||
const 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 打包人员列表
|
||
*/
|
||
async _writePackOperationLog({ warehouseId, orderId, waveId, waveNo, isSandan, packData, users }) {
|
||
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);
|
||
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更新单笔,团购按波次批量更新)。
|
||
* 遍历 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 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]);
|
||
}
|
||
} 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);
|
||
break;
|
||
}
|
||
} catch (err) {
|
||
ctx.logger.warn('[%s._updateOrderPackStatus] 更新分表 %s 失败: %s', caller, entry.label, err.message);
|
||
}
|
||
}
|
||
}
|
||
|
||
return orderPackStatus;
|
||
}
|
||
|
||
/**
|
||
* 打包任务写入:根据发货单号查询订单并创建/更新打包任务记录
|
||
* @param {Object} params - { delivery_order_code, wave_no, warehouse_id, workbench_id, status, pack_time }
|
||
* @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,
|
||
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}]`);
|
||
|
||
// 拦截流程中的订单不允许打包
|
||
if (isInterceptedOrderStatus(orderRow.intercept_status)) {
|
||
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 */ }
|
||
}
|
||
|
||
// 步骤3:获取工作台 device_ids
|
||
let deviceIds = null;
|
||
if (validWorkbenchId) {
|
||
try {
|
||
const wb = await ctx.model.Workbench.findByPk(validWorkbenchId, {
|
||
attributes: ['device_ids'],
|
||
raw: true,
|
||
});
|
||
deviceIds = wb && wb.device_ids ? wb.device_ids : null;
|
||
} catch (_err) { /* ignore */ }
|
||
}
|
||
|
||
// 步骤4:同一工作台有新的打包任务时,关闭上一个未结束的任务
|
||
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',
|
||
});
|
||
}
|
||
}
|
||
|
||
// 步骤5:去重 — 散单按 order_id 物理删除旧记录,团购按 wave_no 物理删除旧记录
|
||
if (isSandan === 1) {
|
||
// 散单:按 order_id 去重,先收集旧任务ID清理关联打包人,再物理移除旧任务
|
||
const oldTasks = await ctx.model.PackTask.findAll({
|
||
where: { order_id: orderId, 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 条旧记录 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:创建新的打包任务
|
||
const packData = {
|
||
order_id: orderId,
|
||
warehouse_id: warehouseId,
|
||
workbench_id: validWorkbenchId,
|
||
wave_id: waveId,
|
||
wave_no: actualWaveNo,
|
||
waybill_code: null, // 后续可从 order_express 补
|
||
pack_mode: isSandan === 0 ? 2 : 1, // 1=散单 2=团购
|
||
status: packStatus !== undefined ? parseInt(packStatus) : 1,
|
||
pack_quantity: waveTotalOrders !== undefined ? parseInt(waveTotalOrders) || 0 : 1,
|
||
item_quantity: itemsTotal !== undefined ? parseInt(itemsTotal) || 0 : (orderRow.items_total || 0),
|
||
sku_count: itemsCount !== undefined ? parseInt(itemsCount) || 0 : (orderRow.item_count || 0),
|
||
start_time: new Date(packTimeMs),
|
||
end_time: packStatus >= 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);
|
||
|
||
// 步骤6.5:更新订单的打包状态字段(散单按订单更新,团购按波次批量更新)
|
||
// 传 packData.status(已归一化,缺省为 1),避免设备端未传 status 时订单被误写为已完成
|
||
await this._updateOrderPackStatus(warehouseId, {
|
||
orderId,
|
||
waveId: isSandan === 1 ? 0 : waveId,
|
||
packStatus: packData.status,
|
||
caller: 'Workbench._packOrder',
|
||
});
|
||
|
||
// 步骤7:写入打包人员信息
|
||
const users = Array.isArray(usersParam) ? usersParam : [];
|
||
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) {
|
||
// 散单:用运单号
|
||
const expressRecord = await ctx.model.OrderExpress.findOne({
|
||
where: { order_id: orderId, warehouse_id: warehouseId },
|
||
attributes: ['waybill_code'],
|
||
raw: true,
|
||
});
|
||
osdText = (expressRecord && expressRecord.waybill_code) || deliveryOrderCode;
|
||
} else {
|
||
// 团购:波次号+总量
|
||
osdText = `波次${actualWaveNo} 共${totalOrders}单`;
|
||
}
|
||
|
||
// 写入 OSD 缓存
|
||
try {
|
||
const osdCacheKey = `osd_${validWorkbenchId}`;
|
||
await this.app.setCacheAsync(osdCacheKey, osdText, 3600);
|
||
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);
|
||
|
||
// 异步下发,不阻塞打包主流程
|
||
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);
|
||
});
|
||
}
|
||
|
||
// 步骤8:写入操作日志(散单写单个订单,团购批量写波次所有订单)
|
||
await this._writePackOperationLog({
|
||
warehouseId,
|
||
orderId,
|
||
waveId,
|
||
waveNo: actualWaveNo,
|
||
isSandan,
|
||
packData,
|
||
users,
|
||
});
|
||
|
||
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 });
|
||
|
||
ctx.logger.info('[Workbench._finishPack] 工作台 %d 结束打包任务 taskId=%d orderId=%d',
|
||
validWorkbenchId, lastTask.id, lastTask.order_id);
|
||
|
||
// 同步更新关联订单打包状态:散单更新单笔订单,团购批量更新波次下所有未拦截订单
|
||
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)
|
||
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 }] : [],
|
||
});
|
||
|
||
return {
|
||
workbench_id: validWorkbenchId,
|
||
finished: true,
|
||
task_id: lastTask.id,
|
||
order_id: lastTask.order_id,
|
||
end_time: endTime,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 称重上报:条码(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,
|
||
},
|
||
}
|
||
);
|
||
|
||
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,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 条码查订单:条码 → wms_order_express → 待处理/配送订单详情
|
||
* 散单(isSandan=1)时在响应 order 对象中额外返回 intercept_flag / pack_flag 两个 0/1 标志:
|
||
* 拦截状态(intercept_status)不等于 none 时 intercept_flag=1,否则 0;
|
||
* 打包状态(pack_status)不等于 none 时 pack_flag=1,否则 0。
|
||
* @param {Object} params - { barcode, warehouseId }
|
||
* @return {Promise<Object>} 查询结果 { barcode, waybill_code, isSandan, store_remark, express, order, items, source_table, batch? }
|
||
*/
|
||
async _queryOrder(params) {
|
||
const { ctx } = this;
|
||
const { barcode, warehouseId: inputWarehouseId } = params;
|
||
|
||
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 详情(带缓存)
|
||
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._queryOrder] 查询 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(),
|
||
};
|
||
});
|
||
}
|
||
}
|
||
} catch (itemsErr) {
|
||
ctx.logger.warn('[Workbench._queryOrder] 查询订单商品失败: %s', itemsErr.message);
|
||
}
|
||
|
||
// 步骤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)
|
||
const normalizedInterceptStatus = String(orderRow.intercept_status || '').trim() || 'none';
|
||
const normalizedPackStatus = String(orderRow.pack_status || '').trim() || 'none';
|
||
const interceptFlag = normalizedInterceptStatus === 'none' ? 0 : 1;
|
||
const packFlag = normalizedPackStatus === 'none' ? 0 : 1;
|
||
|
||
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,
|
||
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,
|
||
};
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 检查条码在仓库内是否已存在(排除指定ID)
|
||
* @param {string} barcode - 条码
|
||
* @param {number} [excludeId] - 排除的工作台ID(更新时使用)
|
||
* @returns {Promise<boolean>}
|
||
*/
|
||
async checkBarcodeExists(barcode, excludeId) {
|
||
const { ctx } = this;
|
||
const warehouseId = ctx.user.store_id;
|
||
|
||
if (!barcode) return false;
|
||
|
||
const where = {
|
||
warehouse_id: warehouseId,
|
||
barcode: String(barcode).trim(),
|
||
};
|
||
if (excludeId) {
|
||
const { Op } = ctx.app.Sequelize;
|
||
where.id = { [Op.ne]: excludeId };
|
||
}
|
||
|
||
const count = await ctx.model.Workbench.count({ where });
|
||
return count > 0;
|
||
}
|
||
|
||
// ==================== 绑定码 / 登录码 / 令牌 ====================
|
||
|
||
/**
|
||
* 工作台绑定会话缓存 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 客户端编码
|
||
* @return {Promise<{code: string, state: Object}>} 新绑定码与会话状态
|
||
*/
|
||
async refreshWorkbenchBindCode(clientCode) {
|
||
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: '绑定成功',
|
||
};
|
||
}
|
||
|
||
// 超时:重新生成绑定码后才返回数据。
|
||
const refreshed = await this.refreshWorkbenchBindCode(clientCode);
|
||
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 缓存/接口信息(不含 token、login_code 敏感字段)。
|
||
* @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,
|
||
barcode: plain.barcode,
|
||
status: plain.status,
|
||
type: plain.type,
|
||
remark: plain.remark,
|
||
device_ids: plain.device_ids,
|
||
created_at: plain.created_at,
|
||
updated_at: plain.updated_at,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 绑定工作台:校验缓存绑定码 + 工作台归属后写入随机 token(供 workbench.bind)。
|
||
* - 成功后在 wms_workbench.token 写入随机生成的 token;
|
||
* - 若工作台已有 token,删除旧 workbench:token:{token} 缓存;
|
||
* - 更新绑定会话状态为 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 → 工作台信息缓存。
|
||
await app.setCacheAsync(
|
||
this.getWorkbenchTokenCacheKey(newToken),
|
||
this.formatWorkbenchTokenInfo(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)。
|
||
* 先查缓存 workbench:token:{token},未命中则查库并回填缓存;查无信息返回失败(403)。
|
||
* @param {Object} [data={}] - { token }
|
||
* @return {Promise<Object>} { success, code, data, message }
|
||
*/
|
||
async getWorkbenchInfoByToken(data = {}) {
|
||
const { ctx, app } = this;
|
||
try {
|
||
const rawToken = typeof data.token === 'string' ? data.token.trim() : '';
|
||
if (!rawToken) {
|
||
return {
|
||
success: false,
|
||
code: 0,
|
||
statusCode: 400,
|
||
data: null,
|
||
message: 'token 不能为空',
|
||
};
|
||
}
|
||
|
||
const tokenCacheKey = this.getWorkbenchTokenCacheKey(rawToken);
|
||
let cached = null;
|
||
try {
|
||
cached = await app.getCacheAsync(tokenCacheKey);
|
||
} catch (cacheErr) {
|
||
app.coreLogger.warn(`读取工作台 token 缓存失败: ${cacheErr.message}`);
|
||
}
|
||
if (cached) {
|
||
return { success: true, code: 200, data: cached, message: 'ok' };
|
||
}
|
||
|
||
const record = await ctx.model.Workbench.findOne({
|
||
where: { token: rawToken },
|
||
});
|
||
if (!record) {
|
||
return {
|
||
success: false,
|
||
code: 0,
|
||
statusCode: 403,
|
||
data: null,
|
||
message: '工作台不存在或 token 无效',
|
||
};
|
||
}
|
||
|
||
const info = this.formatWorkbenchTokenInfo(record);
|
||
await app.setCacheAsync(tokenCacheKey, info, WORKBENCH_TOKEN_CACHE_TTL_SECONDS);
|
||
return { success: true, code: 200, data: info, message: 'ok' };
|
||
} catch (error) {
|
||
app.coreLogger.error(`通过 token 获取工作台信息失败: ${error.message}`);
|
||
return {
|
||
success: false,
|
||
code: 0,
|
||
data: null,
|
||
message: '获取工作台信息失败,请稍后重试',
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 通过 login_code 获取工作台 token(供 index.LoginWorkbenchByCode)。
|
||
* 按 wms_workbench.login_code 查询;查无工作台返回失败(403);
|
||
* 工作台尚无 token 时自动生成并持久化(等价于补绑定)。
|
||
* @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 });
|
||
}
|
||
|
||
await app.setCacheAsync(
|
||
this.getWorkbenchTokenCacheKey(token),
|
||
this.formatWorkbenchTokenInfo(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)。
|
||
* 重新生成随机 login_code 并写入数据库。
|
||
* @param {number} id - 工作台 ID
|
||
* @return {Promise<{id: number, login_code: string}>} 新登录码
|
||
*/
|
||
async resetLoginCode(id) {
|
||
const { ctx } = 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();
|
||
await record.update({ login_code: loginCode });
|
||
|
||
return { id: record.id, login_code: loginCode };
|
||
}
|
||
}
|
||
|
||
module.exports = WorkbenchService;
|