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 | 401 ++++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 366 insertions(+), 35 deletions(-)
diff --git a/web-app/src/contexts/CaseDataContext.jsx b/web-app/src/contexts/CaseDataContext.jsx
index fed5062..99c4c75 100644
--- a/web-app/src/contexts/CaseDataContext.jsx
+++ b/web-app/src/contexts/CaseDataContext.jsx
@@ -3,16 +3,22 @@
* 提供案件数据的全局状态管理和localStorage持久化
*/
-import React, { createContext, useContext, useState, useEffect } from 'react';
+import React, { createContext, useContext, useState, useEffect, useRef } from 'react';
import { message } from 'antd';
import ProcessAPIService from '../services/ProcessAPIService';
+import OutboundBotAPIService from '../services/OutboundBotAPIService';
+import EvidenceAPIService from '../services/EvidenceAPIService';
+import MediationAgreementAPIService from '../services/MediationAgreementAPIService';
import { getMergedParams } from '../utils/urlParams';
+import { mockTimelineData } from '../mocks/timeline';
+import { getFallbackStartTime, parseTimeString } from '../utils/timeFormatter';
// 创建Context
const CaseDataContext = createContext(null);
// localStorage键名
const STORAGE_KEY = 'case_data_timeline';
+const OUTBOUND_JOBS_KEY = 'outbound_call_jobs';
/**
* CaseDataProvider组件
@@ -20,23 +26,27 @@
*/
export const CaseDataProvider = ({ children }) => {
const [caseData, setCaseData] = useState(null);
+ const [processNodes, setProcessNodes] = useState([]); // 流程节点数据
const [loading, setLoading] = useState(false);
const [error, setError] = useState(null);
-
- /**
- * 从localStorage读取数据
- */
- const loadFromStorage = () => {
- try {
- const stored = localStorage.getItem(STORAGE_KEY);
- if (stored) {
- return JSON.parse(stored);
- }
- } catch (err) {
- console.error('Failed to load data from localStorage:', err);
- }
- return null;
- };
+ const [taskStartTime, setTaskStartTime] = useState(null); // 任务开始时间
+ const [isTaskTimeFallback, setIsTaskTimeFallback] = useState(false); // 是否降级模式
+ const [hasLoaded, setHasLoaded] = useState(false); // 防止重复加载
+
+ // 证据材料数据
+ const [evidenceData, setEvidenceData] = useState({
+ applicantMaterials: [],
+ respondentMaterials: [],
+ loading: false,
+ error: null
+ });
+
+ // 调解协议数据
+ const [agreementData, setAgreementData] = useState({
+ content: '',
+ loading: false,
+ error: null
+ });
/**
* 保存数据到localStorage
@@ -50,16 +60,216 @@
};
/**
+ * 检查是否有活跃的外呼任务
+ * @returns {boolean} 是否有活跃任务
+ */
+ const hasActiveOutboundJobs = () => {
+ try {
+ const stored = localStorage.getItem(OUTBOUND_JOBS_KEY);
+ if (!stored) return false;
+
+ const jobs = JSON.parse(stored);
+ const activeStatuses = [
+ 'Scheduling',
+ 'Executing',
+ 'Paused',
+ 'Drafted',
+ 'InProgress',
+ 'Calling',
+ 'Ringing',
+ 'Answered'
+ ];
+
+ // 过滤出活跃状态的任务
+ const activeJobs = jobs.filter(job => activeStatuses.includes(job.callStatus));
+ return activeJobs.length > 0;
+ } catch (err) {
+ console.error('检查活跃外呼任务失败:', err);
+ return false;
+ }
+ };
+
+ /**
+ * [已废弃] 触发智能外呼（前端直接调用）
+ * 改造后由后端 /trigger API 驱动，前端不再直接发起外呼
+ */
+
+ /**
+ * 触发后端外呼（通过 MQ 异步处理）
+ * @param {Object} timeline - 案件时间线数据
+ */
+ const triggerOutboundCall = async (timeline) => {
+ try {
+ const { mediation } = timeline;
+ if (!mediation) {
+ console.warn('缺少必要参数:timeline.mediation，跳过外呼触发:', timeline);
+ return;
+ }
+ const { state } = mediation;
+ if (state >= 2) { // 2：调解成功,3:调解失败，4:人工接管
+ console.warn('调解状态已结束,mediation.state:', state);
+ return;
+ }
+
+ const mediationId = timeline.id;
+ const caseId = timeline.case_id;
+
+ if (!mediationId || !caseId) {
+ console.warn('缺少必要参数，跳过外呼触发:', { mediationId, caseId });
+ return;
+ }
+
+ console.log('触发后端外呼，mediationId:', mediationId, ', caseId:', caseId);
+
+ // 调用后端 /trigger API（由后端校验状态 + 防重复 + MQ 异步处理）
+ const response = await OutboundBotAPIService.triggerOutbound({
+ mediationId: String(mediationId),
+ caseId: String(caseId),
+ callAuto: 0,
+ callPersonId: ''
+ });
+
+ if (response?.data) {
+ console.log('后端外呼触发结果:', response.data);
+ if (response.data.queued) {
+ console.log('外呼任务已提交到队列，等待后端处理');
+ }
+ }
+ } catch (err) {
+ console.error('后端外呼触发失败:', err);
+ // 不显示错误提示，后端已有降级处理
+ }
+ };
+
+ /**
+ * 加载任务时间数据
+ */
+ const loadTaskTime = async (timeline) => {
+ try {
+ const mediationId = timeline.id;
+ const nodeId = timeline.current_node?.id;
+
+ if (!mediationId || !nodeId) {
+ throw new Error('缺少必要的参数: mediation_id 或 node_id');
+ }
+
+ console.log('Loading task time with:', { mediationId, nodeId });
+
+ const response = await ProcessAPIService.getTaskTime(mediationId, nodeId);
+
+ // 解析API返回的开始时间
+ const startTimeStr = response.data?.startTime;
+ if (startTimeStr) {
+ const startTime = parseTimeString(startTimeStr);
+ if (startTime) {
+ setTaskStartTime(startTime);
+ setIsTaskTimeFallback(false);
+ console.log('Task start time loaded:', new Date(startTime).toLocaleString());
+ return;
+ }
+ }
+
+ throw new Error('无法解析开始时间');
+ } catch (err) {
+ console.error('Failed to load task time:', err);
+
+ // 降级到本地计时
+ const fallbackTime = getFallbackStartTime();
+ setTaskStartTime(fallbackTime);
+ setIsTaskTimeFallback(true);
+ message.warning('任务时间API不可用，使用本地计时');
+ console.log('Using fallback start time:', new Date(fallbackTime).toLocaleString());
+ }
+ };
+
+ /**
+ * 加载证据材料数据
+ * @param {Object} params - 参数对象
+ * @param {string} params.caseId - 案件ID
+ * @param {string} params.caseType - 案件类型
+ * @param {string} params.platformCode - 平台编码
+ */
+ const loadEvidenceData = async (params) => {
+ setEvidenceData(prev => ({ ...prev, loading: true, error: null }));
+
+ try {
+ const response = await EvidenceAPIService.getEvidenceList({
+ case_id: params.caseId,
+ case_type: params.caseType || params.caseTypeFirst,
+ platform_code: params.platformCode
+ });
+
+ console.log('Evidence API response:', response);
+
+ const responseData = response.data || [];
+
+ // 分离申请人和被申请人材料
+ const applicantData = responseData.find(item => item.per_type === '15_020008-1');
+ const respondentData = responseData.find(item => item.per_type === '15_020008-2');
+
+ const applicantList = applicantData?.file_list?.slice(0, applicantData.file_count) || [];
+ const respondentList = respondentData?.file_list?.slice(0, respondentData.file_count) || [];
+
+ setEvidenceData({
+ applicantMaterials: applicantList,
+ respondentMaterials: respondentList,
+ loading: false,
+ error: null
+ });
+
+ console.log('Evidence data loaded:', { applicantList, respondentList });
+ } catch (err) {
+ console.error('加载证据材料失败:', err);
+ setEvidenceData(prev => ({
+ ...prev,
+ loading: false,
+ error: err.message || '加载证据材料失败'
+ }));
+ }
+ };
+
+ /**
+ * 加载调解协议数据
+ * @param {string} caseId - 案件ID
+ */
+ const loadAgreementData = async (caseId) => {
+ setAgreementData(prev => ({ ...prev, loading: true, error: null }));
+
+ try {
+ const response = await MediationAgreementAPIService.generateAgreement(caseId);
+
+ if (response?.data?.agreeContent) {
+ setAgreementData({
+ content: response.data.agreeContent,
+ loading: false,
+ error: null
+ });
+ console.log('Agreement data loaded');
+ } else {
+ setAgreementData({
+ content: '',
+ loading: false,
+ error: '协议内容为空'
+ });
+ }
+ } catch (err) {
+ console.error('加载调解协议失败:', err);
+ setAgreementData({
+ content: '',
+ loading: false,
+ error: err.message || '加载调解协议失败'
+ });
+ }
+ };
+
+ /**
* 加载案件数据
*/
const loadCaseData = async (forceRefresh = false) => {
- // 如果不是强制刷新，先尝试从localStorage读取
- if (!forceRefresh) {
- const cachedData = loadFromStorage();
- if (cachedData) {
- setCaseData(cachedData);
- console.log('Loaded case data from localStorage');
- }
+ // 防止重复加载（除非强制刷新）
+ if (hasLoaded && !forceRefresh) {
+ console.log('Data already loaded, skipping...');
+ return;
}
setLoading(true);
@@ -71,65 +281,186 @@
console.log('Loading case data with params:', params);
+ if (!params.caseId) {
+ setError('caseId缺失');
+ setLoading(false);
+ return;
+ }
+
+
// 调用API获取数据
+ // 将URL中的auth_token转换为authorization传入API
const response = await ProcessAPIService.getCaseProcessInfo(
params.caseId,
{
caseTypeFirst: params.caseTypeFirst,
- platform_code: params.platform_code
+ platform_code: params.platform_code,
+ authorization: params.auth_token || params.authorization || ''
}
);
// 提取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 || [];
+
+ console.log('API Response:', response);
+ console.log('Extracted nodesData:', nodesData);
+
// 更新状态
setCaseData(timelineData);
+ setProcessNodes(Array.isArray(nodesData) ? nodesData : []); // 确保为数组
+ setHasLoaded(true); // 标记已加载
+
+ // 并行加载证据材料和调解协议数据（在终态检查之前，确保数据完整性）
+ 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, 5].includes(mediationState);
+
+ if (isTerminalState) {
+ console.log('案件已处于终态状态:', mediationState, '，跳过外呼和存储');
+ return;
+ }
// 保存到localStorage
saveToStorage(timelineData);
+
+ // 触发智能外呼
+ await triggerOutboundCall(timelineData);
+
+ // 加载任务时间数据
+ 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('加载案件数据失败，使用模拟数据');
- // 如果localStorage有数据，尝试使用缓存
- const cachedData = loadFromStorage();
- if (cachedData && !forceRefresh) {
- message.warning('已加载历史数据');
- setCaseData(cachedData);
- }
+ // 使用Mock数据作为降级方案
+ const mockTimeline = mockTimelineData.data?.timeline || mockTimelineData;
+ console.log('使用Mock数据降级:', mockTimeline);
+ setCaseData(mockTimeline);
+ setProcessNodes(mockTimelineData.data?.nodes || []);
+ setHasLoaded(true);
+
} finally {
setLoading(false);
}
};
/**
- * 刷新数据（强制从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);
+ }
+ };
+
+ // 防止重复加载的引用标识
+ const loadInitRef = useRef(false);
+
+ /**
* 组件挂载时加载数据
*/
useEffect(() => {
- loadCaseData();
+ console.log('===== CaseDataContext useEffect triggered =====');
+ console.log('loadInitRef.current:', loadInitRef.current);
+ console.log('hasLoaded:', hasLoaded);
+ console.log('processNodes:', processNodes);
+
+ // StrictMode下防止双重调用
+ if (!loadInitRef.current) {
+ loadInitRef.current = true;
+ console.log('Calling loadCaseData()...');
+ loadCaseData();
+ } else {
+ console.log('loadCaseData() skipped due to loadInitRef.current === true');
+ }
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []); // 只在挂载时执行一次
// 提供的值
const value = {
caseData,
+ processNodes, // 流程节点数据
loading,
error,
refreshData,
- loadCaseData
+ refreshNodeData, // 轻量级刷新（仅 timeline + nodes）
+ loadCaseData,
+ taskStartTime, // 任务开始时间
+ isTaskTimeFallback, // 是否降级模式
+ // 证据材料数据
+ evidenceData,
+ loadEvidenceData,
+ // 调解协议数据
+ agreementData,
+ loadAgreementData
};
return (
--
Gitblit v1.8.0