process loading bug；报告

wujingjing

2024-11-05 022a757742c70b3106d817461464e821b537e794

 src/components/chat/chatComponents/summaryCom/SummaryCom.vue

@@ -1,294 +1,80 @@
<template>
   <div class="w-full">
      <template v-if="data && data.length > 0">
         <template v-if="summaryList && summaryList.length > 0">
            <div class="w-full" v-for="(item, idx) in summaryList" :key="idx">
               <h3>{{ item.title }}</h3>
               <el-table ref="tableRefList" class="w-full" :data="[{}]">
                  <el-table-column v-for="(col, index) in item.values" :label="col.title" :key="index">
                     <template #default="scope">
                        {{ col?.value }}
                     </template>
                  </el-table-column>
               </el-table>
            </div>
   <div class="w-full space-y-3">
      <template v-if="parsedData && parsedData.length > 0">
         <template v-for="(item, index) in parsedData" :key="item.id">
            <el-button v-if="showReportIndex.includes(index) && conclusion.length > 0" @click="showAgentReport(index)">报告</el-button>
            <component
               ref="componentRef"
               :id="item.id"
               :is="summaryAnswerTypeMapCom[item.type]"
               :data="item"
               :originData="originData"
               :summaryIndex="index"
               chartHeight="20rem"
               :tableLimitHeight="tableLimitHeight"
               @updateQuery="(res) => updateRecordSet(index, res)"
            ></component>
         </template>

         <div
            class="flex-column w-full"
            :class="{ 'mt-10': summaryList && summaryList.length > 0 }"
            v-if="recordSetList && recordSetList.length > 0"
         >
            <div class="h-[20rem] flex-auto w-full">
               <div ref="chartRef" v-for="(item, index) in recordSetList" :key="index"></div>
            </div>
         </div>
         <div v-if="urlList && urlList.length > 0" class="w-full">
            <!-- <HTMLCom data="http://101.133.133.173:8019/ai_html/views/demo/html/MonthlyPay.html" v-for="(item, index) in urlList" :key="index"></HTMLCom> -->
            <HTMLCom :data="item.url" v-for="(item, index) in urlList" :key="index"></HTMLCom>
         </div>
      </template>
      <ReportDlg v-model="infoDlgIsShow" :report="report" :agentKey="agentKey"></ReportDlg>
   </div>
</template>

<script setup lang="ts">
import * as echarts from 'echarts';
import type { TableInstance } from 'element-plus';
import _ from 'lodash';
import type { ShallowRef } from 'vue';
import { computed, onMounted, ref, shallowRef } from 'vue';
import { AnswerType } from '../../model/types';
import { PATH_ICON, SCATTER_SYMBOL_SIZE, chatComProps, timeDataOptionToContent } from '../common';
import HTMLCom from '../htmlCom/HTMLCom.vue';
import { ChartTypeEnum, chartTypeMapEchart } from '../types';
import { axisLabelFormatter } from '/@/utils/chart';
import { usePageDisplay } from '/@/hooks/usePageDisplay';
import { debounce } from '/@/utils/util';
import { computed, ref } from 'vue';
import { chatComProps } from '../common';
import { SummaryAnswerType, summaryAnswerTypeMapCom } from './components/types';
// import AmisPageTest from './components/amisPage/AmisPageTest.vue';

import ReportDlg from './ReportDlg.vue';
const props = defineProps(chatComProps);
const tableLimitHeight = document.body.clientHeight * 0.7;

const selectChartType = ref<ChartTypeEnum>(ChartTypeEnum.Line);

const columnsWidth = 120;

