pqs-9100_client/frontend/src/views/home/components/test.vue

<template>
  <div class="dialog" v-bind="dialogBig">
    <div class="dialog-title">
      <el-progress
          style="width: 90%"
          :percentage="percentage"
          :color="customColors"/>

      <el-button
          type="primary"
          v-if="testStatus=='process' && activeIndex < TEST_TOTAL"
          :disabled="activeIndex===0"
          :icon="VideoPause"
          @click="emit('update:testStatus','paused')">停止检测
      </el-button>

      <el-button type="success" v-if="activeIndex >= TEST_TOTAL" :icon="Check" disabled>检测完成</el-button>

      <el-button
          type="warning"
          v-if="testStatus=='paused' && activeIndex < TEST_TOTAL"
          :icon="Refresh"
          @click="emit('update:testStatus','process')"
      >继续检测
      </el-button>
      <el-button type="text" :icon="InfoFilled" @click="showTestLog">检测项进度</el-button>
      <!-- <el-button
        type="warning"
        v-if="activeIndex >= TEST_TOTAL"
        :icon="Refresh"
        @click="handleReCheck"
        >重新检测</el-button
      > -->
      <!-- <el-button type="danger" :icon="Close" @click="handleFinishTest"
        >停止检测</el-button
      > -->

    </div>

    <div class="dialog-content">
      <el-table :data="checkResultView" :cell-class-name="tableCell" row-key="scriptId" height="450px"
                :header-cell-style="{ background: '#003078', color: '#eee', textAlign: 'center' } " style="width: 100%"
                border>
        <el-table-column fixed prop="scriptItemName" label="检测项目" width="140px" align="center">
        </el-table-column>

        <template v-if="chnSum<=MAX_CHN_SUM">
          <el-table-column v-for="(item,index1) in deviceList" :key="item.deviceId" :label="item.deviceName"
                           :min-width="110" align="center">
            <el-table-column v-for="(chnItem,index2) in item.chnNum" :key="`${item.deviceId}${chnItem}`"
                             :label="'通道'+chnItem" align="center">
              <template #default="{row}">
                <el-tooltip
                    :content="row.devices[index1].chnResult[index2].resultType==='info' ? '暂无数据' : '点击查看详情'"
                    placement="top">
                  <el-button
                      :disabled="row.devices[index1].chnResult[index2].resultType=='info'"
                      :type="row.devices[index1].chnResult[index2].resultType"
                      size="small"
                      @click="handleClick(row.scriptId,item.deviceId,chnItem)"
                  >
                    {{ row.devices[index1].chnResult[index2].resultValue }}
                  </el-button>
                </el-tooltip>
              </template>
            </el-table-column>
          </el-table-column>
        </template>

        <template v-else>
          <el-table-column v-for="(item,index) in deviceList" :key="item.deviceId" :label="item.deviceName"
                           :min-width="110" align="center">
            <template #default="{row}">
              <el-tooltip :content="row.devices[index].chnResult[0].resultType==='info' ? '暂无数据' : '点击查看详情'"
                          placement="top">
                <el-button
                    :disabled="row.devices[index].chnResult[0].resultType=='info'"
                    :type="row.devices[index].chnResult[0].resultType"
                    size="small"
                    @click="handleClick(row.scriptId,item.deviceId,-1)"
                >
                  {{ row.devices[index].chnResult[0].resultValue }}
                </el-button>
              </el-tooltip>
            </template>
          </el-table-column>
        </template>

      </el-table>
    </div>

  </div>
  <el-drawer v-model="drawer" title="检测项进度">
    <!-- <div ref="scrollContainer"  > -->
    <p v-for="(item, index) in testLogList"
       :key="index"
       :style="{color:item.type==='error'?'#F56C6C':'var(--el-text-color-regular)'}">
      {{ item.log }}<br/>
    </p>
    <!-- </div> -->
  </el-drawer>

  <resultPopup
      :visible="resultDialogVisible"
      @update:visible="resultDialogVisible = $event"
  ></resultPopup>
  <dataCheckSingleChannelSingleTestPopup ref="dataCheckSingleChannelSingleTestPopupRef"/>
</template>
<script lang="tsx" setup name="test">
import {Check, InfoFilled, Refresh, VideoPause} from '@element-plus/icons-vue'
import resultPopup from './resultPopup.vue'
import dataCheckSingleChannelSingleTestPopup from './dataCheckSingleChannelSingleTestPopup.vue'
import {reactive, ref} from "vue";
import {dialogBig} from "@/utils/elementBind";
import {CheckData} from "@/api/check/interface"
import {useCheckStore} from "@/stores/modules/check";


