WMS_MAIN/app/service/inbox/message.js
liufumingren e666abc0a2 feat(inbox): 新增出站推送失败自动重推定时任务
新增 app/schedule/retry_inbox_push.js:每 3 分钟扫描「push_status=3 且失败时间在 2 小时内」的
出站消息并重推(config.inbox.pushRetryWindowMs / pushRetryLimit,单轮默认 20 条、硬上限 200),
成功即停、失败下一轮继续、超出窗口不再补推;worker 单进程执行 + app._inboxPushRetryRunning
重入锁,scanned>0 才写日志。

- inbox.message 新增 retryFailed():按 created_at ASC 逐条串行重推(先补更接近窗口边界的),
  缺 warehouse_id/group_id/group_name/content 的记录跳过并告警,retry_count 递增仅作观测
- inbox.message 新增 _repush():复用原记录重推(reuse_message_id),ext_id 剥离 sys:ack: 前缀,
  有用户信息走 ai_reply、系统通知走 system;重推期间不改记录状态,进程中断时下一轮仍能扫到
- processor.writeOutboundReply 支持 reuse_message_id:重推时跳过按 sys:ack:{ext_id} 查建记录,
  推送结果回写到原记录本身,修复系统通知(sys:notice:*)重推会另建记录、原记录状态永远停留在
  失败/待推送的问题;状态回写由 ext_id 改为按记录 id(对既有调用路径等价)
- 手动重推 retry() 改走 _repush,入参与响应文案不变,methods/system.json 无需变更

失败主因是桥接离线(回调 HTTP 200 但 body code=503:wx offline / qiwe offline),属可自愈的
临时故障;此前仅支持人工单条重推,生产已积压 2441 条未送达的客户回信与系统通知。

单测 test/inbox/retry_inbox_push.test.js 18 例(纯 mock,覆盖调度配置/重入/异常兜底/扫描条件/
窗口与上限/复用原记录/跳过与容错);AI_METHOD_ROUTING.md 方法清单已刷新(inbox/message.js 7 → 9)。
2026-09-15 22:38:38 +08:00

