From 6f45735adfdcd973a19f638f9ced9629f79cd6de Mon Sep 17 00:00:00 2001
From: shimai <shimai@example.com>
Date: Wed, 15 Apr 2026 16:12:01 +0800
Subject: [PATCH] v2.0: 提交当前所有变更，准备创建v2.0标签
---
web-app/src/contexts/CaseDataContext.jsx | 214 +++++++++++++++++++++--------------------------------
1 files changed, 84 insertions(+), 130 deletions(-)
diff --git a/web-app/src/contexts/CaseDataContext.jsx b/web-app/src/contexts/CaseDataContext.jsx
index 01a920c..99c4c75 100644
--- a/web-app/src/contexts/CaseDataContext.jsx
+++ b/web-app/src/contexts/CaseDataContext.jsx
@@ -90,7 +90,12 @@
};
/**
- * 触发智能外呼
+ * [已废弃] 触发智能外呼（前端直接调用）
+ * 改造后由后端 /trigger API 驱动，前端不再直接发起外呼
+ */
+
+ /**
+ * 触发后端外呼（通过 MQ 异步处理）
* @param {Object} timeline - 案件时间线数据
*/
const triggerOutboundCall = async (timeline) => {
@@ -105,11 +110,6 @@
console.warn('调解状态已结束,mediation.state:', state);
return;
}
- // 检查是否已有活跃任务，如有则跳过
- if (hasActiveOutboundJobs()) {
- console.log('检测到活跃外呼任务，跳过发起新外呼');
- return;
- }
const mediationId = timeline.id;
const caseId = timeline.case_id;
@@ -119,113 +119,25 @@
return;
}
- console.log('发起智能外呼，mediationId:', mediationId, ', caseId:', caseId);
+ console.log('触发后端外呼，mediationId:', mediationId, ', caseId:', caseId);
- // 调用外呼API
- const response = await OutboundBotAPIService.makeCallV2({
+ // 调用后端 /trigger API（由后端校验状态 + 防重复 + MQ 异步处理）
+ const response = await OutboundBotAPIService.triggerOutbound({
mediationId: String(mediationId),
caseId: String(caseId),
callAuto: 0,
callPersonId: ''
});
- // 处理响应
- if (response?.data && Array.isArray(response.data)) {
- const successJobs = [];
- const failedJobs = [];
-
- // 分类成功和失败的记录
- response.data.forEach(item => {
- if (item.errorCode === 0 && item.jobId) {
- successJobs.push({
- jobId: item.jobId,
- callStatus: item.callStatus || 'Scheduling',
- personId: item.personId,
- mediationId: item.mediationId,
- caseId: String(caseId), // 添加 caseId 字段用于轮询
- perTypeName: item.perTypeName || '', // 当事人类型名称（申请方当事人/被申请方当事人）
- perClassName: item.perClassName || '', // 添加人员类型名称
- trueName: item.trueName || '', // 添加真实姓名
- startTime: item.createTime || item.createdTime || item.start_time, // 兼容 createTime 和 createdTime
- pollStartTime: Date.now(),
- retryCount: 0
- });
- } else if (item.errorCode > 0) {
- failedJobs.push({
- personId: item.personId,
- message: item.message || '未知错误',
- perTypeName: item.perTypeName || '', // 当事人类型名称（申请方当事人/被申请方当事人）
- perClassName: item.perClassName || '', // 添加人员类型名称
- trueName: item.trueName || '', // 添加真实姓名
- errorCode: item.errorCode, // 添加错误码
- startTime: new Date(item.startTime || item.start_time).getTime() // 转换为时间戳
- });
- }
- });
-
- // 存储成功的任务到 localStorage
- if (successJobs.length > 0) {
- localStorage.setItem(OUTBOUND_JOBS_KEY, JSON.stringify(successJobs));
- console.log('存储外呼任务成功，数量:', successJobs.length);
-
- // 外呼成功后，清除对应的失败记录
- const storedFailedJobs = JSON.parse(localStorage.getItem(`${OUTBOUND_JOBS_KEY}_failed`) || '[]');
- if (storedFailedJobs.length > 0) {
- // 获取成功任务的 personId 列表
- const successPersonIds = successJobs.map(job => job.personId);
- // 过滤掉已成功的 personId 对应的失败记录
- const remainingFailedJobs = storedFailedJobs.filter(job => !successPersonIds.includes(job.personId));
- localStorage.setItem(`${OUTBOUND_JOBS_KEY}_failed`, JSON.stringify(remainingFailedJobs));
- console.log('外呼成功后清除失败记录，清除数量:', storedFailedJobs.length - remainingFailedJobs.length);
- }
-
- // 触发自定义事件，通知 OutboundCallWidget 组件立即刷新
- setTimeout(() => {
- window.dispatchEvent(new CustomEvent('outbound-jobs-updated'));
- }, 300);
- }
-
- // 存储失败的任务到 localStorage（用于气泡显示）
- if (failedJobs.length > 0) {
- console.log('准备存储失败任务:', failedJobs);
- // 读取现有的失败任务
- const storedFailedJobs = JSON.parse(localStorage.getItem(`${OUTBOUND_JOBS_KEY}_failed`) || '[]');
-
- // 去重：按 personId 去重，保留最新的错误信息
- const uniqueFailedJobs = [...storedFailedJobs];
- failedJobs.forEach(newJob => {
- const existingIndex = uniqueFailedJobs.findIndex(job => job.personId === newJob.personId);
- if (existingIndex >= 0) {
- // 更新已存在的失败任务
- uniqueFailedJobs[existingIndex] = newJob;
- } else {
- // 添加新的失败任务
- uniqueFailedJobs.push(newJob);
- }
- });
-
- // 清理超过24小时的失败任务
- const now = Date.now();
- const cleanedFailedJobs = uniqueFailedJobs.filter(job => {
- return (now - job.startTime) < 24 * 60 * 60 * 1000; // 24小时
- });
-
- localStorage.setItem(`${OUTBOUND_JOBS_KEY}_failed`, JSON.stringify(cleanedFailedJobs));
- console.log('存储外呼失败任务，数量:', cleanedFailedJobs.length);
- }
-
- // 提示失败的任务
- if (failedJobs.length > 0) {
- const failedMsg = failedJobs
- .map(job => `${job.personId}（${job.message}）`)
- .join('、');
- message.warning(`部分联系人外呼失败：${failedMsg}`);
- console.warn('部分外呼失败:', failedJobs);
+ if (response?.data) {
+ console.log('后端外呼触发结果:', response.data);
+ if (response.data.queued) {
+ console.log('外呼任务已提交到队列，等待后端处理');
}
}
} catch (err) {
- console.error('智能外呼发起失败:', err);
- message.error('智能外呼发起失败，请检查网络后重试');
+ console.error('后端外呼触发失败:', err);
+ // 不显示错误提示，后端已有降级处理
}
};
@@ -375,20 +287,6 @@
return;
}
- EvidenceAPIService.processCaseFilesOcr(params.caseId).catch((ocrError) => {
- console.error('触发案件文件OCR失败:', ocrError);
- });
-
- try {
- await OutboundBotAPIService.syncStatusByCase({ caseId: params.caseId });
- } catch (syncError) {
- console.error('同步外呼状态失败:', syncError);
- }
- try {
- await OutboundBotAPIService.backfillConversationByCase({ caseId: params.caseId });
- } catch (backfillError) {
- console.error('回补通话记录失败:', backfillError);
- }
// 调用API获取数据
// 将URL中的auth_token转换为authorization传入API
@@ -404,6 +302,14 @@
// 提取timeline数据
const timelineData = response.timeline || response.data?.timeline || response;
+ // 调试日志：输出提取的timeline数据
+ console.log('===== API数据提取 =====');
+ console.log('原始response:', response);
+ console.log('提取的timelineData:', timelineData);
+ console.log('timelineData.mediation:', timelineData.mediation);
+ console.log('timelineData.mediation?.state:', timelineData.mediation?.state);
+ console.log('========================');
+
// 提取nodes数据（确保为数组），兼容 nodeList 和 nodes 两种字段名
const nodesData = response.data?.nodeList || response.data?.nodes || response.nodes || [];
@@ -416,19 +322,17 @@
setHasLoaded(true); // 标记已加载
// 并行加载证据材料和调解协议数据（在终态检查之前，确保数据完整性）
- await Promise.all([
- loadEvidenceData({
- caseId: params.caseId,
- caseType: params.caseType || params.caseTypeFirst,
- caseTypeFirst: params.caseTypeFirst,
- platformCode: params.platform_code
- }),
- loadAgreementData(params.caseId)
- ]);
+ await loadEvidenceData({
+ caseId: params.caseId,
+ caseType: params.caseType || params.caseTypeFirst,
+ caseTypeFirst: params.caseTypeFirst,
+ platformCode: params.platform_code
+ });
+ loadAgreementData(params.caseId);
// 检查终态状态（调解成功/失败/人工接管），终态不执行外呼和存储
const mediationState = timelineData.mediation?.state;
- const isTerminalState = [2, 3, 4].includes(mediationState);
+ const isTerminalState = [2, 3, 4, 5].includes(mediationState);
if (isTerminalState) {
console.log('案件已处于终态状态:', mediationState, '，跳过外呼和存储');
@@ -445,15 +349,34 @@
// 加载任务时间数据
await loadTaskTime(timelineData);
+ EvidenceAPIService.processCaseFilesOcr(params.caseId).catch((ocrError) => {
+ console.error('触发案件文件OCR失败:', ocrError);
+ });
+
+ try {
+ await OutboundBotAPIService.syncStatusByCase({ caseId: params.caseId });
+ } catch (syncError) {
+ console.error('同步外呼状态失败:', syncError);
+ }
+ try {
+ await OutboundBotAPIService.backfillConversationByCase({ caseId: params.caseId });
+ } catch (backfillError) {
+ console.error('回补通话记录失败:', backfillError);
+ }
+
console.log('Case data loaded successfully:', timelineData);
} catch (err) {
console.error('Failed to load case data:', err);
setError(err.message || '加载案件数据失败');
// 显示错误提示
- message.error('加载案件数据失败，请稍后重试');
+ message.error('加载案件数据失败，使用模拟数据');
- // 使用Mock数据（缓存数据不包含nodes，所以统一使用Mock）
+ // 使用Mock数据作为降级方案
+ const mockTimeline = mockTimelineData.data?.timeline || mockTimelineData;
+ console.log('使用Mock数据降级:', mockTimeline);
+ setCaseData(mockTimeline);
+ setProcessNodes(mockTimelineData.data?.nodes || []);
setHasLoaded(true);
} finally {
@@ -462,10 +385,40 @@
};
/**
- * 刷新数据（强制从API获取）
+ * 刷新数据（强制从API获取，含全部副作用）
*/
const refreshData = () => {
loadCaseData(true);
+ };
+
+ /**
+ * 轻量级刷新：仅更新 timeline + processNodes，不触发外呼/OCR等副作用
+ * 适用于周期性轮询场景，避免重复触发外呼任务
+ */
+ const refreshNodeData = async () => {
+ try {
+ const params = getMergedParams();
+ if (!params.caseId) return;
+
+ const response = await ProcessAPIService.getCaseProcessInfo(
+ params.caseId,
+ {
+ caseTypeFirst: params.caseTypeFirst,
+ platform_code: params.platform_code,
+ authorization: params.auth_token || params.authorization || ''
+ }
+ );
+
+ const timelineData = response.timeline || response.data?.timeline || response;
+ const nodesData = response.data?.nodeList || response.data?.nodes || response.nodes || [];
+
+ // 仅更新数据状态，不触发任何副作用
+ setCaseData(timelineData);
+ setProcessNodes(Array.isArray(nodesData) ? nodesData : []);
+ console.log('[refreshNodeData] 轻量刷新完成, current_node:', timelineData.current_node?.node_name);
+ } catch (err) {
+ console.warn('[refreshNodeData] 轻量刷新失败:', err);
+ }
};
// 防止重复加载的引用标识
@@ -498,6 +451,7 @@
loading,
error,
refreshData,
+ refreshNodeData, // 轻量级刷新（仅 timeline + nodes）
loadCaseData,
taskStartTime, // 任务开始时间
isTaskTimeFallback, // 是否降级模式
--
Gitblit v1.8.0