const checkStore = useCheckStore()

const drawer = ref(false)
const showTestLog = () => {
  drawer.value = true
}

// 总测试项数
const TEST_TOTAL = 12
// 最大通道数
const MAX_CHN_SUM = 10
// 当前进行的测试项索引
const activeIndex = ref(0)

const dataCheckSingleChannelSingleTestPopupRef = ref();

// const currentRow = ref<{
//   id: number;
//   scriptItemName: string;
//   name: string;
//   address: string;
//   hasChildren?: boolean;
//   children?: User[]
// } | null>(null);
// const currentRow = ref(null); // 用于存储当前选中的行


const deviceList = reactive<CheckData.Device[]>([
  // {
  //   deviceID: '1',
  //   deviceName: '240001',
  //   chnNum: 1,
  //   monitorIdx: 1,
  //   label: '240001',
  //   prop: 'Result1',
  // },
  // {
  //   deviceID: '2',
  //   deviceName: '240002',
  //   chnNum: 1,
  //   monitorIdx: 2,
  //   label: '240002',
  //   prop: 'Result2',
  // },
  // {
  //   deviceID: '3',
  //   deviceName: '240003',
  //   chnNum: 2,
  //   monitorIdx: 1,
  //   label: '240003',
  //   prop: 'Result3',
  // },
  // {
  //   deviceID: '4',
  //   deviceName: '240004',
  //   chnNum: 4,
  //   monitorIdx: 2,
  //   label: '240004',
  //   prop: 'Result4',
  // }
])

// 总通道数
const chnSum = computed(() => {
  let sum = 0
  deviceList.forEach((item) => {
    sum += item.chnNum
  })
  return sum
})

onBeforeMount(() => {
  initScriptData()
  initDeviceList()
  initCheckResult()
})

// 检测脚本数据
const scriptData = reactive<CheckData.ScriptItem[]>([])
// 初始化检测脚本数据
const initScriptData = () => {
  Object.assign(scriptData, [
    {
      id: '1',
      scriptItemName: '频率'
    },
    {
      id: '2',
      scriptItemName: '电压'
    },
    {
      id: '3',
      scriptItemName: '谐波电压'
    },
    {
      id: '4',
      scriptItemName: '谐波电流'
    },
    {
      id: '5',
      scriptItemName: '谐波有功功率'
    },
    {
      id: '6',
      scriptItemName: '间谐波电压'
    },
    {
      id: '7',
      scriptItemName: '间谐波电流'
    },
    {
      id: '8',
      scriptItemName: '暂态'
    },
    {
      id: '9',
      scriptItemName: '电流'
    },
    {
      id: '10',
      scriptItemName: '电压不平衡度'
    },
    {
      id: '11',
      scriptItemName: '电流不平衡度'
    },
    {
      id: '12',
      scriptItemName: '短时闪变'
    },
  ])

}
// 初始化设备列表
const initDeviceList = () => {
  checkStore.devices.forEach(item => {
    deviceList.push({
      deviceId: item.deviceId,
      deviceName: item.deviceName,
      chnNum: item.chnNum,
    })
  })
}
// 真正的检测结果（详细到通道）
const checkResult = reactive<CheckData.ScriptChnItem[]>([])
// 初始化检测结果 （详细到通道）
const initCheckResult = () => {
  scriptData.forEach(item => {
    // 处理当前节点的数据
    let temp: CheckData.ScriptChnItem = {
      scriptId: item.id,
      scriptItemName: item.scriptItemName,
      devices: []
    }
    for (let i = 0; i < deviceList?.length; i++) {
      let tempChnResult: CheckData.ChnCheckResultEnum[] = []
      for (let j = 0; j < deviceList[i].chnNum; j++) {
        tempChnResult.push(CheckData.ChnCheckResultEnum.UNKNOWN)
      }
      temp.devices.push({
        deviceId: deviceList[i].deviceId,
        deviceName: deviceList[i].deviceName,
        chnResult: tempChnResult
      })
    }
    checkResult.push(temp)
  })
}
// 更新检测结果（详细到通道）
const updateCheckResult = (data: CheckData.ScriptChnItem) => {
  const {scriptId} = {...data}

  checkResult.forEach(item => {
    if (item.scriptId == scriptId) {
      item.devices.forEach((device, index) => {
        device.chnResult = [...data.devices[index].chnResult]
      })
    }
  })
}