const chartRef = ref<HTMLDivElement[] | HTMLDivElement>(null);
const tableRef = ref<TableInstance>(null);
const tableRefList = computed(() => {
   let refList: TableInstance[] = [];
   if (!tableRef.value) {
      refList = [];
   } else {
      const first = tableRef.value?.[0];
      if (first) {
         refList = tableRef.value as unknown as TableInstance[];
      } else {
         refList = [tableRef.value as unknown as TableInstance];
const parsedData = computed<any[]>(() => {
   const newData = (props.data ?? []).map((item) => {
      if (item.type === SummaryAnswerType.RecordSet && item.chart === 'table') {
         item.type = SummaryAnswerType.RecordSetTable;
      }
   }

   return refList;
      return item;
   });
   return newData;
});

const chartRefList = computed(() => {
   let refList: HTMLDivElement[] = [];
   if (!chartRef.value) {
      refList = [];
   } else {
      const first = chartRef.value?.[0];
      if (first) {
         refList = chartRef.value as unknown as HTMLDivElement[];
      } else {
         refList = [chartRef.value as unknown as HTMLDivElement];
// 需要展示 report 的 索引
const showReportIndex = computed(() => {
   const agentKeySet = new Set();
   const indexList = [];
   parsedData.value.forEach((value, index) => {
      if (value?.agent_key) {
         if (!agentKeySet.has(value.agent_key)) {
            agentKeySet.add(value.agent_key);
            indexList.push(index);
         }
      }
   }
   return refList;
   });
   return indexList;
});

const recordSetList = computed(() => props.data.filter((item) => item.type === AnswerType.RecordSet));
const summaryList = computed(() => props.data.filter((item) => item.type === AnswerType.Summary));
const urlList = computed(() => props.data.filter((item) => item.type === AnswerType.Url));
const componentRef = ref<any[]>(null);

const drawAllChart = () => {
   chartInstanceList.value.map((item, index) => {
      drawChart(item, recordSetList.value[index]);
   });
};

const selectChartTypeChange = () => {
   drawAllChart();
};

const drawChart = (instance, data) => {
   const xType = 'time';
   let timeIndex = data.cols.findIndex((item) => item.type === 'time');
   if (timeIndex === -1) {
      timeIndex = 0;
const updateRecordSet = (triggerIndex, res) => {
   for (const item of componentRef.value) {
      item?.updateAll(triggerIndex, res);
   }
   const timeCol = data.cols[timeIndex];

   let valueIndex = data.cols.findIndex((item) => item.type === 'value');
   if (valueIndex === -1) {
      valueIndex = 2;
   }
   const valueCol = data.cols[valueIndex];

   let nameCol = null;
   let groupedValues = null;
   if (data.chart === 'muli_line') {
      let nameIndex = data.cols.findIndex((item) => item.type === 'name');
      if (nameIndex === -1) {
         nameIndex = 1;
      }
      nameCol = data.cols[nameIndex];
      groupedValues = _.groupBy(data.values, (item) => item[nameIndex]);
   } else if (data.chart === 'single_line') {
      groupedValues = {
         default: data.values,
      };
   } else {
      // 默认都当muli_line
      let nameIndex = data.cols.findIndex((item) => item.type === 'name');
      if (nameIndex === -1) {
         nameIndex = 1;
      }
      nameCol = data.cols[nameIndex];
      groupedValues = _.groupBy(data.values, (item) => item[nameIndex]);
   }

   const seriesData = Object.keys(groupedValues).map((item) => {
      const values = groupedValues[item];
      return {
         name: item === 'default' ? '' : item,
         data: values.map((item) => [item[timeIndex], item[valueIndex]]),
         type: chartTypeMapEchart[selectChartType.value],
         symbol: 'none',
         smooth: true,
      };
   });
   instance.setOption({
      grid: {
         // bottom: 120,
         // right: '15%',
         left: 35,
         right: 45,
         bottom: 20,
      },
      toolbox: {
         show: true,
         feature: {
            dataZoom: {
               yAxisIndex: 'none',
            },

            myBar: {
               title: '转化为柱状图',
               show: true,
               icon: PATH_ICON.bar,
               onclick: () => {
                  instance.setOption({
                     series: seriesData.map((item) => ({
                        ...item,
                        type: 'bar',
                        symbol: 'none',
                     })),
                  });
               },
            },

            myScatter: {
               title: '转化为散点图',
               show: true,
               icon: PATH_ICON.scatter,
               onclick: () => {
                  instance.setOption({
                     series: seriesData.map((item) => ({
                        ...item,
                        type: 'scatter',
                        symbol: 'circle',
                        symbolSize: SCATTER_SYMBOL_SIZE,
                     })),
                  });
               },
            },
            myLine: {
               title: '转化为曲线图',
               show: true,
               icon: PATH_ICON.line,
               onclick: () => {
                  instance.setOption({
                     series: seriesData.map((item) => ({
                        ...item,
                        type: 'line',
                        symbol: 'none',
                        smooth: true,
                     })),
                  });
               },
            },
            dataView: {
               readOnly: true,
               optionToContent: timeDataOptionToContent,
            },
            saveAsImage: {},
         },
      },

      tooltip: {
         show: true,
         trigger: 'axis',
      },
      title: {
         text: data?.title,
         left: 'center',
      },
      xAxis: {
         name: timeCol?.title,
         type: xType,
      },
      yAxis: {
         name: valueCol?.title,
         type: 'value',
         axisLabel: {
            formatter: axisLabelFormatter,
         },
      },
      series: seriesData,
      dataZoom: {
         type: 'inside',
      },
   });
};
const infoDlgIsShow = ref(false);
const report = ref(null);

const doTableLayout = () => {
   tableRefList.value.forEach((item) => {
      item.doLayout();
   });
const agentKey = ref('');

const conclusion = computed(() => props.originData?.content?.origin?.conclusion ?? []);
const showAgentReport = (agentStartIndex) => {
   const agent = parsedData.value[agentStartIndex];
   agentKey.value = agent.agent_key;
   const foundReport = conclusion.value.find((item) => item.agent_key === agentKey.value);
   report.value = foundReport;
	
   infoDlgIsShow.value = true;
};
let chartInstanceList: ShallowRef<echarts.ECharts[]> = shallowRef(null);

const showEvent = () => {
   window.addEventListener('resize', resizeChart);
};

const hideEvent = () => {
   window.removeEventListener('resize', resizeChart);
};
let resizeChart = null;
const { haveExecutedMounted } = usePageDisplay(showEvent, hideEvent);
onMounted(() => {
   setTimeout(() => {
      const parent = chartRefList.value[0]?.parentElement;
      const data = props.data;
      setTimeout(() => {
         doTableLayout();
      }, 3000);

      if (!parent) {
         return;
      }

      const parentBound = parent.getBoundingClientRect();
      let divideCount = 1;

      const width = parentBound.width / divideCount;
      chartInstanceList.value = chartRefList.value.map((item) => {
         return echarts.init(item, undefined, {
            width: width,
            height: parentBound.height,
         });
      });
      resizeChart = debounce(() => {
         const parentBound = parent.getBoundingClientRect();
         chartInstanceList.value.map((item) =>
            item.resize({
               width: parentBound.width,
               height: parentBound.height,
            })
         );
      });
      showEvent();
      haveExecutedMounted.value = true;
      drawAllChart();
   }, 1000);
});
</script>
<style scoped lang="scss"></style>