WMS_MAIN/app/service/inbox/processor.js
liufumingren e6f4d9f341 feat(inbox): 处理备注推送货主群、群类型清空接口与群按ID管理
- afterSale.handleWorkOrder: 处理备注发送到对应货主售后群(notifyGroup,内部流程不推),响应 notified_groups
- inbox.group.reset: 新增清空群类型接口(入参群主键ID),权限迁移 556
- 群登记以 group_id 为准: 移除同名群回填,群ID不存在直接新建,store_id/群信息均按 group_id 精确匹配
- changeAddr: 已有工单也把客户原文转发快递群并升级 pending_feedback(仅 pending 可升级)
- handleExpressFeedback: 工单描述售后类型显示中文(订单.物流异常)
- 同步 methods/system.json 与 changes 记录
2026-08-17 22:01:18 +08:00

809 lines
30 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 WAREHOUSE_INTERFACE_TYPE_ID = 3;
/** 历史消息过滤默认阈值:发送时间距今超过 10 分钟视为历史/补推消息,跳过 AI(可用 config.inbox.historyMessageMaxAgeMs 覆盖) */
const DEFAULT_HISTORY_MESSAGE_MAX_AGE_MS = 10 * 60 * 1000;
/**
* 站内信内容处理器。
* 负责解析入站消息正文,按 source_type 分流处理,
* 将 warehouse_id 和 store_id 挂载到 ctx 上下文供下游使用。
*/
class InboxProcessorService extends Service {
constructor(ctx) {
super(ctx);
/**
* 群信息缓存(groupId:warehouseId → { group_type, sub_type, ai_enabled, ext_data })。
* 生命周期跟随进程,写回 ext_data 时清除对应条目。
*/
this._groupCache = new Map();
}
/**
* 从缓存或 DB 拉取群信息。若群 ext_data 为空且消息携带 ext_data,自动写回并清缓存。
* @param {string} groupId 外部群ID
* @param {number} warehouseId 仓库ID
* @param {Object|null} msgExtData 入站消息的 ext_data
* @return {Promise<{group_type: string, sub_type: string, ai_enabled: number, ext_data: Object|null}>} 群类型/子类型/AI开关/扩展数据
*/
async _loadGroupInfo(groupId, warehouseId, msgExtData) {
const { ctx } = this;
const cacheKey = `${groupId}:${warehouseId}`;
// 命中缓存直接返回
const cached = this._groupCache.get(cacheKey);
if (cached) return cached;
let group = null;
try {
group = await ctx.model.InboxGroup.findOne({
attributes: [ 'group_type', 'sub_type', 'ai_enabled', 'ext_data' ],
where: { group_id: groupId, warehouse_id: warehouseId },
raw: true,
});
} catch (e) {
ctx.logger.warn(`[inbox processor] 查询群分组信息失败: ${e.message}`);
}
const info = {
group_type: (group && group.group_type) || '',
sub_type: (group && group.sub_type) || '',
ai_enabled: group ? group.ai_enabled : 0,
ext_data: (group && group.ext_data) || null,
};
// 群存在但 ext_data 为空,且入站消息带有 ext_data → 写回群配置
if (group && !info.ext_data && msgExtData && typeof msgExtData === 'object' && Object.keys(msgExtData).length > 0) {
try {
await ctx.model.InboxGroup.update(
{ ext_data: msgExtData },
{ where: { group_id: groupId, warehouse_id: warehouseId } }
);
info.ext_data = msgExtData;
ctx.logger.info(`[inbox processor] 群 ext_data 写回成功: ${groupId}`);
} catch (e) {
ctx.logger.warn(`[inbox processor] 群 ext_data 写回失败: ${e.message}`);
// 写回失败不阻塞,直接返回 info(ext_data 仍为空)
return info;
}
}
// 写入缓存
this._groupCache.set(cacheKey, info);
return info;
}
/**
* 判断消息是否为历史消息(发送时间距今超过阈值)。
* - flags.skipAi === true:外部显式要求跳过 AI。
* - flags.send_time 距今超过 config.inbox.historyMessageMaxAgeMs:视为历史/补推消息。
* - 未携带发送时间:按实时消息处理(向后兼容)。
* @param {Object} data 入站消息数据。
* @return {boolean} 是否应跳过 AI 处理。
*/
isStaleMessage(data = {}) {
const flags = data.flags || {};
if (flags.skipAi === true) return true;
const sendTime = Number(flags.send_time || 0);
if (!Number.isFinite(sendTime) || sendTime <= 0) return false;
const maxAgeMs = Number(this.app.config.inbox?.historyMessageMaxAgeMs);
const threshold = Number.isFinite(maxAgeMs) && maxAgeMs > 0
? maxAgeMs
: DEFAULT_HISTORY_MESSAGE_MAX_AGE_MS;
return Date.now() - sendTime > threshold;
}
/**
* 处理入站消息内容。
* 解析 content 后将 warehouse_id 和 store_id 写入 ctx 上下文。
*
* @param {Object} data 入站消息数据。
* @param {string} data.content 消息正文。
* @param {number} [data.warehouse_id] 仓库ID(优先使用显式传入值)。
* @param {number} [data.store_id] 货主ID(优先使用显式传入值)。
* @return {Promise<{warehouse_id: number|null, store_id: number|null, content: string}>} 处理结果。
*/
async process(data = {}) {
const { ctx } = this;
const content = String(data.content || '').trim();
if (!content) {
throw new Error('消息正文 content 不能为空');
}
// warehouse_id:优先取显式传入,否则尝试从 content 中解析
let warehouseId = data.warehouse_id != null ? Number(data.warehouse_id) : null;
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
warehouseId = this.extractWarehouseId(content) || this.getWarehouseIdFromContext();
}
// store_id:优先取显式传入,否则尝试从 content 中解析
let storeId = data.store_id != null ? Number(data.store_id) : null;
if (!Number.isFinite(storeId) || storeId <= 0) {
storeId = this.extractStoreId(content) || this.getStoreIdFromContext();
}
// 写入 ctx 上下文,供下游使用
if (!ctx.inboxContext) {
ctx.inboxContext = {};
}
ctx.inboxContext.warehouse_id = warehouseId || null;
ctx.inboxContext.store_id = storeId || null;
ctx.inboxContext.group_name = data.group_name || null;
ctx.inboxContext.user_name = data.user_name || null;
ctx.inboxContext.group_id = data.group_id || null;
ctx.inboxContext.user_id = data.user_id || null;
ctx.logger.info(
'[inbox processor] 内容处理完成 ' +
`warehouse_id=${ctx.inboxContext.warehouse_id} ` +
`store_id=${ctx.inboxContext.store_id} ` +
`content_length=${content.length}`
);
return {
warehouse_id: ctx.inboxContext.warehouse_id,
store_id: ctx.inboxContext.store_id,
content,
};
}
/**
* API 来源消息异步回执。
* 处理消息正文后,向仓库 ApiApp 回调地址 POST 确认回执。
* 回执内容为"收到",ext_data 原路带回。
* 异步执行,不阻塞入站响应。
*
* @param {Object} data 入站消息数据。
* @param {number} data.warehouse_id 仓库ID。
* @param {number} [data.store_id] 货主ID。
* @param {number} [data.parent_id] 入站消息记录ID(回执的 parent_id)。
* @param {Object} [data.ext_data] 原始透传数据。
* @param {string} [data.ext_id] 外部消息ID。
* @param {string} [data.content] 消息正文。
* @return {Promise<void>} 无返回值,异常仅记日志不抛出。
*/
async handleApiMessage(data = {}) {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const warehouseId = Number(data.warehouse_id) || 0;
const extId = String(data.ext_id || '');
const parentId = Number(data.parent_id) || null;
try {
// 1. 处理消息正文,挂载上下文
await this.process(data);
// 2. 屏蔽检查
const isBlocked = await this.isBlocked();
if (isBlocked) {
ctx.logger.info(`[inbox processor] 已屏蔽,跳过回执 ext_id=${extId}`);
return;
}
// 2.5 历史消息过滤:发送时间距今超过阈值的历史/补推消息不触发绑群与 AI,防止误建工单
if (this.isStaleMessage(data)) {
ctx.logger.info(`[inbox processor] 历史消息,跳过 AI 处理 ext_id=${extId}`);
return;
}
// 3. 绑群码识别:消息匹配"授权:CODE"时执行绑群
const bindHandled = await this.tryBindGroup(data);
if (bindHandled) return;
// 4. 加载群的 group_type / sub_type / ai_enabled / ext_data(带缓存 + 自动写回)
if (ctx.inboxContext.ai_enabled === undefined) {
const groupId = String(ctx.inboxContext.group_id || '').trim();
if (groupId) {
const info = await this._loadGroupInfo(groupId, warehouseId, data.ext_data || null);
ctx.inboxContext.group_type = info.group_type;
ctx.inboxContext.sub_type = info.sub_type;
ctx.inboxContext.ai_enabled = info.ai_enabled;
ctx.inboxContext.group_ext_data = info.ext_data;
} else {
ctx.inboxContext.ai_enabled = 0;
}
}
// 4.5 群未绑定任务类型 → 跳过 AI 处理
const groupType = String(ctx.inboxContext.group_type || '').trim();
if (!groupType) {
ctx.logger.info(`[inbox processor] 群未绑定任务类型,跳过 AI ext_id=${extId}`);
return;
}
// 5. 群未启用AI → 跳过(ai_enabled != 1 一律跳过,安全默认)
// 快递群默认 ai_enabled=0,需手动开启后才会走 AI 处理
if (ctx.inboxContext.ai_enabled !== 1) {
ctx.logger.info(`[inbox processor] 群未启用AI自动回复,跳过 AI ext_id=${extId}`);
return;
}
// 5.1 加载屏蔽用户列表,注入上下文供 AI 判断真人接管
if (!ctx.inboxContext._blockedUserIds) {
try {
const { InboxBlock } = ctx.model;
const rows = await InboxBlock.findAll({
attributes: [ 'user_id' ],
where: { warehouse_id: warehouseId },
raw: true,
});
ctx.inboxContext._blockedUserIds = new Set(
rows.map(r => String(r.user_id || '').trim()).filter(Boolean)
);
} catch (e) {
ctx.inboxContext._blockedUserIds = new Set();
}
}
// 5.2 注入入站消息ID,供下游函数(如 interceptWaybill)关联工单
ctx.inboxContext.inbound_message_id = parentId || null;
// 6. DeepSeek 两步交互(AI 内部自行判断真人接管)
const aiResult = await ctx.service.inbox.ai.processWithAI({
content: data.content || '',
ext_data: data.ext_data || null,
parentId: data.parent_id || null,
});
// 无回复且无函数调用 → 跳过,节约资源
// AI 显式指示跳过(silent 动作)→ 同上
if (aiResult.skip || (!aiResult.reply && (!aiResult.functionName || aiResult.functionName === 'none'))) {
ctx.logger.info(`[inbox processor] 无回复且未匹配函数,跳过回执 ext_id=${extId}`);
// 保存 AI 思考过程到入站消息,便于排查
if (aiResult.thoughts && aiResult.thoughts.length > 0) {
try {
await InboxMessage.update(
{ ai_thoughts: aiResult.thoughts },
{ where: { ext_id: extId } }
);
} catch (e) {
ctx.logger.warn(`[inbox processor] 保存 AI 思考记录失败: ${e.message}`);
}
}
return;
}
const replyContent = aiResult.reply || '已处理完成';
ctx.logger.info(
`[inbox processor] AI 处理完成 ext_id=${extId} ` +
`function=${aiResult.functionName || 'direct'} reply_length=${replyContent.length}`
);
// 7. AI 推理写入入站消息(便于排查)
if (aiResult.thoughts && aiResult.thoughts.length > 0) {
try {
await InboxMessage.update(
{ ai_thoughts: aiResult.thoughts },
{ where: { ext_id: extId } }
);
} catch (e) {
ctx.logger.warn(`[inbox processor] 保存 AI 思考记录失败: ${e.message}`);
}
}
// 8. 快递群:仅执行函数,不回信
if (groupType === 'express') {
ctx.logger.info(`[inbox processor] 快递群AI处理完成(不回信) ext_id=${extId}`);
return;
}
// 9. 统一回信
await this.writeOutboundReply({
warehouse_id: warehouseId,
ext_id: extId,
parent_id: parentId,
ext_data: data.ext_data || null,
group_id: ctx.inboxContext?.group_id || data.group_id || null,
user_id: ctx.inboxContext?.user_id || data.user_id || null,
group_name: ctx.inboxContext?.group_name || data.group_name || null,
user_name: ctx.inboxContext?.user_name || data.user_name || null,
}, replyContent);
} catch (error) {
ctx.logger.warn(`[inbox processor] API 回执失败 ext_id=${extId}: ${error.message}`);
}
}
/**
* 尝试识别并执行绑群操作。
* 匹配"授权:CODE",从缓存读取绑群信息并绑定货主到群。
*
* @param {Object} data 消息数据。
* @return {Promise<boolean>} 是否已处理绑群。
*/
async tryBindGroup(data = {}) {
const { ctx } = this;
const content = String(data.content || '').trim();
const warehouseId = Number(ctx.inboxContext?.warehouse_id || 0);
const groupId = String(ctx.inboxContext?.group_id || '').trim();
const bindMatch = content.match(/授权[::]\s*([A-Z0-9]{6,20})/i);
if (!bindMatch || !groupId || !warehouseId) return false;
const code = bindMatch[1].toUpperCase();
// 查群是否已绑定(直接查 DB,避免 ctx 上下文被仓库ID污染)
try {
const existingGroup = await ctx.model.InboxGroup.findOne({
attributes: [ 'store_id' ],
where: { group_id: groupId, warehouse_id: warehouseId },
raw: true,
});
if (existingGroup && existingGroup.store_id) {
await this.writeOutboundReply(data, '已在绑定状态,无需重复操作', 'bind_confirm');
return true;
}
} catch (e) {
ctx.logger.warn(`[inbox processor] 查群绑定状态异常: ${e.message}`);
}
const cacheKey = `chat:bind:${warehouseId}:${code}`;
try {
const cacheValue = await ctx.app.getCacheAsync(cacheKey);
if (!cacheValue || !cacheValue.store_id) {
await this.writeOutboundReply(data, '绑群码无效或已过期,请重新生成', 'bind_confirm');
return true;
}
let storeName = `货主${cacheValue.store_id}`;
try {
const store = await ctx.model.Store.findOne({
attributes: [ 'store_name' ],
where: { id: cacheValue.store_id },
raw: true,
});
if (store && store.store_name) storeName = store.store_name;
} catch (e) { /* ignore */ }
await ctx.model.InboxGroup.update(
{
store_id: cacheValue.store_id,
group_type: cacheValue.group_type || 'store',
sub_type: cacheValue.sub_type || null,
},
{ where: { group_id: groupId, warehouse_id: warehouseId } }
);
ctx.inboxContext.store_id = cacheValue.store_id;
ctx.inboxContext.group_type = cacheValue.group_type || 'store';
ctx.inboxContext.sub_type = cacheValue.sub_type || null;
await ctx.app.setCacheAsync(cacheKey, null, 0);
ctx.logger.info(
`[inbox processor] 绑群成功 group_id=${groupId} store=${storeName}`
);
await this.writeOutboundReply(data, `绑定「${storeName}」成功`, 'bind_confirm');
// 绑定成功后自动查询面单余额
try {
const balanceResult = await ctx.service.inbox.functions.callFunction('queryPrintBalance', {});
const balanceMsg = balanceResult?.success
? `面单余额:总量 ${balanceResult.data.print_quantity},已锁定 ${balanceResult.data.print_quantity_locked},可用 ${balanceResult.data.available}`
: `面单余额查询失败:${balanceResult?.error || '未知错误'}`;
// 使用独立 ext_id 避免与绑定成功回执冲突
await this.writeOutboundReply({ ...data, ext_id: `${data.ext_id}:balance` }, balanceMsg, 'balance');
} catch (balanceErr) {
ctx.logger.warn(`[inbox processor] 绑群后面单余额查询异常: ${balanceErr.message}`);
}
return true;
} catch (error) {
ctx.logger.error(`[inbox processor] 绑群异常: ${error.message}`);
return false;
}
}
/**
* 写入 outbound 回执并发送 HTTP 回调。
* group_id / user_id / group_name / user_name 为强制入参,
* 缺失任一将抛出异常。
*
* @param {Object} data 消息数据。
* @param {string} data.group_id 群ID(必填)。
* @param {string} data.user_id 用户ID(必填)。
* @param {string} data.group_name 群名称(必填)。
* @param {string} data.user_name 用户名称(必填)。
* @param {string} replyContent 回复内容。
* @param {string} [source='ai_reply'] 回调 source 类型:ai_reply / bind_confirm / balance / error / system。
* system 类型不要求 user_id/user_name。
* @return {Promise<void>}
*/
async writeOutboundReply(data, replyContent, source = 'ai_reply') {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const warehouseId = Number(data.warehouse_id || 0);
const extId = String(data.ext_id || '');
const parentId = Number(data.parent_id || 0);
const isSystem = source === 'system';
// 强制入参校验(system 类型不要求 user_id/user_name)
const groupId = String(data.group_id || ctx.inboxContext?.group_id || '').trim();
const userId = String(data.user_id || ctx.inboxContext?.user_id || '').trim();
const groupName = String(data.group_name || ctx.inboxContext?.group_name || '').trim();
const userName = String(data.user_name || ctx.inboxContext?.user_name || '').trim();
if (!groupId || !groupName) {
throw new Error(`回执缺少必填字段: group_id=${groupId || '?'}, group_name=${groupName || '?'}`);
}
if (!isSystem && (!userId || !userName)) {
throw new Error(`回执缺少必填字段: user_id=${userId || '?'}, user_name=${userName || '?'}`);
}
const ackExtId = `sys:ack:${extId}`;
const callbackConfig = await this.getApiAppCallbackConfig(warehouseId);
try {
let outboundId = null;
const existAck = await InboxMessage.findOne({
where: { ext_id: ackExtId }, attributes: [ 'id' ], paranoid: false,
});
if (existAck) {
outboundId = existAck.id;
} else {
const created = await InboxMessage.create({
ext_id: ackExtId, warehouse_id: warehouseId,
store_id: Number(data.store_id) || ctx.inboxContext?.store_id || null,
direction: 'outbound', parent_id: parentId || null,
source_type: 'system', source_extra: null,
target_type: 'api',
group_id: groupId,
user_id: isSystem ? null : userId,
group_name: groupName,
user_name: isSystem ? null : userName,
content: replyContent,
ext_data: data.ext_data || null, flags: {},
});
outboundId = created.id;
}
const callbackUrl = callbackConfig.url;
if (callbackUrl) {
const crypto = require('crypto');
const method = 'notify.reply';
const notifyBody = {
code: 200,
data: {
type: isSystem ? 'system' : source === 'ai_reply' ? 'ai' : source === 'bind_confirm' ? 'bind' : source === 'balance' ? 'balance' : 'error',
content: replyContent,
ext_data: data.ext_data || null,
ext_id: String(outboundId),
group_id: groupId,
...(isSystem ? {} : { user_id: userId, user_name: userName }),
group_name: groupName,
timestamp: Math.floor(Date.now() / 1000),
},
};
const bodyJson = JSON.stringify(notifyBody);
const timestamp = Math.floor(Date.now() / 1000);
const appKey = callbackConfig.appKey || '';
const appSecret = callbackConfig.appSecret || '';
// MD5 签名:MD5(appSecret + timestamp + bodyJson)
const sign = appSecret
? crypto.createHash('md5').update(appSecret + timestamp + bodyJson).digest('hex')
: '';
const urlWithSign = `${callbackUrl}?app_key=${encodeURIComponent(appKey)}&method=${encodeURIComponent(method)}&timestamp=${timestamp}&sign=${encodeURIComponent(sign)}`;
const curlResult = await ctx.curl(urlWithSign, {
method: 'POST', dataType: 'json', contentType: 'json',
data: notifyBody,
headers: { 'Content-Type': 'application/json' }, timeout: 10000,
});
// HTTP 200 且 body.code=200 → 推送成功
const pushOk = curlResult && curlResult.status === 200
&& (!curlResult.data || curlResult.data.code === undefined || curlResult.data.code === 200);
// 记录出站通知日志到 wms_warehouse_log
try {
const { WarehouseLog } = ctx.model;
await WarehouseLog.create({
log_id: 'WN-' + Date.now() + '-' + crypto.randomBytes(3).toString('hex'),
app_key: appKey || null,
method,
warehouse_id: warehouseId || null,
url: urlWithSign || null,
http_status: curlResult ? curlResult.status : null,
body: JSON.stringify(notifyBody).substring(0, 65535),
result: curlResult ? JSON.stringify(curlResult.data || {}).substring(0, 65535) : '',
use_time: Date.now() - timestamp * 1000,
created_at: new Date(),
});
} catch (logErr) {
ctx.logger.error('[notify-log] 日志写入失败: ' + logErr.message);
}
if (pushOk) {
await InboxMessage.update(
{
push_status: 2,
push_response: { http_status: curlResult.status, body: curlResult.data || null },
pushed_at: ctx.app.Sequelize.literal('CURRENT_TIMESTAMP'),
},
{ where: { ext_id: ackExtId } }
);
// 同步更新原入站消息的推送状态
if (parentId) {
await InboxMessage.update(
{
push_status: 2,
pushed_at: ctx.app.Sequelize.literal('CURRENT_TIMESTAMP'),
},
{ where: { id: parentId } }
);
}
} else {
// 推送失败:回写状态和原因
await InboxMessage.update(
{
push_status: 3,
push_response: {
http_status: curlResult ? curlResult.status : null,
body: curlResult ? (curlResult.data || null) : null,
error: curlResult ? '回调返回非200或code非200' : '回调无响应',
},
},
{ where: { ext_id: ackExtId } }
);
}
} else {
// 未配置回调地址:回写状态
await InboxMessage.update(
{
push_status: 3,
push_response: { error: '未配置回调地址(wms_api_app.callback_url为空)' },
},
{ where: { ext_id: ackExtId } }
);
ctx.logger.info(`[inbox processor] 仓库 ${warehouseId} 未配置回调地址,回写失败状态 ext_id=${extId}`);
}
} catch (error) {
ctx.logger.warn(`[inbox processor] 回执写入失败: ${error.message}`);
// 推送异常时更新状态 + 写日志
try {
await InboxMessage.update(
{ push_status: 3, push_response: { error: error.message } },
{ where: { ext_id: ackExtId } }
);
} catch (updateErr) {
ctx.logger.error('[inbox processor] 更新推送状态失败: ' + updateErr.message);
}
try {
const { WarehouseLog } = ctx.model;
const crypto = require('crypto');
await WarehouseLog.create({
log_id: 'WN-' + Date.now() + '-' + crypto.randomBytes(3).toString('hex'),
app_key: (await this.getApiAppCallbackConfig(warehouseId)).appKey || null,
method: 'notify.reply',
warehouse_id: warehouseId || null,
http_status: null,
body: '', result: 'Error: ' + error.message,
use_time: null, created_at: new Date(),
});
} catch (logErr) {
ctx.logger.error('[notify-log] 失败日志写入异常: ' + logErr.message);
}
}
}
/**
* 检查当前消息的群/用户是否在屏蔽列表中。
*
* @return {Promise<boolean>} 是否已屏蔽。
*/
async isBlocked() {
const { ctx } = this;
const app = ctx.app;
const groupId = String(ctx.inboxContext?.group_id || '').trim();
const userId = String(ctx.inboxContext?.user_id || '').trim();
const warehouseId = Number(ctx.inboxContext?.warehouse_id || 0);
if (!groupId && !userId) return false;
try {
// 1. 尝试从缓存读取屏蔽列表
const cacheKey = `inbox:block:${warehouseId}`;
let blockedSet = await app.getCacheAsync(cacheKey);
if (!blockedSet || !(blockedSet instanceof Set)) {
// 2. 缓存未命中,查库并填入缓存
const { InboxBlock } = ctx.model;
const rows = await InboxBlock.findAll({
attributes: [ 'group_id', 'user_id' ],
where: { warehouse_id: warehouseId },
raw: true,
});
blockedSet = new Set();
for (const row of rows) {
const g = String(row.group_id || '').trim();
const u = String(row.user_id || '').trim();
if (g && u) blockedSet.add(`${g}:${u}`);
if (g && !u) blockedSet.add(`${g}:*`);
if (!g && u) blockedSet.add(`*:${u}`);
}
// TTL 5 分钟
await app.setCacheAsync(cacheKey, blockedSet, 300);
}
// 3. 检查当前消息是否命中屏蔽规则
if (groupId && userId && blockedSet.has(`${groupId}:${userId}`)) return true;
if (groupId && blockedSet.has(`${groupId}:*`)) return true;
if (userId && blockedSet.has(`*:${userId}`)) return true;
return false;
} catch (error) {
ctx.logger.warn(`[inbox processor] 屏蔽检查异常: ${error.message}`);
return false;
}
}
/**
* 失效屏蔽缓存,在新增屏蔽记录后调用。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<void>} 无返回值。
*/
async invalidateBlockCache(warehouseId) {
const { ctx } = this;
try {
await ctx.app.setCacheAsync(`inbox:block:${warehouseId}`, null, 0);
} catch (error) {
ctx.logger.warn(`[inbox processor] 失效屏蔽缓存失败: ${error.message}`);
}
}
/**
* 获取仓库 ApiApp 回调配置(URL + 签名凭证)。
*
* @param {number} warehouseId 仓库ID。
* @return {Promise<{url: string|null, appKey: string|null, appSecret: string|null}>}
*/
async getApiAppCallbackConfig(warehouseId) {
const { ctx } = this;
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
return { url: null, appKey: null, appSecret: null };
}
try {
const apiApp = await ctx.model.ApiApp.findOne({
attributes: [ 'callback_url', 'self_app_key', 'self_app_secret' ],
where: {
warehouse_id: warehouseId,
interface_type_id: WAREHOUSE_INTERFACE_TYPE_ID,
is_enabled: 1,
},
raw: true,
});
return {
url: (apiApp && apiApp.callback_url) || null,
appKey: (apiApp && apiApp.self_app_key) || null,
appSecret: (apiApp && apiApp.self_app_secret) || null,
};
} catch (error) {
ctx.logger.warn(`[inbox processor] 查询回调配置失败: ${error.message}`);
return { url: null, appKey: null, appSecret: null };
}
}
/**
* 获取仓库 ApiApp 回调地址(兼容旧调用)。
* @param {number} warehouseId 仓库ID。
* @return {Promise<string|null>} 回调 URL。
*/
async getApiAppCallbackUrl(warehouseId) {
const config = await this.getApiAppCallbackConfig(warehouseId);
return config.url;
}
/**
* 系统通知异步推送:仅 POST 回调,不写 inbox_message。
* @param {Object} data 通知数据。
* @param {number} data.warehouse_id 仓库ID。
* @param {string} data.group_id 目标群ID。
* @param {string} data.group_name 目标群名称。
* @param {string} data.content 通知内容。
* @param {Object} [data.ext_data] 群扩展数据(渠道信息)。
* @param {number} [data.store_id] 目标货主ID(用于写入回信记录的 store_id)。
* @return {void} 无返回值,异步写入与推送。
*/
pushSystemNotification(data = {}) {
const { ctx } = this;
const warehouseId = Number(data.warehouse_id);
const groupId = String(data.group_id || '').trim();
const groupName = String(data.group_name || '').trim();
const content = String(data.content || '').trim();
const extData = data.ext_data || null;
const storeId = Number(data.store_id) || null;
if (!warehouseId || !groupId || !content) return;
// 构造 data 对象,复用 writeOutboundReply
const replyData = {
warehouse_id: warehouseId,
ext_id: `sys:notify:${warehouseId}:${groupId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
parent_id: null,
ext_data: extData,
group_id: groupId,
user_id: '',
group_name: groupName,
user_name: '',
store_id: storeId,
};
// 写库 + POST,异步不阻塞
setImmediate(() => {
this.writeOutboundReply(replyData, content, 'system').catch(err => {
ctx.logger.warn(`[pushNotify] 推送异常 group=${groupName}: ${err.message}`);
});
});
}
/**
* 尝试从消息正文中提取仓库ID。
* 子类或业务方可覆盖此方法以实现自定义解析逻辑。
*
* @param {string} content 消息正文。
* @return {number|null} 仓库ID,无法解析时返回 null。
*/
extractWarehouseId(content) {
// 默认不解析,由业务方覆盖
void content;
return null;
}
/**
* 尝试从消息正文中提取货主ID。
* 子类或业务方可覆盖此方法以实现自定义解析逻辑。
*
* @param {string} content 消息正文。
* @return {number|null} 货主ID,无法解析时返回 null。
*/
extractStoreId(content) {
// 默认不解析,由业务方覆盖
void content;
return null;
}
/**
* 从 Egg.js 请求上下文中获取仓库ID。
*
* @return {number|null} 仓库ID。
*/
getWarehouseIdFromContext() {
const { ctx } = this;
const user = ctx.user || ctx.state?.user || {};
const warehouseId = Number(user.store_id || user.warehouse_id) || null;
return Number.isFinite(warehouseId) && warehouseId > 0 ? warehouseId : null;
}
/**
* 从 Egg.js 请求上下文中获取货主ID。
*
* @return {number|null} 货主ID。
*/
getStoreIdFromContext() {
const { ctx } = this;
const user = ctx.user || ctx.state?.user || {};
const storeId = Number(user.store_id) || null;
return Number.isFinite(storeId) && storeId > 0 ? storeId : null;
}
}
module.exports = InboxProcessorService;