// 用来展示的检测结果
const checkResultView = computed(() => {

  let result: CheckData.ScriptChnViewItem[] = checkResult.map(item => {
    let temp: CheckData.ScriptChnViewItem = {
      scriptId: item.scriptId,
      scriptItemName: item.scriptItemName,
      devices: []
    }

    item.devices.forEach(device => {
      let tempChnBtnResult: CheckData.ButtonResult[] = []

      if (chnSum.value <= MAX_CHN_SUM) {
        for (let j = 0; j < device.chnResult.length; j++) {
          if (device.chnResult[j] == CheckData.ChnCheckResultEnum.UNKNOWN) {
            tempChnBtnResult.push({resultType: 'info', resultValue: '-'})
          } else if (device.chnResult[j] == CheckData.ChnCheckResultEnum.FAIL) {
            tempChnBtnResult.push({resultType: 'danger', resultValue: '×'})
          } else {
            tempChnBtnResult.push({resultType: 'success', resultValue: '√'})
          }
        }
      } else {
        let tempChnResult: CheckData.ChnCheckResultEnum = device.chnResult[0]
        if (device.chnResult.some(item => item == CheckData.ChnCheckResultEnum.FAIL)) {
          tempChnResult = CheckData.ChnCheckResultEnum.FAIL
        }
        if (tempChnResult == CheckData.ChnCheckResultEnum.UNKNOWN) {
          tempChnBtnResult.push({resultType: 'info', resultValue: '-'})
        } else if (tempChnResult == CheckData.ChnCheckResultEnum.FAIL) {
          tempChnBtnResult.push({resultType: 'danger', resultValue: '×'})
        } else {
          tempChnBtnResult.push({resultType: 'success', resultValue: '√'})
        }
      }

      temp.devices.push({
        deviceId: device.deviceId,
        deviceName: device.deviceName,
        chnResult: tempChnBtnResult
      })
    })
    return temp
  })

  return result
})

const scrollContainer = ref<HTMLElement | null>(null); // 声明 scrollContainer
const scrollToBottom = () => {
  if (scrollContainer.value) {
    scrollContainer.value.scrollTop = scrollContainer.value.scrollHeight;
  }
};

function getRandomInt(max: number): number {
  return Math.floor(Math.random() * max)
}

//判断该检测项（例如 频率准确度检测）是否全部合格（所有设备所有通道所有子检测项目全部合格为合格，否则为不合格）
function getItemCheckResult(index: number): boolean {
  let items = errorCheckItem.filter((item) => item === index.toString())
  if (items.length > 0) {
    return false
  } else {
    return true
  }
}

//测试项开始检测时间（或继续检测时间）
const startData = ref(new Date())
//测试项检测结束时间（或暂停时的时间）
const endData = ref(new Date())
const timeDifference = ref(0)

function getTimeDifference(timeDifference: number): string {
  // 将时间差转换为天、小时、分钟、秒
  const millisecondsPerDay = 1000 * 60 * 60 * 24;
  const millisecondsPerHour = 1000 * 60 * 60;
  const millisecondsPerMinute = 1000 * 60;
  const millisecondsPerSecond = 1000;

  const days = Math.floor(timeDifference / millisecondsPerDay);
  const hours = Math.floor((timeDifference % millisecondsPerDay) / millisecondsPerHour);
  const minutes = Math.floor((timeDifference % millisecondsPerHour) / millisecondsPerMinute);
  const seconds = Math.floor((timeDifference % millisecondsPerMinute) / millisecondsPerSecond);
  if (days > 0) {
    return `: ${days} 天, ${hours} 小时, ${minutes} 分钟, ${seconds} 秒`
  } else if (hours > 0) {
    return `: ${hours} 小时, ${minutes} 分钟, ${seconds} 秒`
  } else {
    return `: ${minutes} 分钟, ${seconds} 秒`
  }
}

// 用来存放检测日志
const testLogList = ref<CheckData.LogItem[]>([{type: 'info', log: '暂无数据，等待检测开始'}])

