Merge branch 'master' of http://120.79.193.119:9090/r/~chengmw/cloud-melody...

shimai

2026-03-09 d760bcb09f1d1b373ffd417d322bc91a08c63b21

 web-app/src/contexts/CaseDataContext.jsx

@@ -52,7 +52,16 @@
      if (!stored) return false;
      
      const jobs = JSON.parse(stored);
      const activeStatuses = ['Scheduling', 'Executing', 'Paused', 'Drafted'];
      const activeStatuses = [
        'Scheduling',
        'Executing',
        'Paused',
        'Drafted',
        'InProgress',
        'Calling',
        'Ringing',
        'Answered'
      ];
      
      // 过滤出活跃状态的任务
      const activeJobs = jobs.filter(job => activeStatuses.includes(job.callStatus));
@@ -69,6 +78,16 @@
   */
  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;
      }
      // 检查是否已有活跃任务，如有则跳过
      if (hasActiveOutboundJobs()) {
        console.log('检测到活跃外呼任务，跳过发起新外呼');
@@ -94,6 +113,10 @@
      });

      // 处理响应
      console.log('triggerOutboundCall API 响应:', response);
      console.log('response.data:', response?.data);
      console.log('response.data 是数组:', Array.isArray(response?.data));
      
      if (response?.data && Array.isArray(response.data)) {
        const successJobs = [];
        const failedJobs = [];
@@ -107,22 +130,85 @@
              personId: item.personId,
              mediationId: item.mediationId,
              caseId: String(caseId), // 添加 caseId 字段用于轮询
              startTime: Date.now(),
              perClassName: item.perClassName || '', // 添加人员类型名称
              trueName: item.trueName || '', // 添加真实姓名
              startTime: item.createTime || item.createdTime || item.start_time,
              pollStartTime: Date.now(),
              retryCount: 0
            });
          } else {
          } else if (item.errorCode > 0) {
            failedJobs.push({
              personId: item.personId,
              message: item.message || '未知错误'
              message: item.message || '未知错误',
              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 existingJobs = JSON.parse(localStorage.getItem(OUTBOUND_JOBS_KEY) || '[]');
          // 按 jobId 去重，新任务优先
          const existingJobIds = new Set(successJobs.map(job => job.jobId));
          const filteredExistingJobs = existingJobs.filter(job => !existingJobIds.has(job.jobId));
          const mergedJobs = [...successJobs, ...filteredExistingJobs];
          
          localStorage.setItem(OUTBOUND_JOBS_KEY, JSON.stringify(mergedJobs));
          console.log('存储外呼任务成功，新增:', successJobs.length, '总数:', mergedJobs.length);
          console.log('存储的任务:', JSON.stringify(mergedJobs, null, 2));
          
          // 外呼成功后，清除对应的失败记录
          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);
          }
          
          // 延迟触发自定义事件，确保监听器已经设置好
          setTimeout(() => {
            console.log('触发 outbound-jobs-updated 事件');
            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);
          
          // 触发自定义事件通知 OutboundCallWidget 组件刷新
          window.dispatchEvent(new CustomEvent('outbound-jobs-updated'));
        }

        // 提示失败的任务
@@ -199,20 +285,38 @@
      
      console.log('Loading case data with params:', params);

      if (!params.caseId) {
        setError('caseId缺失');
        setLoading(false);
        return;
      }

      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获取数据
      const response = await ProcessAPIService.getCaseProcessInfo(
        params.caseId,
        {
          caseTypeFirst: params.caseTypeFirst,
          platform_code: params.platform_code
          platform_code: params.platform_code,
          authorization: params.auth_token
        }
      );

      // 提取timeline数据
      const timelineData = response.timeline || response.data?.timeline || response;
      
      // 提取nodes数据（确保为数组）
      const nodesData = response.nodes || response.data?.nodes || [];
      // 提取nodes数据（确保为数组），兼容 nodeList 和 nodes 两种字段名
      const nodesData = response.data?.nodeList || response.data?.nodes || response.nodes || [];
      
      console.log('API Response:', response);
      console.log('Extracted nodesData:', nodesData);
@@ -221,6 +325,15 @@
      setCaseData(timelineData);
      setProcessNodes(Array.isArray(nodesData) ? nodesData : []);  // 确保为数组
      setHasLoaded(true);  // 标记已加载
      
      // 检查终态状态（调解成功/失败/人工接管），终态不执行外呼和存储
      const mediationState = timelineData.mediation?.state;
      const isTerminalState = [2, 3, 4].includes(mediationState);
      
      if (isTerminalState) {
        console.log('案件已处于终态状态:', mediationState, '，跳过外呼和存储');
        return;
      }
      
      // 保存到localStorage
      saveToStorage(timelineData);
@@ -241,18 +354,8 @@
      message.error('加载案件数据失败，请稍后重试');
      
      // 使用Mock数据（缓存数据不包含nodes，所以统一使用Mock）
      console.log('===== 使用Mock数据 =====');
      const mockData = mockTimelineData.data.timeline;
      const mockNodes = mockTimelineData.data.nodes || [];
      console.log('mockData:', mockData);
      console.log('mockNodes:', mockNodes);
      setCaseData(mockData);
      setProcessNodes(mockNodes);
      saveToStorage(mockData);
      setHasLoaded(true);
      
      // Mock数据也加载任务时间
      await loadTaskTime(mockData);
    } finally {
      setLoading(false);
    }