594 lines
20 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 { parseWhereConditions } = require('../../lib/query_condition_parser');
/** 出站推送失败自动重推:默认失败时间窗(毫秒)——超窗口的消息不再补推,避免陈旧消息打扰用户 */
const DEFAULT_PUSH_RETRY_WINDOW_MS = 2 * 60 * 60 * 1000;
/** 出站推送失败自动重推:默认单轮最多重推条数(定时任务每 3 分钟扫一次) */
const DEFAULT_PUSH_RETRY_LIMIT = 20;
/** 出站推送失败自动重推:单轮条数硬上限 */
const MAX_PUSH_RETRY_LIMIT = 200;
/**
* 站内信消息查询/管理服务。
* 提供消息列表、详情、对话链、回复、统计等管理功能。
*/
class InboxMessageService extends Service {
/**
* 消息列表(多条件筛选,分页)。
* 支持两种参数风格:
* 1. 扁平风格:{ warehouseId, storeId, keyword, page, pageSize, ... }
* 2. 结构化风格:{ pagination: { page, pageSize }, where: { field: { operator, value } } }
* 时间字段使用 app.formatDate 统一格式化输出。
*
* @param {Object} params 查询参数。
* @param {number} params.warehouseId 仓库ID(必填,服务端上下文注入)。
* @param {Object} [params.pagination] 分页对象(结构化风格)。
* @param {Object} [params.where] 结构化 where 条件,字段映射同 DB 列名。
* @param {string|string[]} [params.storeId] 货主ID筛选。
* @param {string|string[]} [params.groupId] 群ID筛选。
* @param {string} [params.groupName] 群名称模糊搜索。
* @param {string} [params.userName] 用户名模糊搜索。
* @param {string} [params.content] 正文/keyword 模糊搜索。
* @param {string} [params.sourceType] 来源类型:im / api / system。
* @param {string} [params.direction] 消息方向:inbound / outbound。
* @param {number} [params.pushStatus] 推送状态:0/1/2/3。
* @param {string} [params.startDate] 开始日期。
* @param {string} [params.endDate] 结束日期。
* @param {number} [params.page=1] 页码。
* @param {number} [params.pageSize=20] 每页数量。
* @return {Promise<{list: Array, pagination: Object}>} 分页结果。
*/
async list(params = {}) {
const { ctx } = this;
const { Op } = ctx.app.Sequelize;
const { InboxMessage } = ctx.model;
const warehouseId = Number(params.warehouseId);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw new Error('warehouseId 无效');
}
// 分页:优先取 pagination 对象,兜底扁平参数
const pag = params.pagination || {};
const page = Math.max(1, Number(pag.page || params.page) || 1);
const pageSize = Math.min(200, Math.max(1, Number(pag.pageSize || params.pageSize) || 20));
// 基础条件
const where = {
warehouse_id: warehouseId,
deleted_at: null,
};
// ── 结构化 where(operator 模式)──
if (params.where && typeof params.where === 'object') {
const parsed = parseWhereConditions({
where: params.where,
app: ctx.app,
specialFieldMap: {},
});
if (!parsed.ok) {
throw new Error(`where 参数解析失败: ${parsed.reason}`);
}
// 合并解析出的条件
if (Array.isArray(parsed.result.dynamicConditions)) {
Object.assign(where, ...parsed.result.dynamicConditions);
}
// 前端约定:store_id = 0 视为无货主消息 → IS NULL
if (where.store_id !== undefined && where.store_id !== null) {
const sid = where.store_id;
// Sequelize 将 [0] 展开为 IN (0),需转为 IS NULL
if (Array.isArray(sid) && sid.length === 1 && sid[0] === 0) {
where.store_id = { [Op.is]: null };
} else if (sid === 0 || sid === '0') {
where.store_id = { [Op.is]: null };
}
}
}
// ── 扁平参数(向后兼容,结构化 where 已设置的字段会被覆盖)──
// 货主ID(-1 = 无货主消息,即 store_id IS NULL)
const rawStoreId = params.storeId;
if (rawStoreId === -1 || rawStoreId === '-1') {
where.store_id = { [Op.is]: null };
} else {
const storeIds = this._normalizeIds(rawStoreId);
if (storeIds.length > 0) {
where.store_id = { [Op.in]: storeIds };
}
}
// 群ID
const groupIds = this._normalizeStrings(params.groupId);
if (groupIds.length > 0) {
where.group_id = { [Op.in]: groupIds };
}
// 群名称
const groupName = String(params.groupName || '').trim();
if (groupName) {
where.group_name = { [Op.like]: `%${groupName}%` };
}
// 用户名
const userName = String(params.userName || '').trim();
if (userName) {
where.user_name = { [Op.like]: `%${userName}%` };
}
// 关键词:content + group_name + user_name
const rawKw = params.content || params.keyword;
const keyword = Array.isArray(rawKw)
? String(rawKw.filter(Boolean)[0] || '').trim()
: String(rawKw || '').trim();
if (keyword) {
const like = { [Op.like]: `%${keyword}%` };
where[Op.or] = [
{ content: like },
{ group_name: like },
{ user_name: like },
];
}
// 来源类型
const VALID_SOURCE_TYPES = [ 'im', 'api', 'system' ];
const sourceType = String(params.sourceType || '').trim();
if (sourceType && VALID_SOURCE_TYPES.includes(sourceType)) {
where.source_type = sourceType;
}
// 日期范围(扁平参数兜底,结构化 where 已通过 created_at 处理)
if (!where.created_at) {
const startDate = params.startDate || params.start_date;
const endDate = params.endDate || params.end_date;
if (startDate || endDate) {
where.created_at = {};
if (startDate) where.created_at[Op.gte] = new Date(startDate);
if (endDate) where.created_at[Op.lte] = new Date(endDate);
}
}
// 方向
if (params.direction && [ 'inbound', 'outbound' ].includes(params.direction)) {
where.direction = params.direction;
}
// 推送状态
if (params.pushStatus !== undefined && params.pushStatus !== null && params.pushStatus !== '') {
const status = Number(params.pushStatus);
if ([ 0, 1, 2, 3 ].includes(status)) {
where.push_status = status;
}
}
const { count: total, rows } = await InboxMessage.findAndCountAll({
attributes: {
exclude: [ 'ext_data', 'push_response', 'target_channel' ],
},
where,
order: [[ 'created_at', 'DESC' ]],
offset: (page - 1) * pageSize,
limit: pageSize,
});
// 批量查货主备注名称(StoreWarehouse.store_remask)
const storeIdsInResult = [ ...new Set(rows.map(r => r.store_id).filter(Boolean)) ];
const storeNameMap = {};
if (storeIdsInResult.length > 0) {
const contracts = await ctx.model.StoreWarehouse.findAll({
attributes: [ 'store_id', 'store_remask' ],
where: {
store_id: { [Op.in]: storeIdsInResult },
warehouse_id: warehouseId,
},
raw: true,
});
for (const c of contracts) {
storeNameMap[c.store_id] = c.store_remask || '';
}
}
const formatDate = ctx.app.formatDate;
const list = rows.map(row => {
const obj = row && typeof row.toJSON === 'function' ? row.toJSON() : row;
return {
...obj,
store_name: storeNameMap[obj.store_id] || '',
created_at: obj.created_at ? formatDate(obj.created_at) : '',
updated_at: obj.updated_at ? formatDate(obj.updated_at) : '',
pushed_at: obj.pushed_at ? formatDate(obj.pushed_at) : '',
};
});
return {
list,
pagination: {
page,
pageSize,
total,
totalPages: Math.ceil(total / pageSize),
hasPrevious: page > 1,
hasNext: page * pageSize < total,
},
};
}
/**
* 将入参统一为数字ID数组。
* 支持逗号分隔字符串 "1,2,3" 或数组 [1,2,3]。
* @param {string|string[]|number[]|undefined} val 入参。
* @return {number[]} 去重后的数字数组。
*/
_normalizeIds(val) {
if (val === undefined || val === null) return [];
const arr = Array.isArray(val) ? val : String(val).split(',');
return [ ...new Set(arr.map(Number).filter(v => Number.isFinite(v) && v > 0)) ];
}
/**
* 将入参统一为字符串数组(去重去空)。
* @param {string|string[]|undefined} val 入参。
* @return {string[]} 去重后的非空字符串数组。
*/
_normalizeStrings(val) {
if (val === undefined || val === null) return [];
const arr = Array.isArray(val) ? val : String(val).split(',');
return [ ...new Set(arr.map(String).map(s => s.trim()).filter(Boolean)) ];
}
/**
* 消息详情(含 push_response)。
* @param {Object} params 查询参数。
* @param {number} params.warehouseId 仓库ID(必填)。
* @param {number} params.id 消息ID。
* @return {Promise<Object>} 消息详情。
*/
async detail(params = {}) {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const warehouseId = Number(params.warehouseId);
const id = Number(params.id);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw new Error('warehouseId 无效');
}
if (!Number.isFinite(id) || id <= 0) {
throw new Error('消息ID无效');
}
const record = await InboxMessage.findOne({
where: { id, warehouse_id: warehouseId, deleted_at: null },
});
if (!record) {
throw new Error('消息不存在或无权访问');
}
return record;
}
/**
* 对话链查询(原消息 + 所有回信),按 parent_id 递归。
* @param {Object} params 查询参数。
* @param {number} params.warehouseId 仓库ID(必填)。
* @param {number} params.id 消息ID。
* @return {Promise<Array>} 对话链列表。
*/
async thread(params = {}) {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const warehouseId = Number(params.warehouseId);
const id = Number(params.id);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw new Error('warehouseId 无效');
}
if (!Number.isFinite(id) || id <= 0) {
throw new Error('消息ID无效');
}
// 查找根消息
const root = await InboxMessage.findOne({
where: { id, warehouse_id: warehouseId },
});
if (!root) {
throw new Error('消息不存在或无权访问');
}
// 收集对话链:从根到叶
const MAX_THREAD_DEPTH = 50;
const thread = [ root ];
const visited = new Set([ root.id ]);
// 查找所有回信(以 root.id 为 parent_id)
const replies = await InboxMessage.findAll({
where: {
warehouse_id: warehouseId,
parent_id: root.id,
deleted_at: null,
},
order: [[ 'created_at', 'ASC' ]],
});
for (const reply of replies) {
if (!visited.has(reply.id) && thread.length < MAX_THREAD_DEPTH) {
visited.add(reply.id);
thread.push(reply);
}
}
// 如果当前消息不是根(有 parent_id),也向上查找原消息
if (root.parent_id) {
const parent = await InboxMessage.findOne({
where: {
id: root.parent_id,
warehouse_id: warehouseId,
deleted_at: null,
},
});
if (parent && !visited.has(parent.id) && thread.length < MAX_THREAD_DEPTH) {
visited.add(parent.id);
thread.unshift(parent);
}
}
return thread;
}
/**
* 推送统计(按仓库 + 方向汇总)。
* @param {Object} params 统计参数。
* @param {number} params.warehouseId 仓库ID(必填)。
* @return {Promise<Object>} 统计结果。
*/
async stats(params = {}) {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const { Op } = ctx.app.Sequelize;
const warehouseId = Number(params.warehouseId);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw new Error('warehouseId 无效');
}
const where = {
warehouse_id: warehouseId,
};
if (params.direction && [ 'inbound', 'outbound' ].includes(params.direction)) {
where.direction = params.direction;
}
// 按方向统计
const directionStats = await InboxMessage.findAll({
attributes: [
'direction',
[ ctx.app.Sequelize.fn('COUNT', ctx.app.Sequelize.col('id')), 'count' ],
],
where,
group: [ 'direction' ],
raw: true,
});
// 按推送状态统计
const statusStats = await InboxMessage.findAll({
attributes: [
'push_status',
[ ctx.app.Sequelize.fn('COUNT', ctx.app.Sequelize.col('id')), 'count' ],
],
where,
group: [ 'push_status' ],
raw: true,
});
// 最近24小时统计
const recentWhere = {
...where,
created_at: {
[Op.gte]: new Date(Date.now() - 24 * 60 * 60 * 1000),
},
};
const recentCount = await InboxMessage.count({ where: recentWhere });
return {
total_by_direction: directionStats,
total_by_status: statusStats,
recent_24h_count: recentCount,
};
}
/**
* 手动重推失败(push_status=3)的站内信消息。
* 重置为待推送状态(push_status=0)并触发异步推送;
* 推送结果回写到同一记录(复用原记录,不新建回执记录)。
* @param {Object} params 重推参数。
* @param {number} params.warehouseId 仓库ID(必填,服务端上下文注入)。
* @param {number} params.id 消息ID。
* @return {Promise<Object>} { ok, id, ext_id, message }。
*/
async retry(params = {}) {
const { ctx } = this;
const { InboxMessage } = ctx.model;
const warehouseId = Number(params.warehouseId);
const id = Number(params.id);
if (!Number.isFinite(warehouseId) || warehouseId <= 0) {
throw new Error('warehouseId 无效');
}
if (!Number.isFinite(id) || id <= 0) {
throw new Error('消息ID无效');
}
const record = await InboxMessage.findOne({
where: { id, warehouse_id: warehouseId, deleted_at: null },
});
if (!record) {
throw new Error('消息不存在或无权访问');
}
if (record.push_status !== 3) {
throw new Error('仅失败状态的消息可以手动重推');
}
// 重置为待推送状态
await InboxMessage.update(
{ push_status: 0, push_response: null, push_started_at: null },
{ where: { id } }
);
// 触发异步推送(复用原记录回写推送结果)
setImmediate(() => {
this._repush(record).catch(async err => {
ctx.logger.error(`[inbox] 手动重推异步推送异常 id=${id}: ${err.message}`);
// 推送前校验失败时回写失败状态,避免消息卡在待推送
try {
await InboxMessage.update(
{ push_status: 3, push_response: { error: err.message } },
{ where: { id } }
);
} catch (updateErr) {
ctx.logger.error(`[inbox] 重推失败状态回写异常 id=${id}: ${updateErr.message}`);
}
});
});
return {
ok: true,
id: record.id,
ext_id: record.ext_id,
message: '已重置为待推送状态,正在异步重推',
};
}
/**
* 重推一条已存在的出站消息记录(推送结果回写到该记录本身,不新建记录)。
*
* 与直接调用 processor.writeOutboundReply 的区别:
* - 传 reuse_message_id,让其跳过按 `sys:ack:{ext_id}` 查建,直接复用该记录;
* - 否则 sys:notice:* 类型(warehouseNotify 系统通知)会被另建一条 sys:ack:sys:notice:*
* 记录推送,原记录状态永远停留在失败/待推送,重推也无法继续。
* 本方法推送期间不改动记录状态:推送完成由推送链路回写 2/3,进程中断则保持 3 等下一轮。
*
* @param {Object} record 消息记录(InboxMessage 行,Sequelize 实例或 raw 对象)。
* @return {Promise<void>} 推送完成(结果已回写)。
*/
async _repush(record) {
const { ctx } = this;
const extId = String(record.ext_id || '');
// 回执记录 ext_id 形如 sys:ack:{原消息ext_id},反解出原消息 ext_id 以复用推送链路
const originalExtId = extId.startsWith('sys:ack:') ? extId.slice(8) : extId;
const hasUser = Boolean(record.user_id && record.user_name);
await ctx.service.inbox.processor.writeOutboundReply({
warehouse_id: Number(record.warehouse_id) || 0,
ext_id: originalExtId,
parent_id: record.parent_id || null,
group_id: record.group_id || '',
group_name: record.group_name || '',
user_id: record.user_id || '',
user_name: record.user_name || '',
ext_data: record.ext_data || null,
reuse_message_id: Number(record.id) || 0,
}, record.content || '', hasUser ? 'ai_reply' : 'system');
}
/**
* 批量重推「推送失败」的出站消息(供定时任务调用)。
*
* 规则:
* 1. 只处理失败时间(created_at)在窗口内的记录,默认 2 小时;超窗口不再补推;
* 2. 逐条串行重推并等待结果回写,单条异常不影响其余记录;
* 3. 重推期间记录保持失败状态,进程中断时下一轮仍能被扫到(不丢消息);
* 4. 缺少 warehouse_id / group_id / group_name / content 的记录无法重放,跳过并计数。
*
* @param {Object} [params] 查询参数。
* @param {number} [params.windowMs] 失败时间窗(毫秒),默认 config.inbox.pushRetryWindowMs。
* @param {number} [params.limit] 单轮最多重推条数,默认 config.inbox.pushRetryLimit。
* @return {Promise<Object>} { scanned, retried, succeeded, failed, skipped }。
*/
async retryFailed(params = {}) {
const { ctx } = this;
const { Op } = ctx.app.Sequelize;
const { InboxMessage } = ctx.model;
const inboxConfig = (ctx.app.config && ctx.app.config.inbox) || {};
const configuredWindow = Number(inboxConfig.pushRetryWindowMs);
const windowMs = Number(params.windowMs) > 0
? Number(params.windowMs)
: (configuredWindow > 0 ? configuredWindow : DEFAULT_PUSH_RETRY_WINDOW_MS);
const configuredLimit = Number(inboxConfig.pushRetryLimit);
const rawLimit = Number(params.limit) > 0
? Number(params.limit)
: (configuredLimit > 0 ? configuredLimit : DEFAULT_PUSH_RETRY_LIMIT);
const limit = Math.min(MAX_PUSH_RETRY_LIMIT, Math.max(1, Math.trunc(rawLimit)));
// 先补早失败的消息(更快接近 2 小时窗口边界)
const rows = await InboxMessage.findAll({
where: {
direction: 'outbound',
push_status: 3,
created_at: { [Op.gte]: new Date(Date.now() - windowMs) },
},
attributes: [
'id', 'warehouse_id', 'ext_id', 'parent_id',
'group_id', 'group_name', 'user_id', 'user_name',
'ext_data', 'content',
],
order: [[ 'created_at', 'ASC' ], [ 'id', 'ASC' ]],
limit,
raw: true,
});
const summary = { scanned: rows.length, retried: 0, succeeded: 0, failed: 0, skipped: 0 };
for (const row of rows) {
if (!(Number(row.warehouse_id) > 0) || !row.group_id || !row.group_name || !row.content) {
summary.skipped++;
ctx.logger.warn(`[inbox] 自动重推跳过消息 id=${row.id}(缺少 warehouse_id/group_id/group_name/content,无法重放)`);
continue;
}
try {
await this._repush(row);
summary.retried++;
const fresh = await InboxMessage.findOne({
where: { id: row.id },
attributes: [ 'push_status' ],
raw: true,
});
if (fresh && Number(fresh.push_status) === 2) {
summary.succeeded++;
} else {
summary.failed++;
}
// 已重试次数仅作观测;失败不影响主流程
try {
await InboxMessage.increment('retry_count', { where: { id: row.id } });
} catch (countErr) {
ctx.logger.warn(`[inbox] 自动重推计数失败 id=${row.id}: ${countErr.message}`);
}
} catch (error) {
summary.failed++;
ctx.logger.warn(`[inbox] 自动重推异常 id=${row.id}: ${error.message}`);
}
}
return summary;
}
}
module.exports = InboxMessageService;