v2.0: 提交当前所有变更，准备创建v2.0标签

shimai

1 days ago 6f45735adfdcd973a19f638f9ced9629f79cd6de

 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,107 +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);
          
          // 外呼成功后，清除所有失败记录（新任务开始时应清空旧记录）
          localStorage.removeItem(`${OUTBOUND_JOBS_KEY}_failed`);
          console.log('外呼成功后清除所有失败记录');
          
          // 触发自定义事件，通知 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);
      // 不显示错误提示，后端已有降级处理
    }
  };

@@ -369,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
@@ -397,6 +301,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 || [];
@@ -420,7 +332,7 @@
      
      // 检查终态状态（调解成功/失败/人工接管），终态不执行外呼和存储
      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, '，跳过外呼和存储');
@@ -437,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 {
@@ -454,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);
    }
  };

  // 防止重复加载的引用标识
@@ -490,6 +451,7 @@
    loading,
    error,
    refreshData,
    refreshNodeData,   // 轻量级刷新（仅 timeline + nodes）
    loadCaseData,
    taskStartTime,      // 任务开始时间
    isTaskTimeFallback, // 是否降级模式