// 更新日志
const updateLog = () => {
  const currentTime = ref(new Date().toLocaleString());
  let timeDifferenceItem = 0

  switch (activeIndex.value) {
    case 1:
      timeDifference.value = 0;
      testLogList.value.length = 0; // 清空数组
      testLogList.value.push({
        type: 'info',
        log: currentTime.value + '：检测开始',
      })
      startData.value = new Date();
      break;
    case 2:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：频率准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：频率准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 3:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 4:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：谐波电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：谐波电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 5:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：谐波电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：谐波电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 6:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：谐波有功功率准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：谐波有功功率准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 7:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：间谐波电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：间谐波电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 8:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：间谐波电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：间谐波电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 9:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：暂态准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：暂态准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 10:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 11:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：电压不平衡度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：电压不平衡度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 12:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：电流不平衡度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：电流不平衡度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }
      startData.value = new Date();
      break;
    case 13:
      endData.value = new Date();
      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
      timeDifference.value += timeDifferenceItem
      if (getItemCheckResult(activeIndex.value - 1)) {
        testLogList.value.push({
          type: 'info',
          log: currentTime.value + '：闪变准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      } else {
        testLogList.value.push({
          type: 'error',
          log: currentTime.value + '：闪变准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
        })
      }

      testLogList.value.push({
        type: 'info',
        log: currentTime.value + '：检测结束，总用时' + getTimeDifference(timeDifference.value),
      })
      break;
  }
  scrollToBottom();
}

// 用来存放检测出现失败的测试项id。只要有一个通道检测不合格，则该检测项的id会被加入该数组。
const errorCheckItem = reactive<string[]>([]);

// 动态获取表格单元格样式
function tableCell({row, columnIndex}) {
  let items = errorCheckItem.filter((item) => item === row.scriptId)

  if (columnIndex === 0 && items.length > 0) {
    return 'warning-row'
  }
  if (columnIndex === 0) {
    return 'header-row'
  }
}

// 百分比
const percentage = ref(0);

const customColors = [
  {color: "#5cb87a", percentage: 100}, //绿
];

const resultDialogVisible = ref(false)

function clear() {
}

const updateCheckResultView = (scriptId: string) => {
  const temp = simulateCheck(scriptId)
  updateCheckResult(temp)
  // traverseTableData(scriptData, id);
};

// 模拟检测 todo 可移除
const simulateCheck = (scriptId: string) => {
  let devices = []

  devices = deviceList.map(item => {

    let tempChnResult: CheckData.ChnCheckResultEnum[] = []
    for (let i = 0; i < item.chnNum; i++) {
      tempChnResult.push(CheckData.ChnCheckResultEnum.SUCCESS)
    }

    let randomNum = getRandomInt(item.chnNum * 2)
    if (activeIndex.value >= 4 && activeIndex.value <= 6) {
      if (randomNum <= item.chnNum) {
        tempChnResult[randomNum] = CheckData.ChnCheckResultEnum.FAIL

        errorCheckItem.push(scriptId)
      }
    }

    return {
      deviceId: item.deviceId,
      deviceName: item.deviceName,
      chnResult: tempChnResult,
    }
  })

  let tempScriptChnItem: CheckData.ScriptChnItem = {
    scriptId,
    devices,
  }

  return tempScriptChnItem
}

const handleReCheck = () => {
  activeIndex.value = 0;
  percentage.value = 0;
  // tableData.value.length = 0;
  testLogList.value.length = 0;
  errorCheckItem.length = 0;
  //tableData.value = JSON.parse(JSON.stringify(operatorTableData.value));
  resumeTimer()
};

// 用来保存定时器
const timer: any = ref("");

// 处理暂停、继续按钮点击事件
const handlePauseOrContinue = () => {
  const currentTime = ref(new Date().toLocaleString());

  if (testStatus.value == "paused") {
    endData.value = new Date();
    const Pausetime = endData.value.getTime() - startData.value.getTime();
    timeDifference.value += Pausetime

    testLogList.value.push({
      type: 'info',
      log: currentTime.value + '：暂停检测',
    })
    pauseTimer()
  }
  if(testStatus.value == "process"){
    startData.value = new Date();
    testLogList.value.push({
      type: 'info',
      log: currentTime.value + '：继续检测',
    })
    resumeTimer()
  }
};

// 点击查看（设备）通道检测详情。参数1：设备信息，参数2：通道号，-1：代表查看全部通道
const handleClick = (scriptId:string,deviceId: any, chnNum: number) => {
  dataCheckSingleChannelSingleTestPopupRef.value?.open(scriptId, deviceId, chnNum);
};

const props = defineProps({
  testStatus: {
    type: String,
    default: 'waiting'
  }
})
const testStatus = toRef(props, 'testStatus');

//监听goods_sn的变化
watch(testStatus, function (newValue, oldValue) {
  if (newValue == 'start') {
    emit('update:testStatus', 'process')
    startTimer()
  }
  if (newValue == 'paused' && oldValue == 'process') {
    handlePauseOrContinue()
  }
  if (newValue === 'process' && oldValue == 'paused') {
    handlePauseOrContinue()
  }
})

const emit = defineEmits(['update:testStatus']);

const startTimer = () => {
  //if (timer.value !== null) return; // 如果定时器已经启动，则不再重复启动
  timer.value = setInterval(() => {
    if (activeIndex.value <= TEST_TOTAL) {
      activeIndex.value++;
      updateLog()

      switch (activeIndex.value) {
        case 1:
          // todo 向后端获取检测结果
          // updateCheckResult(null)

          // updateCheckResultView("1-1-1")
          // updateCheckResultView("1-1-2")
          // updateCheckResultView("1-1-3")
          // updateCheckResultView("1-1-4")
          // updateCheckResultView("1-1")
          // updateCheckResultView("1-2-1")
          // updateCheckResultView("1-2")
          // updateCheckResultView("1-3-1")
          // updateCheckResultView("1-3")
          updateCheckResultView("1")
          break;
        case 2:
          // updateCheckResultView("2-1-1")
          // updateCheckResultView("2-1-2")
          // updateCheckResultView("2-1-3")
          // updateCheckResultView("2-1-4")
          // updateCheckResultView("2-1-5")
          // updateCheckResultView("2-1")
          // updateCheckResultView("2-2-1")
          // updateCheckResultView("2-2")
          // updateCheckResultView("2-3-1")
          // updateCheckResultView("2-3")
          updateCheckResultView("2")
          break;
        case 3:
        case 4:
        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
        case 10:
        case 11:
        case 12:
          updateCheckResultView(activeIndex.value.toString())
          break;
      }

      if (percentage.value < 100) {
        percentage.value = Math.trunc(activeIndex.value / TEST_TOTAL * 100);
      } else {
        percentage.value = 100;
        clearInterval(timer.value)
        timer.value = null;
        emit('update:testStatus', 'success')

        ElMessageBox.alert('检测全部结束,你可以停留在此页面查看检测结果，或返回首页进行复检、报告生成和归档等操作', '检测完成', {
          // if you want to disable its autofocus
          // autofocus: false,
          confirmButtonText: '确定',
        })
        clear();
      }
    } else {
      clearInterval(timer.value)
      timer.value = null;
      emit('update:testStatus', 'success')
      scrollToBottom();
    }
  }, 2000);
};

const pauseTimer = () => {
  if (timer.value) {
    clearInterval(timer.value);
    timer.value = null;
  }
  console.log('暂停中')
};

const resumeTimer = () => {
  if (!timer.value) {
    startTimer();
  }
  console.log('开始继续检测')
};

//完成检测
const handleFinishTest = () => {
  resultDialogVisible.value = true
  ElMessage.success("完成检测");
};

</script>

<style scoped lang="scss">

:deep(.el-table .header-row) {
  // background-color:var(--el-color-warning-light-9);
  background-color: #f5f7fa;
  // color:red;
  // font-size:30px;
  // --el-table-tr-bg-color: var(--el-color-warning-light-9);
}

:deep(.el-table .warning-row) {
  // background-color:var(--el-color-warning-light-9);
  //background-color:#bed96557;
  color: red;
  // font-size:30px;
  // --el-table-tr-bg-color: var(--el-color-warning-light-9);
  // background-color:#f5f7fa;
  // position: relative;
}

// :deep(.el-table .warning-row::before) {
//   content: '*'; /* 必须设置content属性 */
//   position: absolute;
//   color:red;
//   background-color:#f5f7fa;
// }

.el-table .success-row {
  --el-table-tr-bg-color: var(--el-color-success-light-9);
}

.dialog {
  display: flex;
  flex-direction: column;
  overflow-y: hidden;
  overflow-x: hidden;
}

.dialog-title {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-right: 10px;
  margin-bottom: 10px;
}

.dialog-content {
  max-height: 450px;
  overflow-y: hidden;
}

:deep(.el-collapse-item__header) {
  height: 30px;
}

.dialog-log {
  height: 50px;
  overflow-y: hidden;
  // flex-grow: 1;
  // display: flex;
  // flex-direction: column-reverse;

  p {
    margin: 5px 0;
    font-size: 14px;
  }
}

</style>

<style lang="scss" scoped>
:deep(.el-button--small) {
  height: 20px !important;
  width: 20px !important;
}

:deep(.el-table--default  td ) {
  padding: 5px 0 !important;
}

</style>