UPDATE: 优化；

# Conflicts:
#	frontend/src/views/home/components/table.vue

frontend/package.json

@@ -14,6 +14,8 @@
   },
   "dependencies": {
     "@element-plus/icons-vue": "^2.3.1",
+    "@types/event-source-polyfill": "^1.0.5",
+    "@vue-flow/core": "^1.45.0",
     "@vueuse/core": "^10.4.1",
     "axios": "^1.7.3",
     "crypto-js": "^4.2.0",
@@ -22,6 +24,7 @@
     "echarts": "^5.4.3",
     "echarts-liquidfill": "^3.1.0",
     "element-plus": "^2.7.8",
+    "event-source-polyfill": "^1.0.31",
     "html2canvas": "^1.4.1",
     "md5": "^2.3.0",
     "mitt": "^3.0.1",
@@ -72,11 +75,11 @@
     "unplugin-auto-import": "^0.18.3",
     "unplugin-vue-components": "^0.27.4",
     "unplugin-vue-setup-extend-plus": "^1.0.0",
-    "vite": "^5.3.1",
+    "vite": "^5.4.19",
     "vite-plugin-compression": "^0.5.1",
     "vite-plugin-eslint": "^1.8.1",
     "vite-plugin-html": "^3.2.0",
-    "vite-plugin-node-polyfills": "^0.23.0",
+    "vite-plugin-node-polyfills": "^0.24.0",
     "vite-plugin-pwa": "^0.16.5",
     "vite-plugin-svg-icons": "^2.0.1",
     "vue-tsc": "^2.0.21"

frontend/src/api/check/interface/index.ts

@@ -1,126 +1,158 @@
 export namespace CheckData {
     export interface DataCheck {
-        scriptName: string,
-        errorSysId: string,
-        dataRule: string,
-        deviceName: string,
-        chnNum: string,
+        scriptName: string
+        errorSysId: string
+        dataRule: string
+        deviceName: string
+        chnNum: string
+        deviceId: string
+        num?: string | number
     }
 
     export interface PhaseCheckResult {
         // 检测源定值-标准值
-        resultData: number,
+        resultData: number
         // 装置原始数据-被检值
-        data: number,
+        data: number
 
         // 误差值
-        errorData: number,
+        errorData: number
         // 第几次谐波
-        num?: number,
+        num?: number
         //符合、不符合
-        isData?: number,
+        isData?: number
         //最大误差值
-        radius?: string,
-        unit?: string,
+        radius?: string
+        unit?: string
+    }
+    export interface DataItem {
+        num: number
+        isData: number
+        data: number
+        resultData: number
+        radius: string
+        errorData: number
+        unit: string
+    }
+
+    export interface TableRow {
+        isData: number
+        harmNum: number
+        radius: string
+        dataA: DataItem
+        dataB: DataItem
+        dataC: DataItem
+        dataT: DataItem | null
+        unit: string
+        timeDev?: string
+        uaDev?: string | number
+        ubDev?: string | number
+        ucDev?: string | number
+        utDev?: string | number
+        uaStdDev?: string | number
+        ubStdDev?: string | number
+        ucStdDev?: string | number
+        utStdDev?: string | number
     }
 
     /**
      * 用于定义 查看（设备）通道检测结果响应数据 类型
      */
     export interface ResCheckResult {
-        dataA?: PhaseCheckResult | null,
-        dataB?: PhaseCheckResult | null,
-        dataC?: PhaseCheckResult | null,
-        dataT?: PhaseCheckResult | null,
+        dataA?: PhaseCheckResult | null
+        dataB?: PhaseCheckResult | null
+        dataC?: PhaseCheckResult | null
+        dataT?: PhaseCheckResult | null
 
         // 第几次谐波
         //num: number | null,
         //符合、不符合
-        isData?: number,
+        isData?: number
         //最大误差值
-        radius?: string,
+        radius?: string
         //单位
-        unit?: string,
+        unit?: string
     }
 
     /**
      * 用于定义 查看（设备）通道检测结果表格展示数据 类型
      */
     export interface CheckResult {
-        stdA?: string,
-        dataA?: string,
-        errorA?: string,
-        maxErrorA?: string,
-        isDataA?: number,
-        unitA?: string,
-        stdB?: string,
-        dataB?: string,
-        errorB?: string,
-        maxErrorB?: string,
-        isDataB?: number,
-        unitB?: string,
-        stdC?: string,
-        dataC?: string,
-        errorC?: string,
-        maxErrorC?: string,
-        isDataC?: number,
-        unitC?: string,
-        stdT?: string,
-        dataT?: string,
-        errorT?: string,
-        maxErrorT?: string,
-        isDataT?: number,
-        unitT?: string,
+        stdA?: string
+        dataA?: string
+        errorA?: string
+        maxErrorA?: string
+        isDataA?: number
+        unitA?: string
+        stdB?: string
+        dataB?: string
+        errorB?: string
+        maxErrorB?: string
+        isDataB?: number
+        unitB?: string
+        stdC?: string
+        dataC?: string
+        errorC?: string
+        maxErrorC?: string
+        isDataC?: number
+        unitC?: string
+        stdT?: string
+        dataT?: string
+        errorT?: string
+        maxErrorT?: string
+        isDataT?: number
+        unitT?: string
 
         //最大误差值
-        maxError?: string,
-        unit?: string,
+        maxError?: string
+        unit?: string
         //符合、不符合
-        result?: number,
+        result?: number
     }
 
     /**
      * 用于定义 具体通道的原始数据类型
      */
     export interface RawDataItem {
-        time?: string,
-        harmNum?: number | null,
-        dataA?: string,
-        dataB?: string,
-        dataC?: string,
-        dataT?: string,
+        time?: string
+        harmNum?: number | null
+        dataA?: string
+        dataB?: string
+        dataC?: string
+        dataT?: string
         unit?: string | null
     }
 
     export interface Device {
-        deviceId: string;     //装置序号Id
-        deviceName: string; //设备名称
-        chnNum: number;   //设备通道数
+        deviceId: string //装置序号Id
+        deviceName: string //设备名称
+        chnNum: number //设备通道数
 
-        planId: string; //计划Id
-        devType: string; //设备类型
-        devVolt: number; //设备电压
-        devCurr: number; //设备电流
-        factorFlag: number; //是否支持系数校准
-        checkResult:number; //检测结果
+        planId: string //计划Id
+        devType: string //设备类型
+        devVolt: number //设备电压
+        devCurr: number //设备电流
+        factorFlag: number //是否支持系数校准
+        checkResult: number //检测结果
+        chnNumList: string[] //连线存储数据
     }
 
     // 用来描述检测脚本类型
     export interface ScriptItem {
-        id: string,
-        code: string,
-        scriptName: string,
+        id: string
+        code: string
+        scriptName: string
     }
 
     // 用来描述 检测数据-左侧树结构
     export interface TreeItem {
-        id: string | null,
-        scriptTypeName: string | null,
-        sourceDesc: string | null,
-        harmNum: number | null,
-        index: number | null,
-        fly: number | null,
-        children: TreeItem[] | null,
+        id: string | null
+        scriptTypeName: string | null
+        sourceDesc: string | null
+        harmNum: number | null
+        index: number | null
+        fly: number | null
+        children: TreeItem[] | null
     }
 
     // 用来描述 通道检测结果
@@ -135,16 +167,17 @@ export namespace CheckData {
     }
 
     export interface DeviceCheckResult {
-        deviceId: string,
-        deviceName: string,
+        deviceId: string
+        deviceName: string
+        code?: string
         chnResult: ChnCheckResultEnum[] //通道检测结果
     }
 
     //用来描述 某个脚本测试项对所有通道的检测结果
     export interface ScriptChnItem {
         scriptType: string
-        scriptName?: string  //可以不要该属性，有点多余
-
+        scriptName?: string //可以不要该属性，有点多余
+        code?: string
         // 设备
         devices: Array<DeviceCheckResult>
     }
@@ -154,7 +187,7 @@ export namespace CheckData {
         LOADING = 'var(--el-color-primary)',
         SUCCESS = '#91cc75',
         WARNING = '#e6a23c',
-        DANGER = '#f56c6c',
+        DANGER = '#f56c6c'
     }
 
     /**
@@ -169,18 +202,17 @@ export namespace CheckData {
      * 用于描述 脚本检测结果展示的按钮类型
      */
     export interface ScriptChnViewItem {
-        scriptType: string,
+        scriptType: string
         scriptName?: string //脚本项名称，可以不要该属性，有点多余
 
         // 设备
         devices: Array<{
-            deviceId: string,
-            deviceName: string,
-            chnResult: ButtonResult[],
+            deviceId: string
+            deviceName: string
+            chnResult: ButtonResult[]
         }>
     }
 
-
     /**
      * 定义检测日志类型
      */
@@ -193,13 +225,16 @@ export namespace CheckData {
      * 定义手动检测时，勾选的测试项
      */
     export interface SelectTestItem {
-        preTest: boolean,
-        timeTest: boolean,
-        channelsTest: boolean,
+        preTest: boolean
+        timeTest: boolean
+        channelsTest: boolean
         test: boolean
     }
+
+    //描述比对式检测项描述
+    export interface CompareTestItem {
+        id: string
+        code: string
+        name: string
+    }
 }
-
-
-
-

frontend/src/api/check/test/index.ts

@@ -1,12 +1,22 @@
-import http from "@/api";
-import {CheckData} from "@/api/check/interface";
+import { pa } from 'element-plus/es/locale/index.mjs';
+import http from '@/api'
+import {CheckData} from '@/api/check/interface'
 
 export const getBigTestItem = (params: {
-    reCheckType: number,
-    planId: string,
-    devIds: string[],
+    reCheckType: number
+    planId: string
+    devIds: string[]
+    patternId: string
 }) => {
-    return http.post(`/adPlan/getBigTestItem`, params, {loading: false});
+    return http.post(`/adPlan/getBigTestItem`, params, {loading: false})
+}
+
+export const getScriptList = (params: {
+    devId:string,
+    chnNum:number,
+    num:number
+}) => {
+    return http.post('/result/getCheckItem', params, {loading: false})
 }
 
 /**
@@ -14,12 +24,12 @@ export const getBigTestItem = (params: {
  * @param params 当为scriptType为null时，表示查询所有脚本类型，否则只查询指定脚本类型。当为chnNum为-1时，表示查询所有通道，否则只查询指定通道。
  */
 export const getFormData = (params: {
-    planId: string,
-    deviceId: string,
-    chnNum: string,
+    planId: string
+    deviceId: string
+    chnNum: string
     scriptType: string | null
 }) => {
-    return http.post("/result/formContent/", params, {loading: false});
+    return http.post('/result/formContent/', params, {loading: false})
 }
 
 /**
@@ -27,13 +37,13 @@ export const getFormData = (params: {
  * @param params
  */
 export const getTreeData = (params: {
-    scriptId?: string,
-    devId?: string,
-    devNum?: string,
-    scriptType?: string | null,
-    code?: string,
+    scriptId?: string
+    devId?: string
+    devNum?: string
+    scriptType?: string | null
+    code?: string
 }) => {
-    return http.post<CheckData.TreeItem[]>("/result/treeData/", params, {loading: false});
+    return http.post<CheckData.TreeItem[]>('/result/treeData/', params, {loading: false})
 }
 
 /**
@@ -41,25 +51,25 @@ export const getTreeData = (params: {
  * @param params
  */
 export const getTableData = (params: {
-    scriptType: string | null,
-    scriptId: string,
-    devId: string,
-    devNum: string,
-    code: string,
-    index: number,
+    scriptType: string | null
+    scriptId: string
+    devId: string
+    devNum: string
+    code: string
+    index: number
 }) => {
-    return http.post("/result/resultData/", params, {loading: false});
+    return http.post('/result/resultData/', params, {loading: false})
 }
 
 export const exportRawData = (params: {
-    scriptType: string | null,
-    scriptId: string,
-    devId: string,
-    devNum: string,
-    code: string,
-    index: number,
+    scriptType: string | null
+    scriptId: string
+    devId: string
+    devNum: string
+    code: string
+    index: number
 }) => {
-    return http.download("/result/exportRawData", params, {loading: false});
+    return http.download('/result/exportRawData', params, {loading: false})
 }
 
 /**
@@ -67,13 +77,46 @@ export const exportRawData = (params: {
  * @param params
  */
 export const reCalculate = (params: {
-    planId: string,
-    scriptId: string,
-    errorSysId: string,
-    deviceId: string,
+    planId: string
+    scriptId: string
+    errorSysId: string
+    deviceId: string
     code: string
+    patternId: string
+  
 }) => {
-    return http.post("/result/reCalculate", params, {loading: true});
+    return http.post('/result/reCalculate', params, {loading: true})
+}
+
+/**
+ * 获取数据获取基本信息
+ * @param params
+ */
+export const getContrastFormContent = (params: {
+    planId: string
+    scriptType: string
+    deviceId: string
+    chnNum: string
+    num: number | null
+    patternId: string
+}) => {
+    return http.post('/result/getContrastFormContent', params, {loading: false})
+}
+/**
+ * 获取检测结果
+ * @param params
+ */
+export const getContrastResult = (params: {
+    planId: string
+    scriptType: string
+    deviceId: string
+    chnNum: string | number
+    num: number | string | null
+    waveNum: number | null
+    isWave: boolean
+    patternId: string
+}) => {
+    return http.post('/result/getContrastResult', params, {loading: true})
 }
 
 /**
@@ -81,13 +124,14 @@ export const reCalculate = (params: {
  * @param params
  */
 export const changeErrorSystem = (params: {
-    planId: string,
-    scriptId: string,
-    errorSysId: string,
-    deviceId: string,
+    planId: string
+    scriptId: string
+    errorSysId: string
+    deviceId: string
     code: string
+    patternId: string
 }) => {
-    return http.post("/result/changeErrorSystem", params, {loading: true});
+    return http.post('/result/changeErrorSystem', params, {loading: true})
 }
 
 /**
@@ -96,4 +140,4 @@ export const changeErrorSystem = (params: {
  */
 export const deleteTempTable = (code: string) => {
     return http.get(`/result/deleteTempTable?code=${code}`, null, {loading: false})
-}
+}

frontend/src/api/device/device/deviceData.ts

@@ -266,172 +266,4 @@ const data = [
         reCheck_Num: 0, //复检次数
       },
     ]
-    // const plan_devicedata = [
-    //   {
-    //     id: '1',     //装置序号ID
-    //     name: '模拟装置1', //设备名称
-    //     dev_Type: 'PQS882A',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 0, //复检次数
-    //   },
-    //   {
-    //     id: '2',     //装置序号ID
-    //     name: '模拟装置2', //设备名称
-    //     dev_Type: 'PQS882B4',//设备类型
-    //     dev_Chns: 4,  //设备通道数
-    //     check_Result: '/', //检测结果
-    //     report_State: '未生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'未检',//检测状态
-    //     reCheck_Num: 0, //复检次数
-    //   },
-    //   {
-    //     id: '3',     //装置序号ID
-    //     name: '模拟装置3', //设备名称
-    //     dev_Type: 'PQS882B4',//设备类型
-    //     dev_Chns: 4,  //设备通道数
-    //     check_Result: '/', //检测结果
-    //     report_State: '未生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测中',//检测状态
-    //     reCheck_Num: 0, //复检次数
-    //   },
-    //   {
-    //     id: '4',     //装置序号ID
-    //     name: '模拟装置4', //设备名称
-    //     dev_Type: 'PQS882B4',//设备类型
-    //     dev_Chns: 4,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '未生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 1, //复检次数
-    //   },
-    //   {
-    //     id: '5',     //装置序号ID
-    //     name: '中电测试装置', //设备名称
-    //     dev_Type: 'PMC-680M-22-22-00-115ANBC',//设备类型
-    //     dev_Chns: 4,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '未生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 1, //复检次数
-    //   },
-    //   {
-    //     id: '6',     //装置序号ID
-    //     name: '易司拓测试装置1', //设备名称
-    //     dev_Type: 'E703A',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 1, //复检次数
-    //   },
-    //   {
-    //     id: '7',     //装置序号ID
-    //     name: '易司拓测试装置2', //设备名称
-    //     dev_Type: 'E703A',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 1, //复检次数
-    //   },
-    //   {
-    //     id: '8',     //装置序号ID
-    //     name: '山大电力测试装置1', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 1, //复检次数
-    //   },
-    //   {
-    //     id: '9',     //装置序号ID
-    //     name: '山大电力测试装置2', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '10',     //装置序号ID
-    //     name: '山大电力测试装置2', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '11',     //装置序号ID
-    //     name: '山大电力测试装置2', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '12',     //装置序号ID
-    //     name: '山大电力测试装置2', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '13',     //装置序号ID
-    //     name: '山大电力测试装置2', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '14',     //装置序号ID
-    //     name: '山大电力测试装置3', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    //   {
-    //     id: '15',     //装置序号ID
-    //     name: '山大电力测试装置4', //设备名称
-    //     dev_Type: 'SDL-3002C',//设备类型
-    //     dev_Chns: 1,  //设备通道数
-    //     check_Result: '不合格', //检测结果
-    //     report_State: '已生成', //报告状态
-    //     document_State: '未归档', //归档状态
-    //     check_State:'检测完成',//检测状态
-    //     reCheck_Num: 2, //复检次数
-    //   },
-    // ]
-    
   export default {data,plan_devicedata}

frontend/src/api/device/device/index.ts

@@ -1,3 +1,4 @@
+import { pa } from 'element-plus/es/locale/index.mjs';
 import type {Device} from '@/api/device/interface/device'
 import http from '@/api'
 
@@ -30,8 +31,8 @@ export const exportPqDev = (params: Device.ReqPqDevParams) => {
     return http.download(`/pqDev/export`, params)
 }
 // 下载导入文件模板
-export const downloadTemplate = () => {
-    return http.download(`/pqDev/downloadTemplate`)
+export const downloadTemplate = (params: { pattern: string }) => {
+    return http.download(`/pqDev/downloadTemplate`,params)
 }
 
 //导入被检设备
@@ -59,8 +60,15 @@ export const importContrastPqDev = (params: Device.ReqPqDevParams) => {
 //     return http.uploadExcel(`/pqDev/importCNDev`, params)
 // }
 
+export const getPqDevById = (params: Device.ReqPqDevParams) => {
+    return http.get(`/pqDev/getById?id=${params.id}`)
+}
 
 //根据设备类型决定（电源、icd、模板、通道数、额定电压、额定电流）；
 export const getPqDev = () => {
     return http.get(`/devType/listAll`)
 }
+
+export const getSelectOptions = (params:{ pattern: string }) => {
+    return http.get(`/pqDev/getSelectOptions`, params)
+}

frontend/src/api/device/interface/devType.ts

@@ -25,6 +25,7 @@ export namespace DevType {
     devChns: number;   //设备通道数
     reportName: string| null;//报告模版名称
     state: number;
+    waveCmd:string| null;//录波指令
     createBy?: string| null; //创建用户
     createTime?: string| null; //创建时间
     updateBy?: string| null; //更新用户

frontend/src/api/device/interface/device.ts

@@ -1,97 +1,119 @@
-import type {ReqPage, ResPage} from '@/api/interface'
+import type { ReqPage, ResPage } from '@/api/interface'
+import type { Monitor } from './monitor'
 
 // 被检设备模块
 export namespace Device {
-
     /**
      *  被检设备表格分页查询参数
      */
     export interface ReqPqDevParams extends ReqPage {
-        id: string; // 装置序号id 必填
-        name: string; //设备名称
-        devType?: string; // 设备名称
-        createTime?: string; //创建时间
-        pattern: string;
+        id: string // 装置序号id 必填
+        name: string //设备名称
+        devType?: string // 设备名称
+        createTime?: string //创建时间
+        pattern: string
     }
 
     /**
      *  被检设备表格分页查询参数
      */
     export interface ReqDevReportParams extends ReqPage {
-        planId?: string; // 计划id
-        devId?: string; // 装置id
-        scriptId?: string; // 脚本id
-        planCode?: string;
-        devIdList?: string[]; // 装置id列表
+        planId?: string // 计划id
+        devId?: string // 装置id
+        scriptId?: string // 脚本id
+        planCode?: string
+        devIdList?: string[] // 装置id列表
     }
 
     /**
      * 被检设备新增、修改、根据id查询返回的对象
      */
     export interface ResPqDev {
-        id: string;     //装置序号ID
-        name: string; //设备名称
-        pattern: string; //设备模式 模拟 数字 比对
-        devType: string;//设备类型
-        devChns: number;   //设备通道数
-        devVolt: number;   //额定电压（V）
-        devCurr: number;   //额定电流（A）
-        manufacturer?: string | null;//生产厂家
-        createDate: string; //生产日期
-        createId: string; //出厂编号
-        hardwareVersion: string; //固件版本
-        softwareVersion: string; //软件版本
-        protocol: string; //通讯协议
-        ip: string; //IP地址
-        port: number; //端口号
-        encryptionFlag: number; //装置是否为加密版本
-        series?: string | null; //装置识别码（3ds加密）
-        devKey?: string | null; //装置秘钥（3ds加密）
-        sampleId?: string | null; //样品编号
-        arrivedDate?: string; //送样日期
-        cityName?: string | null; //所属地市名称
-        gDName?: string | null; //所属供电公司名称
-        subName?: string | null; //所属电站名称
-        checkState?: number | null; //检测状态
-        checkResult?: number | null; //检测结果
-        reportState?: number | null; //报告状态
-        reportPath?: string | null; //报告路径
-        qRCode?: string | null; //设备关键信息二维码
-        reCheckNum: number; //复检次数
-        planId?: string;//检测计划Id
-        timeCheckResult?: number;//守时检测结果(0:不符合1:符合)
-        factorFlag?: number;//是否支持系数校准(0:不支持,1:支持)
-        factorCheckResult?: number;//系数校准结果(0:不合格，1:合格，2：/表示没有做系数校准)
-        state: number; //状态
-        createBy?: string | null; //创建用户
-        createTime?: string | null; //创建时间
-        updateBy?: string | null; //更新用户
-        updateTime?: string | null; //更新时间
-        icdId: string | null;
-        power: string | null;//工作电源
-        preinvestmentPlan: string | null;
-        delegate: string | null; //委托方
+        id: string //装置序号ID
+        name: string //设备名称
+        pattern: string //设备模式 模拟 数字 比对
+        devType: string //设备类型
+        manufacturer?: string | null //生产厂家
+        createDate: string //生产日期
+        createId: string //出厂编号
+        hardwareVersion: string //固件版本
+        softwareVersion: string //软件版本
+        protocol: string //通讯协议
+        ip: string //IP地址
+        port: number //端口号
+        encryptionFlag: number //装置是否为加密版本
+        series?: string | null //装置识别码（3ds加密）
+        devKey?: string | null //装置秘钥（3ds加密）
+        sampleId?: string | null //样品编号
+        arrivedDate?: string //送样日期
+        cityName?: string | null //所属地市名称
+        gdName?: string | null //所属供电公司名称
+        subName?: string | null //所属电站名称
+        reportPath?: string | null //报告路径
+        planId?: string //检测计划Id
+        factorFlag?: number //是否支持系数校准(0:不支持,1:支持)
+        preinvestmentPlan: string | null //预投计划
+        delegate: string | null //委托方
+        inspectChannel?: string[] | string //被检通道
+        inspectDate?: string | null //定检日期
+        harmSysId?: string | null //谐波系统设备id
+        importFlag?: number //是否为导入设备 0否 1是
+        state: number //状态
+        createBy?: string | null //创建用户
+        createTime?: string | null //创建时间
+        updateBy?: string | null //更新用户
+        updateTime?: string | null //更新时间
+
+        devChns: number //设备通道数
+        devVolt: number //额定电压（V）
+        devCurr: number //额定电流（A）
+        icdId: string | null
+        power: string | null //工作电源
+
+        devId?: number
+        checkState?: number | null //检测状态(0:未检，1:检测中，2:检测完成 3:归档)
+        checkResult?: number | null //检测结果(0:不符合，1:符合，2:未检)
+        reportState?: number | null //报告状态(0:未生成，1:已生成，2:未检)
+        recheckNum: number //复检次数
+        timeCheckResult?: number //守时检测结果(0:不符合1:符合)
+        factorCheckResult?: number //系数校准结果(0:不合格，1:合格，2:未检)
+        realtimeResult?: number //实时数据结论(0:不符合，1:符合，2:未检)
+        statisticsResult?: number //统计数据结论(0:不符合，1:符合，2:未检)
+        recordedResult?: number //录波数据结论(0:不符合，1:符合，2:未检)
+        checkBy?: string | null //检测人
+        checkTime?: string | null //检测时间
+        preDetectTime?: number //预检测耗时
+        coefficientTime?: number //系数校准耗时
+        formalCheckTime?: number //正式检测耗时
+
+        boundPlanName?: string | null
+        assign?: number ////是否分配给检测人员 0否 1是
+        monitorList: Monitor.ResPqMon[]
+        checked: boolean // 是否已选择
+        disabled: boolean // 是否禁用
     }
 
+    export interface SelectOption {
+        label: string
+        value: string | number
+    }
 
     export interface ResDev {
-        id: string;
-        name: string,
-        icd: string,
-        power: string,
-        devVolt: number,
-        devCurr: number,
-        devChns: number,
+        id: string
+        name: string
+        icd: string
+        power: string
+        devVolt: number
+        devCurr: number
+        devChns: number
     }
 
     export interface ResTH {
-        temperature :number | null;//温度
-        humidity:number | null;//湿度
+        temperature: number | null //温度
+        humidity: number | null //湿度
     }
     /**
      * 被检设备表格查询分页返回的对象；
      */
-    export interface ResPqDevPage extends ResPage<ResPqDev> {
-
-    }
+    export interface ResPqDevPage extends ResPage<ResPqDev> {}
 }

frontend/src/api/device/interface/icd.ts

@@ -24,6 +24,8 @@ export namespace ICD {
     createTime?: string| null; //创建时间
     updateBy?: string| null; //更新用户
     updateTime?: string| null; //更新时间
+    angle: number; // 是否支持电压相角、电流相角指标
+    usePhaseIndex: number; // 角型接线时是否使用相别的指标来进行检测
   }
 
   /**

frontend/src/api/device/interface/monitor.ts

@@ -1,33 +1,36 @@
 import type { ReqPage, ResPage } from '@/api/interface'
 
-// 被检设备模块
+// 监测点模块
 export namespace Monitor {
 
   /**
-   * 电能质量指标字典数据表格分页查询参数
+   * 监测点表格分页查询参数
    */
   export interface ReqPqMonParams extends ReqPage {
     id: string; // 装置序号id 必填
-    devType?: string; // 设备名称
-    createTime?: string; //创建时间
+    name?: string; // 设备名称
+    
   }
 
   /**
-   * 被检设备新增、修改、根据id查询返回的对象
+   * 监测点新增、修改、根据id查询返回的对象
    */
   export interface ResPqMon {
     id: string;     //监测点ID
-    code: string; //默认与谐波系统监测点ID相同
     devId: string; //所属设备ID
-    name: string; //所属母线
-    num: number; //监测点序号
-    pt: number; //PT变比
-    ct: number; //CT变比
-    ptType: string; //接线方式，字典表
+    busbar: string;//所属母线
+    name: string; //监测点名称
+    num: number; //线路号,监测点序号
+    pt: string; //PT变比
+    ct: string; //CT变比
+    connection: string; //接线方式，字典表
+    statInterval: number; //统计间隔
+    harmSysId: string; //默认与谐波系统监测点ID相同
+    checkFlag: number;//是否参与检测0否1是
   }
 
   /**
-   * 被检设备表格查询分页返回的对象；
+   * 监测点表格查询分页返回的对象；
    */
   export interface ResPqMonPage extends ResPage<ResPqMon> {
 

frontend/src/api/device/interface/standardDevice.ts

@@ -0,0 +1,47 @@
+import type { ReqPage, ResPage } from '@/api/interface'
+
+// 标准设备模块
+export namespace StandardDevice {
+
+    /**
+     *  标准设备表格分页查询参数
+     */
+    export interface ReqPqStandardDeviceParams extends ReqPage {
+        id: string; // 装置序号id 必填
+        name: string; //设备名称
+        devType?: string; // 设备名称
+        createTime?: string; //创建时间
+    }
+
+
+    /**
+     * 标准设备新增、修改、根据id查询返回的对象
+     */
+    export interface ResPqStandardDevice {
+        id: string;     //装置序号ID
+        name: string; //设备名称
+        devType: string;//设备类型
+        manufacturer?: string | null;//生产厂家
+        protocol: string;//通讯协议
+        ip: string; //IP地址
+        port: number; //端口号
+        inspectChannel:string[] |string;//可检通道数
+        encryptionFlag: number; //装置是否为加密版本
+        series?: string | null; //装置识别码（3ds加密）
+        devKey?: string | null; //装置秘钥（3ds加密）
+        state: number; //状态
+        createBy?: string | null; //创建用户
+        createTime?: string | null; //创建时间
+        updateBy?: string | null; //更新用户
+        updateTime?: string | null; //更新时间
+        disabled?: boolean;
+    }
+
+
+    /**
+     * 标准设备表格查询分页返回的对象；
+     */
+    export interface ResPqStandardDevicePage extends ResPage<ResPqStandardDevice> {
+
+    }
+}

frontend/src/api/device/monitor/index.ts

@@ -1,4 +1,3 @@
-import type { Monitor } from '@/api/device/interface/monitor'
 import http from '@/api'
 
 /**
@@ -6,23 +5,9 @@ import http from '@/api'
  */
 
 //获取监测点
-export const getPqMonList = (params: Monitor.ReqPqMonParams) => {
-  //return http.post(`/pqMon/list`, params)
-}
-
-//添加监测点
-export const addPqMon = (params: Monitor.ResPqMon) => {
-  //return http.post(`/pqMon/add`, params)
-}
-
-//编辑监测点
-export const updatePqMon = (params: Monitor.ResPqMon) => {
-  //return http.post(`/pqMon/update`, params)
-}
-
-//删除监测点
-export const deletePqMon = (params: string[]) => {
-  //return http.post(`/pqMon/delete`, params)
+export const getPqMonList = (param:any) => {
+  return http.post(`/pqMonitor/list`, param)
 }
 
 
+

frontend/src/api/device/standardDevice/index.ts

@@ -0,0 +1,55 @@
+import type { StandardDevice } from '@/api/device/interface/standardDevice'
+import http from '@/api'
+
+/**
+ * @name 标准设备管理模块
+ */
+
+//获取标准设备
+export const getPqStandardDevList = (params: StandardDevice.ReqPqStandardDeviceParams) => {
+    return http.post(`/pqStandardDev/list`, params)
+}
+
+//根据id查询标准设备
+export const getPqStandardDevById = (params: StandardDevice.ReqPqStandardDeviceParams) => {
+    return http.get(`/pqStandardDev/getById?id=${params.id}`)
+}
+
+//添加标准设备
+export const addPqStandardDev = (params: StandardDevice.ResPqStandardDevice) => {
+    return http.post(`/pqStandardDev/add`, params)
+}
+
+//编辑标准设备
+export const updatePqStandardDev = (params: StandardDevice.ResPqStandardDevice) => {
+    return http.post(`/pqStandardDev/update`, params)
+}
+
+//删除标准设备
+export const deletePqStandardDev = (params: string[]) => {
+    return http.post(`/pqStandardDev/delete`, params)
+}
+
+//导出标准设备
+export const exportPqStandardDev = (params: StandardDevice.ReqPqStandardDeviceParams) => {
+    return http.download(`/pqStandardDev/export`, params)
+}
+// 下载导入文件模板
+export const downloadTemplate = () => {
+    return http.download(`/pqStandardDev/downloadTemplate`)
+}
+
+//导入标准设备
+export const importPqStandardDev = (params: StandardDevice.ReqPqStandardDeviceParams) => {
+    return http.uploadExcel(`/pqStandardDev/import`, params)
+}
+
+//获取所有标准设备
+export const getAllPqStandardDev = () => {
+    return http.get(`/pqStandardDev/getAll`)
+}
+
+//获取可以绑定的标准设备
+export const canBindingList = () => {
+    return http.get(`/pqStandardDev/canBindingList`)
+}

frontend/src/api/index.ts

@@ -1,190 +1,240 @@
-import { ElMessage, ElTreeSelect } from 'element-plus';
-import axios, { AxiosInstance, AxiosError, AxiosRequestConfig, InternalAxiosRequestConfig, AxiosResponse } from 'axios'
+import { ElMessage } from 'element-plus'
+import axios, {
+    AxiosError,
+    type AxiosInstance,
+    type AxiosRequestConfig,
+    type AxiosResponse,
+    type InternalAxiosRequestConfig
+} from 'axios'
 import { showFullScreenLoading, tryHideFullScreenLoading } from '@/components/Loading/fullScreen'
 import { LOGIN_URL } from '@/config'
-import { ElMessage } from 'element-plus'
-import { ResultData } from '@/api/interface'
+import { type ResultData } from '@/api/interface'
 import { ResultEnum } from '@/enums/httpEnum'
 import { checkStatus } from './helper/checkStatus'
 import { useUserStore } from '@/stores/modules/user'
 import router from '@/routers'
-import {refreshToken} from '@/api/user/login'
+import { refreshToken } from '@/api/user/login'
+import { EventSourcePolyfill } from 'event-source-polyfill'
 
 export interface CustomAxiosRequestConfig extends InternalAxiosRequestConfig {
-  loading?: boolean;
+    loading?: boolean
 }
 
 const config = {
-  // 默认地址请求地址，可在 .env.** 文件中修改
-  baseURL: import.meta.env.VITE_API_URL as string,
-  // 设置超时时间
-  timeout: ResultEnum.TIMEOUT as number,
-  // 跨域时候允许携带凭证
-  withCredentials: true,
-  // post请求指定数据类型以及编码
-  headers: { 'Content-Type': 'application/json;charset=utf-8' },
+    // 默认地址请求地址，可在 .env.** 文件中修改
+    baseURL: import.meta.env.VITE_API_URL as string,
+    // 设置超时时间
+    timeout: ResultEnum.TIMEOUT as number,
+    // 跨域时候允许携带凭证
+    withCredentials: true,
+    // post请求指定数据类型以及编码
+    headers: { 'Content-Type': 'application/json;charset=utf-8' }
 }
 
 class RequestHttp {
-  service: AxiosInstance
+    service: AxiosInstance
 
-  public constructor(config: AxiosRequestConfig) {
-    // 创建实例
-    this.service = axios.create(config)
+    public constructor(config: AxiosRequestConfig) {
+        // 创建实例
+        this.service = axios.create(config)
 
-    /**
-     * @description 请求拦截器
-     * 客户端发送请求 -> [请求拦截器] -> 服务器
-     * token校验(JWT) : 接受服务器返回的 token,存储到 vuex/pinia/本地储存当中
-     */
-    this.service.interceptors.request.use(
-      (config: CustomAxiosRequestConfig) => {
-          isFirst = true
-        const userStore = useUserStore()
-        // 当前请求不需要显示 loading，在 api 服务中通过指定的第三个参数: { loading: false } 来控制
-        config.loading ?? (config.loading = true)
-        config.loading && showFullScreenLoading()
-        if (config.headers && typeof config.headers.set === 'function') {
-          config.headers.set('Authorization', 'Bearer ' + userStore.accessToken)
-          config.headers.set('Is-Refresh-Token', userStore.isRefreshToken+"")
-        }
-        return config
-      },
-      (error: AxiosError) => {
-        return Promise.reject(error)
-      },
-    )
-
-    let isFirst = true
-    /**
-     * @description 响应拦截器
-     *  服务器换返回信息 -> [拦截统一处理] -> 客户端JS获取到信息
-     */
-    this.service.interceptors.response.use(
-      async (response: AxiosResponse) => {
-        const { data } = response
-        const userStore = useUserStore()
-        tryHideFullScreenLoading()
-
-        if(data.code === ResultEnum.ACCESSTOKEN_EXPIRED){
-            // 用长token去换短token
-            userStore.setAccessToken(userStore.refreshToken)
-            userStore.setIsRefreshToken(true)
-            const result = await refreshToken()
-            if (result) { //获取新token成功的话
-              // 有新的token后，重新请求
-              userStore.setAccessToken(result.data.accessToken)
-              userStore.setRefreshToken(result.data.refreshToken)
-                userStore.setIsRefreshToken(false)
-                userStore.setExp(1000 * 60 * 60 * 24 * 30)
-              response.config.headers.Authorization = `Bearer ${result.data.accessToken}`//重新请求前需要将更新后的新token更换掉之前无效的token,不然会死循环
-              const resp = await this.service.request(response.config)
-              return resp
-            } else {
-              // 刷新失效，跳转登录页
+        /**
+         * @description 请求拦截器
+         * 客户端发送请求 -> [请求拦截器] -> 服务器
+         * token校验(JWT) : 接受服务器返回的 token,存储到 vuex/pinia/本地储存当中
+         */
+        this.service.interceptors.request.use(
+            (config: CustomAxiosRequestConfig) => {
+                isFirst = true
+                const userStore = useUserStore()
+                // 当前请求不需要显示 loading，在 api 服务中通过指定的第三个参数: { loading: false } 来控制
+                config.loading ?? (config.loading = true)
+                config.loading && showFullScreenLoading()
+                if (config.headers && typeof config.headers.set === 'function') {
+                    config.headers.set('Authorization', 'Bearer ' + userStore.accessToken)
+                    config.headers.set('Is-Refresh-Token', userStore.isRefreshToken + '')
+                }
+                return config
+            },
+            (error: AxiosError) => {
+                return Promise.reject(error)
             }
-         }
-        // 登陆失效
-        if (data.code === ResultEnum.OVERDUE) {
-          console.log("登陆失效")
-          userStore.setAccessToken('')
-          userStore.setRefreshToken('')
-            userStore.setIsRefreshToken(false)
-          userStore.setUserInfo({ id:'',name: '' })
-            userStore.setExp(0)
-          await router.replace(LOGIN_URL)
-            if(isFirst){//临时处理token失效弹窗多次
-            ElMessage.error(data.message)
-            isFirst = false
-          }
-          return Promise.reject(data)
+        )
+
+        let isFirst = true
+        /**
+         * @description 响应拦截器
+         *  服务器换返回信息 -> [拦截统一处理] -> 客户端JS获取到信息
+         */
+        this.service.interceptors.response.use(
+            async (response: AxiosResponse) => {
+                const { data } = response
+                const userStore = useUserStore()
+                tryHideFullScreenLoading()
+
+                if (data.code === ResultEnum.ACCESSTOKEN_EXPIRED) {
+                    // 用长token去换短token
+                    userStore.setAccessToken(userStore.refreshToken)
+                    userStore.setIsRefreshToken(true)
+                    const result = await refreshToken()
+                    if (result) {
+                        //获取新token成功的话
+                        // 有新的token后，重新请求
+                        userStore.setAccessToken(result.data.accessToken)
+                        userStore.setRefreshToken(result.data.refreshToken)
+                        userStore.setIsRefreshToken(false)
+                        userStore.setExp(1000 * 60 * 60 * 24 * 30)
+                        response.config.headers.Authorization = `Bearer ${result.data.accessToken}` //重新请求前需要将更新后的新token更换掉之前无效的token,不然会死循环
+                        const resp = await this.service.request(response.config)
+                        return resp
+                    } else {
+                        // 刷新失效，跳转登录页
+                    }
+                }
+                // 登陆失效
+                if (data.code === ResultEnum.OVERDUE) {
+                    console.log('登陆失效')
+                    userStore.setAccessToken('')
+                    userStore.setRefreshToken('')
+                    userStore.setIsRefreshToken(false)
+                    userStore.setUserInfo({ id: '', name: '' })
+                    userStore.setExp(0)
+                    await router.replace(LOGIN_URL)
+                    if (isFirst) {
+                        //临时处理token失效弹窗多次
+                        ElMessage.error(data.message)
+                        isFirst = false
+                    }
+                    return Promise.reject(data)
+                }
+                // 全局错误信息拦截（防止下载文件的时候返回数据流，没有 code 直接报错）
+                if (data.code && data.code !== ResultEnum.SUCCESS) {
+                    if (data.message.includes('&')) {
+                        let formattedMessage = data.message.split('&').join('<br>')
+                        if (data.message.includes(':')) {
+                            formattedMessage = formattedMessage.replace(':', '')
+                        }
+                        ElMessage.error({ message: formattedMessage, dangerouslyUseHTMLString: true })
+                        return Promise.reject(data)
+                    }
+
+                    ElMessage.error(data.message)
+                    return Promise.reject(data)
+                }
+                // 成功请求（在页面上除非特殊情况，否则不用处理失败逻辑）
+
+                if (userStore.exp <= Date.now() && userStore.exp !== 0) {
+                    userStore.setAccessToken('')
+                    userStore.setRefreshToken('')
+                    userStore.setIsRefreshToken(false)
+                    userStore.setUserInfo({ id: '', name: '' })
+                    userStore.setExp(0)
+                    ElMessage.error('登录已过期，请重新登录!')
+                    await router.replace(LOGIN_URL)
+                    return Promise.reject(data)
+                }
+                // 对于blob类型的响应，返回完整的response对象以保留响应头
+                if (response.config.responseType === 'blob') {
+                    return response
+                }
+                return data
+            },
+            async (error: AxiosError) => {
+                const { response } = error
+                tryHideFullScreenLoading()
+                console.log('error', error.message)
+                // 请求超时 && 网络错误单独判断，没有 response
+                if (error.message.indexOf('timeout') !== -1) ElMessage.error('请求超时！请您稍后重试')
+                if (error.message.indexOf('Network Error') !== -1) ElMessage.error('网络错误！请您稍后重试')
+                // 根据服务器响应的错误状态码，做不同的处理
+                if (response) checkStatus(response.status)
+                // 服务器结果都没有返回(可能服务器错误可能客户端断网)，断网处理:可以跳转到断网页面
+                if (!window.navigator.onLine) router.replace('/500')
+                return Promise.reject(error)
+            }
+        )
+    }
+
+    /**
+     * @description 常用请求方法封装
+     */
+    get<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
+        return this.service.get(url, { params, ..._object })
+    }
+
+    post<T>(url: string, params?: object | string, _object = {}): Promise<ResultData<T>> {
+        return this.service.post(url, params, _object)
+    }
+
+    put<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
+        return this.service.put(url, params, _object)
+    }
+
+    delete<T>(url: string, params?: any, _object = {}): Promise<ResultData<T>> {
+        return this.service.delete(url, { params, ..._object })
+    }
+
+    download(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service.post(url, params, { ..._object, responseType: 'blob' }).then(res => res.data)
+    }
+
+    downloadWithHeaders(url: string, params?: object, _object = {}): Promise<AxiosResponse<Blob>> {
+        return this.service.post(url, params, { ..._object, responseType: 'blob' })
+    }
+
+    upload(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service.post(url, params, {
+            ..._object,
+            headers: { 'Content-Type': 'multipart/form-data' }
+        })
+    }
+
+    /**
+     * 针对excel的上传，默认返回的是blob类型，Excel没问题时返回json特殊处理
+     */
+    uploadExcel(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service.post(url, params, {
+            ..._object,
+            headers: { 'Content-Type': 'multipart/form-data' },
+            responseType: 'blob'
+        }).then(res => res.data)
+    }
+
+    // 添加SSE连接方法
+    sse(url: string, params?: any): EventSource {
+        const userStore = useUserStore()
+        // 构造带参数的URL
+        let requestUrl = config.baseURL + url
+        if (params) {
+            const searchParams = new URLSearchParams()
+            for (const key in params) {
+                if (Object.prototype.hasOwnProperty.call(params, key)) {
+                    searchParams.append(key, String(params[key]))
+                }
+            }
+            requestUrl += '?' + searchParams.toString()
         }
-        // 全局错误信息拦截（防止下载文件的时候返回数据流，没有 code 直接报错）
-        if (data.code && data.code !== ResultEnum.SUCCESS) {
-          if(data.message.includes('&')){
-            let formattedMessage = data.message.split('&').join('<br>');
-              if (data.message.includes(':')) {
-                  formattedMessage = formattedMessage.replace(':', '')
-              }
-            ElMessage.error({ message: formattedMessage, dangerouslyUseHTMLString: true });
-            return Promise.reject(data)
-          }
 
-          ElMessage.error(data.message)
-          return Promise.reject(data)
-        }
-        // 成功请求（在页面上除非特殊情况，否则不用处理失败逻辑）
-
-          if (userStore.exp <= Date.now() && userStore.exp !== 0) {
-              userStore.setAccessToken('')
-              userStore.setRefreshToken('')
-              userStore.setIsRefreshToken(false)
-              userStore.setUserInfo({ id:'',name: '' })
-              userStore.setExp(0)
-              ElMessage.error('登录已过期，请重新登录!')
-              await router.replace(LOGIN_URL)
-              return Promise.reject(data)
-          }
-        return data
-      },
-      async (error: AxiosError) => {
-        const { response } = error
-        tryHideFullScreenLoading()
-        console.log('error', error.message)
-        // 请求超时 && 网络错误单独判断，没有 response
-        if (error.message.indexOf('timeout') !== -1) ElMessage.error('请求超时！请您稍后重试')
-        if (error.message.indexOf('Network Error') !== -1) ElMessage.error('网络错误！请您稍后重试')
-        // 根据服务器响应的错误状态码，做不同的处理
-        if (response) checkStatus(response.status)
-        // 服务器结果都没有返回(可能服务器错误可能客户端断网)，断网处理:可以跳转到断网页面
-        if (!window.navigator.onLine) router.replace('/500')
-        return Promise.reject(error)
-      },
-    )
-  }
-
-  /**
-   * @description 常用请求方法封装
-   */
-  get<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
-    return this.service.get(url, { params, ..._object })
-  }
-
-  post<T>(url: string, params?: object | string, _object = {}): Promise<ResultData<T>> {
-    return this.service.post(url, params, _object)
-  }
-
-  put<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
-    return this.service.put(url, params, _object)
-  }
-
-  delete<T>(url: string, params?: any, _object = {}): Promise<ResultData<T>> {
-    return this.service.delete(url, { params, ..._object })
-  }
-
-  download(url: string, params?: object, _object = {}): Promise<BlobPart> {
-    return this.service.post(url, params, { ..._object, responseType: 'blob' })
-  }
-
-  upload(url: string, params?: object, _object = {}): Promise<BlobPart> {
-    return this.service.post(url, params, {
-      ..._object,
-      headers: { 'Content-Type': 'multipart/form-data' }
-    })
-  }
-
-  /**
-   * 针对excel的上传，默认返回的是blob类型，Excel没问题时返回json特殊处理
-   */
-  uploadExcel(url: string, params?: object, _object = {}): Promise<BlobPart> {
-    return this.service.post(url, params, {
-      ..._object,
-      headers: { 'Content-Type': 'multipart/form-data' },
-      responseType: 'blob',
-    })
-  }
+        // 创建EventSource连接
+        const eventSource = new EventSourcePolyfill(requestUrl, {
+            headers: {
+                Authorization: 'Bearer ' + userStore.accessToken
+            },
+            // 增加超时时间到120秒
+            heartbeatTimeout: 120000
+        })
 
+        // 设置默认的Authorization头部
+        eventSource.addEventListener('open', function () {
+            console.log('SSE连接已建立')
+        })
+        // 添加错误处理
+        eventSource.addEventListener('error', function (err) {
+            console.error('SSE连接错误:', err)
+        })
 
+        return eventSource
+    }
 }
 
 export default new RequestHttp(config)

frontend/src/api/interface/index.ts

@@ -15,6 +15,7 @@ export interface Result {
  * 请求响应参数（包含data）
  */
 export interface ResultData<T = any> extends Result {
+  map(arg0: (item: any) => { label: any; value: any; }): { label: string; value: string; }[] | { label: string; value: string; }[];
   data: T;
 }
 

frontend/src/api/plan/interface/index.ts

@@ -26,7 +26,19 @@ export namespace Plan {
         associateReport:number;//是否关联报告模板 0否 1是
         reportTemplateName:string;
         reportTemplateVersion:string;
-        dataRule:string //数据处理原则
+        dataRule:string;//数据处理原则
+
+        standardDevIds:string[];
+        standardDevMap:Map<string,number>;//标准设备
+        testItems:string[];//测试项
+        Check_By?:string;//计划检测人
+        progress?: number; // 进度百分比，例如 75
+        children?: ResPlan[];
+        testConfig?: PlanTestConfig;
+        importFlag?: number; // 导入标识，0-否，1-是
+        leader?: string; // 负责人
+        memberIds?: string | string[]; //成员
+        members?: string; //成员字符串
     }
 
     // 检测计划 + 分页
@@ -35,15 +47,27 @@ export namespace Plan {
     }
 
 
+
     export interface ReqPlan extends ResPlan {
-        datasourceIds:string;
-        sourceIds: string;
+        datasourceIds:string | string[];
+        sourceIds: string | null;
         planId:string;
         scriptName: string ; 
         errorSysName: string;
         sourceName: string ;
+        standardDevNameStr: string;
+        testItemNameStr:string;
         devIds: string[];
     }
 
+    export interface PlanTestConfig {
+        planId: string;
+        waveRecord: number;
+        realTime: number;
+        statistics: number;
+        flicker: number;
+        maxTime: number;
+    }
+
   
   }

frontend/src/api/plan/plan.ts

@@ -2,54 +2,53 @@ import type { Plan } from './interface'
 import http from '@/api'
 import type { ErrorSystem } from '../device/interface/error'
 import type { Device } from '../device/interface/device'
-import { ReqDevReportParams } from '@/api/device/interface/device'
 
 /**
  * @name 检测计划管理模块
  */
 // 获取检测计划列表
 export const getPlanList = (params: Plan.ReqPlanParams) => {
-  return http.post(`/adPlan/list`, params)
+    return http.post(`/adPlan/list`, params)
 }
 
 // 新增检测计划
 export const addPlan = (params: any) => {
-  return http.post(`/adPlan/add`, params)
+    return http.post(`/adPlan/add`, params)
 }
 
 // 编辑检测计划
 export const updatePlan = (params: any) => {
-  return http.post(`/adPlan/update`, params)
+    return http.post(`/adPlan/update`, params)
 }
 
 // 删除检测计划
-export const deletePlan = (params: { id: string[] }) => {
-  return http.post(`/adPlan/delete`, params)
+export const deletePlan = (params: { id: string[]; pattern: string }) => {
+    return http.post(`/adPlan/delete?pattern=${params.pattern}`, params.id)
 }
 
-// 获取指定模式下所有检测源 
+// 获取指定模式下所有检测源
 export const getTestSourceList = (params: Plan.ReqPlan) => {
-  return http.get(`/pqSource/getAll?patternId=${params.pattern}`)
+    return http.get(`/pqSource/getAll?patternId=${params.pattern}`)
 }
 
 // 获取指定模式下所有检测脚本
 export const getPqScriptList = (params: Plan.ReqPlan) => {
-  return http.get(`/pqScript/getAll?patternId=${params.pattern}`)
+    return http.get(`/pqScript/getAll?patternId=${params.pattern}`)
 }
 
 //获取所有误差体系
 export const getPqErrSysList = () => {
-  return http.get<ErrorSystem.ErrorSystemList>(`/pqErrSys/getAll`)
+    return http.get<ErrorSystem.ErrorSystemList>(`/pqErrSys/getAll`)
 }
 
 //获取指定模式下所有未绑定的设备
-export const getUnboundPqDevList = (params: Plan.ReqPlan) => {
-  return http.get(`/pqDev/listUnbound?pattern=${params.pattern}`)
+export const getUnboundPqDevList = (params: { pattern: string}) => {
+    return http.get(`/pqDev/listUnbound?pattern=${params.pattern}`)
 }
 
 //根据检测计划id查询出所有已绑定的设备
 export const getBoundPqDevList = (params: any) => {
-  return http.post(`/pqDev/listByPlanId`, params)
+    return http.post(`/adPlan/listByPlanId`, params)
 }
 
 //检测计划绑定设备
@@ -59,34 +58,105 @@ export const getBoundPqDevList = (params: any) => {
 
 // 按照模式查询检测计划（用于首页展示）
 export const getPlanListByPattern = (params: Plan.ReqPlan) => {
-  return http.get(`/adPlan/listByPattern?pattern=${params.pattern}`)
+    return http.get(`/adPlan/listByPattern?pattern=${params.pattern}`)
 }
 
 // 导出检测计划
 export const exportPlan = (params: Device.ReqPqDevParams) => {
-  return http.download(`/adPlan/export`, params)
+    return http.download(`/adPlan/export`, params)
 }
 
 // 下载模板
 export const downloadTemplate = (params: { patternId: string }) => {
-  return http.download(`/adPlan/downloadTemplate`, params)
+    return http.download(`/adPlan/downloadTemplate`, params)
 }
 // 导入检测计划
 export const importPlan = (params: Device.ReqPqDevParams) => {
-  return http.uploadExcel(`/adPlan/import`, params)
+    return http.uploadExcel(`/adPlan/import`, params)
 }
 
 // 装置检测报告生成
 export const generateDevReport = (params: Device.ReqDevReportParams) => {
-  return http.post(`/report/generateReport`, params)
+    return http.post(`/report/generateReport`, params)
 }
 
 // 装置检测报告下载
 export const downloadDevData = (params: Device.ReqDevReportParams) => {
-  return http.download(`/report/downloadReport`, params)
+    return http.download(`/report/downloadReport`, params)
+}
+
+// 装置检测报告下载（带响应头）
+export const downloadDevDataWithHeaders = (params: Device.ReqDevReportParams) => {
+    return http.downloadWithHeaders(`/report/downloadReport`, params)
 }
 
 export const staticsAnalyse = (params: { id: string[] }) => {
-  return http.download('/adPlan/analyse', params)
+    return http.download('/adPlan/analyse', params)
 }
 
+//根据计划id分页查询被检设
+export const getDevListByPlanId = (params: any) => {
+    return http.post(`/adPlan/listDevByPlanId`, params)
+}
+
+//修改子计划名称
+export const updateSubPlanName = (params: Plan.ReqPlan) => {
+    return http.get(`/adPlan/updateSubPlanName?planId=${params.id}&name=${params.name}`)
+}
+
+//子计划绑定/解绑标准设备
+export const subPlanBindStandardDevList = (params: Plan.ReqPlan) => {
+    return http.post(`/adPlan/updateBindStandardDev`, params)
+}
+
+//子计划绑定/解绑被检设备
+export const subPlanBindDev = (params: Plan.ReqPlan) => {
+    return http.post(`/adPlan/updateBindDev`, params)
+}
+
+//根据父计划ID获取未被子计划绑定的标准设备
+export const getUnboundStandardDevList = (params: Plan.ResPlan) => {
+    return http.get(`/adPlan/getUnBoundStandardDev?fatherPlanId=${params.fatherPlanId}`)
+}
+
+//根据计划ID获取已绑定的标准设备
+export const getBoundStandardDevList = (params: Plan.ResPlan) => {
+    return http.get(`/adPlan/getBoundStandardDev?planId=${params.id}`)
+}
+
+//根据计划ID获取已绑定的所有标准设备
+export const getBoundStandardDevAllList = (params: { id: string }) => {
+    return http.get(`/adPlan/getBoundStandardDev?planId=${params.id}&all=1`)
+}
+
+// 导出子计划
+export const exportSubPlan = (params: Plan.ResPlan) => {
+    return http.download(`/adPlan/exportSubPlan?planId=${params.id}`)
+}
+
+// 导入子检测计划
+export const importSubPlan = (params: Plan.ResPlan) => {
+    return http.upload(`/adPlan/importSubPlan`, params)
+}
+
+// 导出计划检测结果数据
+export const exportPlanCheckData = (params: any) => {
+    return http.post(
+        `/adPlan/exportPlanCheckData?planId=${params.id}&devIds=${params.devIds}&report=${params.report}`
+    )
+}
+
+//根据误差体系id获取测试项
+export const getPqErrSysTestItemList = (params: {errorSysId : string}) => {
+    return http.get(`/pqErrSys/getTestItems?id=${params.errorSysId}`)
+}
+
+// 获取计划项目成员
+export const getMemberList = (params: {id : string}) => {
+    return http.get(`/adPlan/getMemberList?planId=${params.id}`)
+}
+
+// 导入并合并子检测计划检测结果数据
+export const importAndMergePlanCheckData = (params: Plan.ResPlan) => {
+    return http.upload(`/adPlan/importAndMergePlanCheckData`, params)
+}

frontend/src/api/result/interface/index.ts

@@ -0,0 +1,51 @@
+
+export interface MonitorResult {
+    /**
+     * 监测点id
+     */
+    monitorId: string;
+
+    /**
+     * 监测点序号
+     */
+    monitorNum: number;
+
+    /**
+     * 总检测次数
+     */
+    totalNum: number;
+
+    /**
+     * 合格检测次数
+     */
+    qualifiedNum: number;
+
+    /**
+     * 不合格检测次数
+     */
+    unQualifiedNum: number;
+
+    /**
+     * 误差体系名称
+     */
+    errorSysName: string;
+
+    /**
+     * 检测结果
+     */
+    checkResult: number;
+
+    /**
+     * 哪次
+     */
+    whichTime: string;
+
+    /**
+     * 结论来源
+     */
+    resultOrigin: string;
+    /**
+     * 来源类型
+     */
+    resultType: string;
+}

frontend/src/api/result/result.ts

@@ -0,0 +1,7 @@
+import http from '@/api'
+
+export const getMonitorResult = (devId: string) => http.post(`/result/getMonitorResult?devId=${devId}`)
+export const getMonitorDataSourceResult = (monitorId: string) =>
+    http.get(`/result/getMonitorDataSourceResult?monitorId=${monitorId}`)
+
+export const updateMonitorResult = (data: any) => http.post('/result/updateMonitorResult', data)

frontend/src/api/socket/socket.ts

@@ -32,3 +32,15 @@ export const pauseTest = () => {
 export const resumeTest = (params) => {
     return http.post(`/prepare/restartTemTest/`, params, {loading: false})
 }
+
+/**
+ * 比对式通道配对
+ * @param params
+ */
+export const contrastTest = (params: any) => {
+    return http.post(`/prepare/startContrastTest`,params)
+}
+
+export const exportAlignData= () => {
+    return http.download(`/prepare/exportAlignData`)
+}

frontend/src/api/system/versionRegister/index.ts

@@ -1,12 +1,11 @@
 import http from '@/api'
-import {type VersionRegister} from '@/api/system/versionRegister/interface'
+import { type VersionRegister } from '@/api/system/versionRegister/interface'
 
 //获取有效数据配置
-export const getRegRes = (params: VersionRegister.ResSys_Reg_Res) => {
+export const getRegRes = (params: { type: string }) => {
     return http.get(`/sysRegRes/getRegResByType?id=${params.type}`)
 }
 
-
 //编辑有效数据配置
 export const updateRegRes = (params: VersionRegister.Sys_Reg_Res) => {
     return http.post(`/sysRegRes/update`, params)

frontend/src/api/user/interface/user.ts

@@ -1,23 +1,23 @@
 // 登录模块
-import type { ReqPage,ResPage } from '@/api/interface'
+import type { ReqPage, ResPage } from '@/api/interface'
 
 export namespace Login {
-  export interface ReqLoginForm {
-    username: string;
-    password: string;
-    checked: boolean;
-  }
-  export interface ResLogin {
-    accessToken: string;
-    refreshToken: string;
-    userInfo:{
-      id: string;
-      name: string;
+    export interface ReqLoginForm {
+        username: string
+        password: string
+        checked: boolean
+    }
+    export interface ResLogin {
+        accessToken: string
+        refreshToken: string
+        userInfo: {
+            id: string
+            name: string
+        }
+    }
+    export interface ResAuthButtons {
+        [key: string]: string[]
     }
-  }
-  export interface ResAuthButtons {
-    [key: string]: string[];
-  }
 }
 
 
@@ -52,6 +52,8 @@ export namespace User {
     updateTime?: string;//更新时间
     roleIds?: string[]; // 
     roleNames?:string[]; //
+    roleCodes?:string[]; //
+    disabled?: boolean;
   }
 
   // 用户接口

frontend/src/api/user/login/index.ts

@@ -1,3 +1,4 @@
+import { pa } from 'element-plus/es/locale/index.mjs';
 import type {Login} from '@/api/user/interface/user'
 import {ADMIN as rePrefix} from '@/api/system/config/serviceName'
 import http from '@/api'

frontend/src/api/user/user/index.ts

@@ -37,3 +37,7 @@ export const updatePassWord = (params: User.ResPassWordUser) => {
   return http.post(`/sysUser/updatePassword`,params)
 }
 
+// 获取所有用户
+export const getAllUser= () => {
+  return http.get(`/sysUser/getAll`)
+}

frontend/src/components/ImportExcel/index.vue

@@ -1,58 +1,69 @@
 <template>
-  <el-dialog v-model='dialogVisible' :title='`批量添加${parameter.title}`' :destroy-on-close='true' width='580px'
-             draggable>
-    <el-form class='drawer-multiColumn-form' label-width='100px'>
-      <el-form-item label='模板下载 :'>
-        <el-button type='primary' :icon='Download' @click='downloadTemp'> 点击下载</el-button>
-      </el-form-item>
-      <el-form-item label='文件上传 :'>
-        <el-upload
-          action='#'
-          class='upload'
-          :drag='true'
-          :limit='excelLimit'
-          :multiple='true'
-          :show-file-list='true'
-          :http-request='uploadExcel'
-          :before-upload='beforeExcelUpload'
-          :on-exceed='handleExceed'
-          :accept="parameter.fileType!.join(',')"
-        >
-          <slot name='empty'>
-            <el-icon class='el-icon--upload'>
-              <upload-filled />
-            </el-icon>
-            <div class='el-upload__text'>将文件拖到此处，或<em>点击上传</em></div>
-          </slot>
-          <template #tip>
-            <slot name='tip'>
-              <div class='el-upload__tip'>请上传 .xls , .xlsx 标准格式文件，文件最大为 {{ parameter.fileSize }}M</div>
-            </slot>
-          </template>
-        </el-upload>
-      </el-form-item>
-      <el-form-item v-if='parameter.showCover' label='数据覆盖 :'>
-        <el-switch v-model='isCover' />
-      </el-form-item>
-    </el-form>
-  </el-dialog>
+    <el-dialog
+        v-model="dialogVisible"
+        :title="`批量添加${parameter.title}`"
+        :destroy-on-close="true"
+        width="580px"
+        draggable
+    >
+        <el-form class="drawer-multiColumn-form" label-width="100px">
+            <el-form-item label="模板下载 :">
+                <el-button type="primary" :icon="Download" @click="downloadTemp">点击下载</el-button>
+            </el-form-item>
+            <el-form-item label="文件上传 :">
+                <el-upload
+                    action="#"
+                    class="upload"
+                    :drag="true"
+                    :limit="excelLimit"
+                    :multiple="true"
+                    :show-file-list="true"
+                    :http-request="uploadExcel"
+                    :before-upload="beforeExcelUpload"
+                    :on-exceed="handleExceed"
+                    :accept="parameter.fileType!.join(',')"
+                >
+                    <slot name="empty">
+                        <el-icon class="el-icon--upload">
+                            <upload-filled />
+                        </el-icon>
+                        <div class="el-upload__text">
+                            将文件拖到此处，或
+                            <em>点击上传</em>
+                        </div>
+                    </slot>
+                    <template #tip>
+                        <slot name="tip">
+                            <div class="el-upload__tip">
+                                请上传 .xls , .xlsx 标准格式文件，文件最大为 {{ parameter.fileSize }}M
+                            </div>
+                        </slot>
+                    </template>
+                </el-upload>
+            </el-form-item>
+            <el-form-item v-if="parameter.showCover" label="数据覆盖 :">
+                <el-switch v-model="isCover" />
+            </el-form-item>
+        </el-form>
+    </el-dialog>
 </template>
 
-<script setup lang='ts' name='ImportExcel'>
+<script setup lang="ts" name="ImportExcel">
 import { ref } from 'vue'
 import { useDownload } from '@/hooks/useDownload'
 import { Download } from '@element-plus/icons-vue'
-import { ElNotification, UploadRequestOptions, UploadRawFile, ElMessage } from 'element-plus'
+import { ElMessage, ElNotification, UploadRawFile, UploadRequestOptions } from 'element-plus'
 
 export interface ExcelParameterProps {
-  title: string; // 标题
-  showCover?: boolean; // 是否显示”数据覆盖“选项
-  patternId?: string; // 模式ID
-  fileSize?: number; // 上传文件的大小
-  fileType?: File.ExcelMimeType[]; // 上传文件的类型
-  tempApi?: (params: any) => Promise<any>; // 下载模板的Api
-  importApi?: (params: any) => Promise<any>; // 批量导入的Api
-  getTableList?: () => void; // 获取表格数据的Api
+    title: string // 标题
+    showCover?: boolean // 是否显示”数据覆盖“选项
+    patternId?: string // 模式ID
+    planId?: string | null //计划ID
+    fileSize?: number // 上传文件的大小
+    fileType?: File.ExcelMimeType[] // 上传文件的类型
+    tempApi?: (params: any) => Promise<any> // 下载模板的Api
+    importApi?: (params: any) => Promise<any> // 批量导入的Api
+    getTableList?: () => void // 获取表格数据的Api
 }
 
 // 是否覆盖数据
@@ -63,68 +74,77 @@ const excelLimit = ref(1)
 const dialogVisible = ref(false)
 // 父组件传过来的参数
 const parameter = ref<ExcelParameterProps>({
-  title: '',
-  fileSize: 5,
-  fileType: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+    title: '',
+    fileSize: 5,
+    fileType: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']
 })
-
+const emit = defineEmits<{
+    (e: 'result', data: boolean): void
+}>()
 // 接收父组件参数
 const acceptParams = (params: ExcelParameterProps) => {
-  parameter.value = { ...parameter.value, ...params }
-  dialogVisible.value = true
+    parameter.value = { ...parameter.value, ...params }
+    dialogVisible.value = true
 }
 
 // Excel 导入模板下载
 const downloadTemp = () => {
-  if (!parameter.value.tempApi) return
-  useDownload(parameter.value.tempApi, `${parameter.value.title}模板`, {'patternId':parameter.value.patternId}, false)
+    if (!parameter.value.tempApi) return
+    useDownload(parameter.value.tempApi, `${parameter.value.title}模板`, { pattern: parameter.value.patternId }, false)
 }
 
 // 文件上传
 const uploadExcel = async (param: UploadRequestOptions) => {
-  let excelFormData = new FormData()
-  excelFormData.append('file', param.file)
-  if (parameter.value.patternId) {
-    excelFormData.append('patternId', parameter.value.patternId)
-  }
-  isCover.value && excelFormData.append('isCover', isCover.value as unknown as Blob)
-  //await parameter.value.importApi!(excelFormData);
-  await parameter.value.importApi!(excelFormData)
-    .then(res => handleImportResponse(res))
-  parameter.value.getTableList && parameter.value.getTableList()
-  dialogVisible.value = false
+    let excelFormData = new FormData()
+    excelFormData.append('file', param.file)
+    if (parameter.value.patternId) {
+        excelFormData.append('patternId', parameter.value.patternId)
+    }
+
+    excelFormData.append('planId', parameter.value.planId)
+
+    isCover.value && excelFormData.append('isCover', isCover.value as unknown as Blob)
+    //await parameter.value.importApi!(excelFormData);
+    await parameter.value.importApi!(excelFormData).then(res => handleImportResponse(res))
+
+    parameter.value.getTableList && parameter.value.getTableList()
+    dialogVisible.value = false
 }
 
-
 async function handleImportResponse(res: any) {
-  console.log(res)
+    console.log(res)
 
-  if (res.type === 'application/json') {
-    const fileReader = new FileReader()
-    fileReader.onloadend = () => {
-      try {
-        const jsonData = JSON.parse(fileReader.result)
-        if (jsonData.code === 'A0000') {
-          ElMessage.success('导入成功')
-        } else {
-          ElMessage.error(jsonData.message)
+    if (res.type === 'application/json') {
+        const fileReader = new FileReader()
+        fileReader.onloadend = () => {
+            try {
+                const jsonData = JSON.parse(fileReader.result)
+                if (jsonData.code === 'A0000') {
+                    ElMessage.success('导入成功')
+                } else {
+                    ElMessageBox.alert(jsonData.message, {
+                        title: '导入结果',
+                        type: 'error'
+                    })
+                }
+                emit('result', jsonData.data)
+            } catch (err) {
+                console.log(err)
+            }
         }
-      } catch (err) {
-        console.log(err)
-      }
+        fileReader.readAsText(res)
+    } else {
+        emit('result', false)
+        ElMessage.error('导入失败，请查看下载附件！')
+        let blob = new Blob([res], { type: 'application/vnd.ms-excel' })
+        const url = window.URL.createObjectURL(blob)
+        const link = document.createElement('a')
+        link.href = url
+        link.download = '导入失败数据'
+        document.body.appendChild(link)
+        link.click()
+        link.remove()
     }
-    fileReader.readAsText(res)
-  } else {
-    ElMessage.error('导入失败，请查看下载附件！')
-    let blob = new Blob([res], { type: 'application/vnd.ms-excel' })
-    const url = window.URL.createObjectURL(blob)
-    const link = document.createElement('a')
-    link.href = url
-    link.download = '导入失败数据'
-    document.body.appendChild(link)
-    link.click()
-    link.remove()
-  }
 }
 
 /**
@@ -132,32 +152,32 @@ async function handleImportResponse(res: any) {
  * @param file 上传的文件
  * */
 const beforeExcelUpload = (file: UploadRawFile) => {
-  const isExcel = parameter.value.fileType!.includes(file.type as File.ExcelMimeType)
-  const fileSize = file.size / 1024 / 1024 < parameter.value.fileSize!
-  if (!isExcel)
-    ElNotification({
-      title: '温馨提示',
-      message: '上传文件只能是 xls / xlsx 格式！',
-      type: 'warning',
-    })
-  if (!fileSize)
-    setTimeout(() => {
-      ElNotification({
-        title: '温馨提示',
-        message: `上传文件大小不能超过 ${parameter.value.fileSize}MB！`,
-        type: 'warning',
-      })
-    }, 0)
-  return isExcel && fileSize
+    const isExcel = parameter.value.fileType!.includes(file.type as File.ExcelMimeType)
+    const fileSize = file.size / 1024 / 1024 < parameter.value.fileSize!
+    if (!isExcel)
+        ElNotification({
+            title: '温馨提示',
+            message: '上传文件只能是 xls / xlsx 格式！',
+            type: 'warning'
+        })
+    if (!fileSize)
+        setTimeout(() => {
+            ElNotification({
+                title: '温馨提示',
+                message: `上传文件大小不能超过 ${parameter.value.fileSize}MB！`,
+                type: 'warning'
+            })
+        }, 0)
+    return isExcel && fileSize
 }
 
 // 文件数超出提示
 const handleExceed = () => {
-  ElNotification({
-    title: '温馨提示',
-    message: '最多只能上传一个文件！',
-    type: 'warning',
-  })
+    ElNotification({
+        title: '温馨提示',
+        message: '最多只能上传一个文件！',
+        type: 'warning'
+    })
 }
 
 // 上传错误提示
@@ -179,9 +199,9 @@ const handleExceed = () => {
 // }
 
 defineExpose({
-  acceptParams,
+    acceptParams
 })
 </script>
-<style lang='scss' scoped>
-@import "./index.scss";
+<style lang="scss" scoped>
+@use './index.scss';
 </style>

frontend/src/components/ImportZip/index.scss

@@ -0,0 +1,3 @@
+.upload {
+  width: 80%;
+}

frontend/src/components/ImportZip/index.vue

@@ -0,0 +1,241 @@
+<template>
+    <el-dialog
+        v-model="dialogVisible"
+        :title="parameter.title"
+        :destroy-on-close="true"
+        width="450px"
+        :close-on-click-modal="!parameter.progressBar"
+        :show-close="!disable"
+        draggable
+    >
+        <el-upload
+            ref="uploadRef"
+            action="#"
+            class="upload"
+            :limit="1"
+            :http-request="uploadZip"
+            accept=".zip"
+            :auto-upload="!parameter.confirmMessage"
+            :on-change="handleChange"
+            :on-remove="handleRemove"
+            :disabled="fileDisabled"
+        >
+            <slot name="empty">
+                <el-button type="primary" :disabled="fileDisabled" icon="Upload">点击上传</el-button>
+            </slot>
+            <template #tip>
+                <slot name="tip">
+                    <div class="el-upload__tip">请上传 .zip 标准格式文件</div>
+                </slot>
+            </template>
+        </el-upload>
+
+        <el-text v-if="parameter.progressBar && progressData.status === 'exception'" size="small" type="danger">
+            {{ progressData.message }}
+        </el-text>
+        <el-text v-if="parameter.progressBar && progressData.status === 'success'" size="small" type="success">
+            {{ progressData.message }}
+        </el-text>
+        <el-text v-if="parameter.progressBar && progressData.status === ''" size="small" type="info">
+            {{ progressData.message }}
+        </el-text>
+        <el-progress
+            style="margin-top: 10px; margin-bottom: 10px"
+            v-if="parameter.progressBar"
+            :status="progressData.status"
+            :percentage="progressData.percentage"
+            :stroke-width="10"
+            striped
+            striped-flow
+        ></el-progress>
+
+        <template #footer v-if="parameter.confirmMessage">
+            <el-button :disabled="disable" type="primary" @click="uploadSubmit">开始导入</el-button>
+        </template>
+    </el-dialog>
+</template>
+
+<script setup lang="ts" name="ImportZip">
+import { ref } from 'vue'
+import type { UploadInstance, UploadProps, UploadRequestOptions } from 'element-plus'
+import http from '@/api'
+
+export interface ZipParameterProps {
+    title: string // 标题
+    patternId?: string // 模式ID
+    planId?: string // 计划ID
+    importApi?: (params: any) => Promise<any> // 批量导入的Api
+    confirmMessage?: string // 提示信息
+    progressBar?: boolean // 进度条
+}
+// dialog状态
+const dialogVisible = ref(false)
+const disable = ref(true)
+const fileDisabled = ref(false)
+const uploadRef = ref<UploadInstance>()
+
+// 父组件传过来的参数
+const parameter = ref<ZipParameterProps>({
+    title: ''
+})
+const emit = defineEmits<{
+    (e: 'result', data: boolean): void
+}>()
+// 接收父组件参数
+const acceptParams = (params: ZipParameterProps) => {
+    parameter.value = { ...parameter.value, ...params }
+    dialogVisible.value = true
+}
+
+// 文件上传
+const uploadZip = (param: UploadRequestOptions) => {
+    let zipFormData = new FormData()
+    zipFormData.append('file', param.file)
+    if (parameter.value.patternId) {
+        zipFormData.append('patternId', parameter.value.patternId)
+    }
+    if (parameter.value.planId) {
+        zipFormData.append('planId', parameter.value.planId)
+    }
+    if (parameter.value.progressBar) {
+        initSSE()
+    }
+
+    setTimeout(() => {
+        parameter.value.importApi!(zipFormData)
+            .then(res => handleImportResponse(res))
+            .catch(err => {
+                fileDisabled.value = false
+                disable.value = false
+            })
+    }, 1000)
+}
+
+const handleImportResponse = (res: any) => {
+    if (!parameter.value.progressBar) {
+        if (res.code === 'A0000') {
+            ElMessage.success('导入成功')
+            emit('result', true)
+            dialogVisible.value = false
+        } else {
+            ElMessage.error(res.message)
+            fileDisabled.value = false
+            disable.value = false
+        }
+    } else {
+        if (res.code !== 'A0000') {
+            ElMessage.error(res.message)
+        }
+    }
+}
+
+const uploadSubmit = () => {
+    if (!uploadRef.value) {
+        return ElMessage.warning('请选择文件！')
+    }
+    progressData.value = {
+        percentage: 0,
+        status: '',
+        message: ''
+    }
+    ElMessageBox.confirm(parameter.value.confirmMessage, '温馨提示', {
+        confirmButtonText: '确定',
+        cancelButtonText: '取消',
+        type: 'warning'
+    })
+        .then(() => {
+            disable.value = true
+            fileDisabled.value = true
+            uploadRef.value?.submit()
+        })
+        .catch(() => {
+            disable.value = false
+            fileDisabled.value = false
+        })
+}
+const handleChange: UploadProps['onChange'] = (uploadFile, uploadFiles) => {
+    disable.value = uploadFiles.length === 0
+    progressData.value = {
+        percentage: 0,
+        status: '',
+        message: ''
+    }
+}
+const handleRemove: UploadProps['onRemove'] = (uploadFile, uploadFiles) => {
+    disable.value = uploadFiles.length === 0
+    progressData.value = {
+        percentage: 0,
+        status: '',
+        message: ''
+    }
+}
+
+const progressData = ref({
+    percentage: 0,
+    status: '',
+    message: ''
+})
+const eventSource = ref<EventSource | null>(null)
+
+const initSSE = () => {
+    eventSource.value = http.sse('/sse/createSse')
+
+    eventSource.value.onmessage = event => {
+        console.log('收到消息内容是:', event.data)
+        const res = JSON.parse(event.data)
+        progressData.value.percentage = res.data
+        progressData.value.message = res.message
+        if (res.code === 'A0002') {
+            fileDisabled.value = false
+            disable.value = false
+            progressData.value.status = 'exception'
+            ElMessage.error(res.message)
+        }
+        if (progressData.value.percentage === 100) {
+            progressData.value.status = 'success'
+            eventSource.value!.close()
+            ElMessage.success('导入成功')
+            emit('result', true)
+            dialogVisible.value = false
+        }
+    }
+
+    eventSource.value.onerror = error => {
+        console.warn('SSE 连接出错：', error)
+        eventSource.value!.close()
+    }
+}
+// 添加一个手动关闭EventSource的函数
+const closeEventSource = () => {
+    if (eventSource.value) {
+        eventSource.value.close()
+        eventSource.value = null
+        console.log('SSE连接已关闭')
+    }
+}
+// 监听 dialogVisible 的变化，确保在对话框关闭时清理资源
+watch(dialogVisible, newVal => {
+    if (!newVal) {
+        // 延迟执行，确保在组件完全关闭后清理
+        setTimeout(() => {
+            closeEventSource()
+            fileDisabled.value = false
+            disable.value = false
+            progressData.value = {
+                percentage: 0,
+                status: '',
+                message: ''
+            }
+        }, 100)
+    }
+})
+onUnmounted(() => {
+    closeEventSource()
+})
+defineExpose({
+    acceptParams
+})
+</script>
+<style lang="scss" scoped>
+@use './index.scss';
+</style>

frontend/src/components/ProTable/index.vue

@@ -119,6 +119,7 @@ import TableColumn from './components/TableColumn.vue'
 import Sortable from 'sortablejs'
 
 export interface ProTableProps {
+
   columns: ColumnProps[]; // 列配置项  ==> 必传
   data?: any[]; // 静态 table data 数据，若存在则不会使用 requestApi 返回的 data ==> 非必传
   requestApi?: (params: any) => Promise<any>; // 请求表格数据的 api ==> 非必传

frontend/src/directives/modules/auth.ts

@@ -6,21 +6,24 @@ import { useAuthStore } from '@/stores/modules/auth'
 import type { Directive, DirectiveBinding } from 'vue'
 
 const auth: Directive = {
-  mounted(el: HTMLElement, binding: DirectiveBinding) {
-    const { value } = binding
-    const authStore = useAuthStore()
-    const currentPageRoles = authStore.authButtonListGet[authStore.routeName] ?? []
-      // console.log('1234',authStore.routeName)
-      // console.log('123',currentPageRoles)
-    if (value instanceof Array && value.length) { 
-      //console.log('123456',value)     
-      const hasPermission = value.every(item => currentPageRoles.includes(item))
-      if (!hasPermission) el.remove()
-    } else {
-      //console.log('12345',value)
-      if (!currentPageRoles.includes(value)) el.remove()
+    mounted(el: HTMLElement, binding: DirectiveBinding) {
+        //console.log('binding',binding)
+        const { value, modifiers } = binding
+        let currentPageRoles = []
+        const authStore = useAuthStore()
+        if (modifiers && Object.keys(modifiers).length) {
+            currentPageRoles = authStore.authButtonListGet[Object.keys(modifiers)[0]] ?? []
+        } else {
+            currentPageRoles = authStore.authButtonListGet[authStore.routeName] ?? []
+        }
+        console.log('currentPageRoles', currentPageRoles)
+        if (value instanceof Array && value.length) {
+            const hasPermission = value.every(item => currentPageRoles.includes(item))
+            if (!hasPermission) el.remove()
+        } else {
+            if (!currentPageRoles.includes(value)) el.remove()
+        }
     }
-  },
 }
 
 export default auth

frontend/src/hooks/useDownload.ts

@@ -1,4 +1,5 @@
 import { ElNotification } from "element-plus";
+import type { AxiosResponse } from "axios";
 
 /**
  * @description 接收数据流生成 blob，创建链接，下载文件
@@ -8,6 +9,55 @@ import { ElNotification } from "element-plus";
  * @param {Boolean} isNotify 是否有导出消息提示 (默认为 true)
  * @param {String} fileType 导出的文件格式 (默认为.xlsx)
  * */
+/**
+ * 从 Content-Disposition 头解析文件名
+ */
+const getFileNameFromContentDisposition = (contentDisposition: string | undefined | null): string | null => {
+  if (!contentDisposition) return null;
+
+  // 优先匹配 filename*=UTF-8'' 格式（RFC 5987）
+  const filenameStarRegex = /filename\*\s*=\s*UTF-8''([^;]+)/i;
+  const starMatches = filenameStarRegex.exec(contentDisposition);
+
+  if (starMatches && starMatches[1]) {
+    try {
+      return decodeURIComponent(starMatches[1]);
+    } catch (e) {
+      console.warn('解码 filename* 失败:', e);
+    }
+  }
+
+  // 其次匹配 filename="文件名" 或 filename=文件名 格式
+  const filenameRegex = /filename\s*=\s*([^;]+)/i;
+  const matches = filenameRegex.exec(contentDisposition);
+
+  if (matches && matches[1]) {
+    let filename = matches[1].trim();
+
+    // 去除引号
+    filename = filename.replace(/^["']|["']$/g, "");
+
+    // 尝试解码 URL 编码的文件名
+    try {
+      // 检查是否包含 URL 编码字符
+      if (filename.includes('%') || filename.includes('UTF-8')) {
+        // 处理可能的 UTF-8 前缀
+        if (filename.startsWith("UTF-8''") || filename.startsWith("utf-8''")) {
+          filename = filename.substring(7);
+        }
+        filename = decodeURIComponent(filename);
+      }
+    } catch (e) {
+      // 如果解码失败，返回原始文件名
+      console.warn('解码文件名失败，使用原始值:', e);
+    }
+
+    return filename;
+  }
+
+  return null;
+};
+
 export const useDownload = async (
   api: (param: any) => Promise<any>,
   tempName: string,
@@ -39,6 +89,73 @@ export const useDownload = async (
     document.body.removeChild(exportFile);
     window.URL.revokeObjectURL(blobUrl);
   } catch (error) {
-   
+
+  }
+};
+
+/**
+ * @description 支持服务器文件名的下载方法，会从 Content-Disposition 头获取文件名
+ * @param {Function} api 导出表格的api方法 (必传)
+ * @param {String} fallbackName 备用文件名，当服务器未提供时使用 (可选)
+ * @param {Object} params 导出的参数 (默认{})
+ * @param {Boolean} isNotify 是否有导出消息提示 (默认为 true)
+ * @param {String} fallbackFileType 备用文件格式，当服务器未提供时使用 (默认为.xlsx)
+ */
+export const useDownloadWithServerFileName = async (
+  api: (param: any) => Promise<AxiosResponse<Blob> | any>,
+  fallbackName: string = "",
+  params: any = {},
+  isNotify: boolean = true,
+  fallbackFileType: string = ".xlsx"
+) => {
+  if (isNotify) {
+    ElNotification({
+      title: "温馨提示",
+      message: "如果数据庞大会导致下载缓慢哦，请您耐心等待！",
+      type: "info",
+      duration: 3000
+    });
+  }
+  try {
+    const res = await api(params);
+
+    // 检查响应是否包含 data 属性（AxiosResponse）还是直接是 Blob
+    const blob = res.data ? new Blob([res.data]) : new Blob([res]);
+
+    // 尝试从响应头获取文件名（如果存在）
+    let serverFileName: string | null = null;
+    if (res.headers) {
+      const headers = res.headers || {};
+      const contentDisposition = headers['content-disposition'] || headers['Content-Disposition'];
+      serverFileName = getFileNameFromContentDisposition(contentDisposition);
+    }
+
+    // 确定最终使用的文件名
+    let finalFileName: string;
+    if (serverFileName) {
+      finalFileName = serverFileName;
+    } else if (fallbackName) {
+      finalFileName = `${fallbackName}${fallbackFileType}`;
+    } else {
+      finalFileName = `download${fallbackFileType}`;
+    }
+
+    // 兼容 edge 不支持 createObjectURL 方法
+    if ("msSaveOrOpenBlob" in navigator) {
+      return window.navigator.msSaveOrOpenBlob(blob, finalFileName);
+    }
+
+    const blobUrl = window.URL.createObjectURL(blob);
+    const exportFile = document.createElement("a");
+    exportFile.style.display = "none";
+    exportFile.download = finalFileName;
+    exportFile.href = blobUrl;
+    document.body.appendChild(exportFile);
+    exportFile.click();
+    // 去除下载对 url 的影响
+    document.body.removeChild(exportFile);
+    window.URL.revokeObjectURL(blobUrl);
+  } catch (error) {
+    console.error('文件下载失败:', error);
   }
 };

frontend/src/hooks/useTable.ts

@@ -78,6 +78,7 @@ export const useTable = (
       });
       dataCallBack && (data = dataCallBack(data));
       state.tableData = isPageable ? data.records : data;
+      //console.log(data);
       // 解构后台返回的分页数据 (如果有分页更新分页信息)
       if (isPageable) {
         state.resPageable.total = data.total;
@@ -85,6 +86,7 @@ export const useTable = (
         state.resPageable.size = data.size;
       }
     } catch (error) {
+      //console.log('123');
       requestError && requestError(error);
     }
   };

frontend/src/layouts/components/Footer/index.vue

@@ -25,7 +25,7 @@
             >数字式模块</el-dropdown-item
           >
           <el-dropdown-item @click="handelOpen('比对式')"
-            disabled>比对式模块</el-dropdown-item
+           >比对式模块</el-dropdown-item
           >
         </el-dropdown-menu>
       </template>

frontend/src/layouts/components/Header/components/Avatar.vue

@@ -48,6 +48,7 @@
                     active: item.value === appSceneStore.currentScene
                   }"
                   @click="changeScene(item.value?? '')"
+                  :disabled = "item.value === appSceneStore.currentScene"
                 >
               {{ item.name }}
               </el-dropdown-item>

frontend/src/layouts/components/Main/index.vue

@@ -1,84 +1,83 @@
-<template>
-  <Maximize v-show="maximize" />
-  <Tabs v-if="tabs && showMenuFlag" />
-  <el-main>
-    <router-view v-slot="{ Component, route }" style="height:100%;">
-      <!-- {{ keepAliveName}} -->
-      <!-- <transition  name="slide-right" mode="out-in"> -->
-        <keep-alive :include="tabsMenuList" >
-          <component :is="Component" :key="route.fullPath" />
-        </keep-alive>
-      <!-- </transition> -->
-    </router-view>
-  </el-main>
-  <el-footer>
-    <Footer />
-  </el-footer>
-</template>
-
-<script setup lang="ts">
-import { ref, onBeforeUnmount, provide, watch, computed } from "vue";
-import { storeToRefs } from "pinia";
-import { useDebounceFn } from "@vueuse/core";
-import { useGlobalStore } from "@/stores/modules/global";
-import { useKeepAliveStore } from "@/stores/modules/keepAlive";
-import Maximize from "./components/Maximize.vue";
-import Tabs from "@/layouts/components/Tabs/index.vue";
-import Footer from "@/layouts/components/Footer/index.vue";
-import { useAuthStore } from "@/stores/modules/auth";
-import { useTabsStore } from '@/stores/modules/tabs'
-const tabStore = useTabsStore()
-const globalStore = useGlobalStore();
-const tabsMenuList = computed(() => tabStore.tabsMenuList.map(item => item.name))
-const authStore = useAuthStore();
-const { maximize, isCollapse, layout, tabs, footer } = storeToRefs(globalStore);
-const keepAliveStore = useKeepAliveStore();
-const { keepAliveName } = storeToRefs(keepAliveStore);
-// console.log("🚀 ~ keepAliveName:", keepAliveName)
-//是否显示导航栏
-const showMenuFlag = computed(() => authStore.showMenuFlagGet);
-// 注入刷新页面方法
-const isRouterShow = ref(true);
-const refreshCurrentPage = (val: boolean) => (isRouterShow.value = val);
-provide("refresh", refreshCurrentPage);
-
-// 监听当前页面是否最大化，动态添加 class
-watch(
-  () => maximize.value,
-  () => {
-    const app = document.getElementById("app") as HTMLElement;
-    if (maximize.value) app.classList.add("main-maximize");
-    else app.classList.remove("main-maximize");
-  },
-  { immediate: true }
-);
-
-// 监听布局变化，在 body 上添加相对应的 layout class
-watch(
-  () => layout.value,
-  () => {
-    const body = document.body as HTMLElement;
-    body.setAttribute("class", layout.value);
-  },
-  { immediate: true }
-);
-
-
-// 监听窗口大小变化，折叠侧边栏
-const screenWidth = ref(0);
-const listeningWindow = useDebounceFn(() => {
-  screenWidth.value = document.body.clientWidth;
-  if (!isCollapse.value && screenWidth.value < 1200)
-    globalStore.setGlobalState("isCollapse", true);
-  if (isCollapse.value && screenWidth.value > 1200)
-    globalStore.setGlobalState("isCollapse", false);
-}, 100);
-window.addEventListener("resize", listeningWindow, false);
-onBeforeUnmount(() => {
-  window.removeEventListener("resize", listeningWindow);
-});
-</script>
-
-<style scoped lang="scss">
-@import "./index.scss";
-</style>
+<template>
+  <Maximize v-show="maximize" />
+  <Tabs v-if="tabs && showMenuFlag" />
+  <el-main>
+    <router-view v-slot="{ Component, route }" style="height:100%;">
+      <!-- {{ keepAliveName}} -->
+      <!-- <transition  name="slide-right" mode="out-in"> -->
+        <keep-alive :include="tabsMenuList" >
+          <component :is="Component" :key="route.fullPath" />
+        </keep-alive>
+      <!-- </transition> -->
+    </router-view>
+  </el-main>
+  <el-footer>
+    <Footer />
+  </el-footer>
+</template>
+
+<script setup lang="ts">
+import { ref, onBeforeUnmount, provide, watch, computed } from "vue";
+import { storeToRefs } from "pinia";
+import { useDebounceFn } from "@vueuse/core";
+import { useGlobalStore } from "@/stores/modules/global";
+import { useKeepAliveStore } from "@/stores/modules/keepAlive";
+import Maximize from "./components/Maximize.vue";
+import Tabs from "@/layouts/components/Tabs/index.vue";
+import Footer from "@/layouts/components/Footer/index.vue";
+import { useAuthStore } from "@/stores/modules/auth";
+import { useTabsStore } from '@/stores/modules/tabs'
+const tabStore = useTabsStore()
+const globalStore = useGlobalStore();
+const tabsMenuList = computed(() => tabStore.tabsMenuList.map(item => item.name))
+const authStore = useAuthStore();
+const { maximize, isCollapse, layout, tabs, footer } = storeToRefs(globalStore);
+const keepAliveStore = useKeepAliveStore();
+const { keepAliveName } = storeToRefs(keepAliveStore);
+//是否显示导航栏
+const showMenuFlag = computed(() => authStore.showMenuFlagGet);
+// 注入刷新页面方法
+const isRouterShow = ref(true);
+const refreshCurrentPage = (val: boolean) => (isRouterShow.value = val);
+provide("refresh", refreshCurrentPage);
+
+// 监听当前页面是否最大化，动态添加 class
+watch(
+  () => maximize.value,
+  () => {
+    const app = document.getElementById("app") as HTMLElement;
+    if (maximize.value) app.classList.add("main-maximize");
+    else app.classList.remove("main-maximize");
+  },
+  { immediate: true }
+);
+
+// 监听布局变化，在 body 上添加相对应的 layout class
+watch(
+  () => layout.value,
+  () => {
+    const body = document.body as HTMLElement;
+    body.setAttribute("class", layout.value);
+  },
+  { immediate: true }
+);
+
+
+// 监听窗口大小变化，折叠侧边栏
+const screenWidth = ref(0);
+const listeningWindow = useDebounceFn(() => {
+  screenWidth.value = document.body.clientWidth;
+  if (!isCollapse.value && screenWidth.value < 1200)
+    globalStore.setGlobalState("isCollapse", true);
+  if (isCollapse.value && screenWidth.value > 1200)
+    globalStore.setGlobalState("isCollapse", false);
+}, 100);
+window.addEventListener("resize", listeningWindow, false);
+onBeforeUnmount(() => {
+  window.removeEventListener("resize", listeningWindow);
+});
+</script>
+
+<style scoped lang="scss">
+@import "./index.scss";
+</style>

frontend/src/layouts/components/Menu/SubMenu.vue

@@ -20,13 +20,17 @@
   </template>
 </template>
 <script setup lang="ts">
+import { onBeforeMount } from "vue";
 import { useRouter } from "vue-router";
 defineProps<{ menuList: Menu.MenuOptions[] }>();
 const router = useRouter();
 const handleClickMenu = (subItem: Menu.MenuOptions) => {
+  //console.log('1456----------------',subItem);
   if (subItem.meta.isLink) return window.open(subItem.meta.isLink, "_blank");
   router.push(subItem.path);
 };
+
+
 </script>
 <style lang="scss">
 .el-sub-menu .el-sub-menu__title:hover {

frontend/src/layouts/components/Tabs/index.vue

@@ -1,122 +1,121 @@
-<template>
-    <div class="tabs-box">
-        <div class="tabs-menu">
-            <el-tabs v-model="tabsMenuValue" type="card" @tab-click="tabClick" @tab-remove="tabRemove">
-                <el-tab-pane
-                    v-for="item in tabsMenuList"
-                    :key="item.path"
-                    :label="item.title"
-                    :name="item.path"
-                    :closable="item.close"
-                >
-                    <template #label>
-                        <el-icon v-show="item.icon && tabsIcon" class="tabs-icon">
-                            <component :is="item.icon"></component>
-                        </el-icon>
-                        {{ item.title }}
-                    </template>
-                </el-tab-pane>
-            </el-tabs>
-            <MoreButton />
-        </div>
-    </div>
-</template>
-
-<script setup lang="ts">
-import Sortable from 'sortablejs'
-import { ref, computed, watch, onMounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useGlobalStore } from '@/stores/modules/global'
-import { useTabsStore } from '@/stores/modules/tabs'
-import { useAuthStore } from '@/stores/modules/auth'
-import { TabsPaneContext, TabPaneName } from 'element-plus'
-import MoreButton from './components/MoreButton.vue'
-
-const route = useRoute()
-const router = useRouter()
-const tabStore = useTabsStore()
-const authStore = useAuthStore()
-const globalStore = useGlobalStore()
-
-const tabsMenuValue = ref(route.fullPath)
-const tabsMenuList = computed(() => tabStore.tabsMenuList)
-const tabsIcon = computed(() => globalStore.tabsIcon)
-
-onMounted(() => {
-    tabsDrop()
-    initTabs()
-})
-
-// 监听路由的变化（防止浏览器后退/前进不变化 tabsMenuValue）
-watch(
-    () => route.fullPath,
-    () => {
-        if (route.meta.isFull) return
-        if (route.meta.hideTab) {
-            tabsMenuValue.value = route.meta.parentPath as string
-        } else {
-            tabsMenuValue.value = route.fullPath
-            const tabsParams = {
-                icon: route.meta.icon as string,
-                title: route.meta.title as string,
-                path: route.fullPath,
-                name: route.name as string,
-                close: !route.meta.isAffix,
-                isKeepAlive: route.meta.isKeepAlive as boolean
-            }
-            tabStore.addTabs(tabsParams)
-        }
-    },
-    { immediate: true }
-)
-
-// 初始化需要固定的 tabs
-const initTabs = () => {
-    authStore.flatMenuListGet.forEach(item => {
-        if (item.meta.isAffix && !item.meta.isHide && !item.meta.isFull) {
-            const tabsParams = {
-                icon: item.meta.icon,
-                title: item.meta.title,
-                path: item.path,
-                name: item.name,
-                close: !item.meta.isAffix,
-                isKeepAlive: item.meta.isKeepAlive,
-                unshift: true
-            }
-            tabStore.addTabs(tabsParams)
-        }
-    })
-}
-
-// tabs 拖拽排序
-const tabsDrop = () => {
-    Sortable.create(document.querySelector('.el-tabs__nav') as HTMLElement, {
-        draggable: '.el-tabs__item',
-        animation: 300,
-        onEnd({ newIndex, oldIndex }) {
-            const tabsList = [...tabStore.tabsMenuList]
-            const currRow = tabsList.splice(oldIndex as number, 1)[0]
-            tabsList.splice(newIndex as number, 0, currRow)
-            tabStore.setTabs(tabsList)
-        }
-    })
-}
-
-// Tab Click
-const tabClick = (tabItem: TabsPaneContext) => {
-    const fullPath = tabItem.props.name as string
-    // console.log("🚀 ~ tabClick ~ fullPath:", tabItem)
-    router.push(fullPath)
-}
-
-// Remove Tab
-const tabRemove = (fullPath: TabPaneName) => {
-
-
-    tabStore.removeTabs(fullPath as string, fullPath == route.fullPath || '/machine/testScriptAdd' == route.fullPath)
-}
-</script>
-
-<style scoped lang="scss">
-@import './index.scss';
-</style>
+<template>
+    <div class="tabs-box">
+        <div class="tabs-menu">
+            <el-tabs v-model="tabsMenuValue" type="card" @tab-click="tabClick" @tab-remove="tabRemove">
+                <el-tab-pane
+                    v-for="item in tabsMenuList"
+                    :key="item.path"
+                    :label="item.title"
+                    :name="item.path"
+                    :closable="item.close"
+                >
+                    <template #label>
+                        <el-icon v-show="item.icon && tabsIcon" class="tabs-icon">
+                            <component :is="item.icon"></component>
+                        </el-icon>
+                        {{ item.title }}
+                    </template>
+                </el-tab-pane>
+            </el-tabs>
+            <MoreButton />
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+import Sortable from 'sortablejs'
+import { ref, computed, watch, onMounted } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { useGlobalStore } from '@/stores/modules/global'
+import { useTabsStore } from '@/stores/modules/tabs'
+import { useAuthStore } from '@/stores/modules/auth'
+import { TabsPaneContext, TabPaneName } from 'element-plus'
+import MoreButton from './components/MoreButton.vue'
+
+const route = useRoute()
+const router = useRouter()
+const tabStore = useTabsStore()
+const authStore = useAuthStore()
+const globalStore = useGlobalStore()
+
+const tabsMenuValue = ref(route.fullPath)
+const tabsMenuList = computed(() => tabStore.tabsMenuList)
+const tabsIcon = computed(() => globalStore.tabsIcon)
+
+onMounted(() => {
+    tabsDrop()
+    initTabs()
+})
+
+// 监听路由的变化（防止浏览器后退/前进不变化 tabsMenuValue）
+watch(
+    () => route.fullPath,
+    () => {
+        if (route.meta.isFull) return
+        if (route.meta.hideTab) {
+            tabsMenuValue.value = route.meta.parentPath as string
+        } else {
+            tabsMenuValue.value = route.fullPath
+            const tabsParams = {
+                icon: route.meta.icon as string,
+                title: route.meta.title as string,
+                path: route.fullPath,
+                name: route.name as string,
+                close: !route.meta.isAffix,
+                isKeepAlive: route.meta.isKeepAlive as boolean
+            }
+            tabStore.addTabs(tabsParams)
+        }
+    },
+    { immediate: true }
+)
+
+// 初始化需要固定的 tabs
+const initTabs = () => {
+    authStore.flatMenuListGet.forEach(item => {
+        if (item.meta.isAffix && !item.meta.isHide && !item.meta.isFull) {
+            const tabsParams = {
+                icon: item.meta.icon,
+                title: item.meta.title,
+                path: item.path,
+                name: item.name,
+                close: !item.meta.isAffix,
+                isKeepAlive: item.meta.isKeepAlive,
+                unshift: true
+            }
+            tabStore.addTabs(tabsParams)
+        }
+    })
+}
+
+// tabs 拖拽排序
+const tabsDrop = () => {
+    Sortable.create(document.querySelector('.el-tabs__nav') as HTMLElement, {
+        draggable: '.el-tabs__item',
+        animation: 300,
+        onEnd({ newIndex, oldIndex }) {
+            const tabsList = [...tabStore.tabsMenuList]
+            const currRow = tabsList.splice(oldIndex as number, 1)[0]
+            tabsList.splice(newIndex as number, 0, currRow)
+            tabStore.setTabs(tabsList)
+        }
+    })
+}
+
+// Tab Click
+const tabClick = (tabItem: TabsPaneContext) => {
+    const fullPath = tabItem.props.name as string
+    router.push(fullPath)
+}
+
+// Remove Tab
+const tabRemove = (fullPath: TabPaneName) => {
+
+
+    tabStore.removeTabs(fullPath as string, fullPath == route.fullPath || '/machine/testScriptAdd' == route.fullPath)
+}
+</script>
+
+<style scoped lang="scss">
+@import './index.scss';
+</style>

frontend/src/stores/modules/auth.ts

@@ -8,6 +8,9 @@ import {
 } from "@/utils";
 import { useRouter } from "vue-router";
 import { AUTH_STORE_KEY } from "@/stores/constant";
+import {useModeStore} from '@/stores/modules/mode'
+
+
 export const useAuthStore = defineStore({
   id: AUTH_STORE_KEY,
   state: (): AuthState => ({
@@ -43,9 +46,16 @@ export const useAuthStore = defineStore({
     },
     // Get AuthMenuList
     async getAuthMenuList() {
-      const { data } = await getAuthMenuListApi();
-      this.authMenuList = data;
+      const modeStore = useModeStore()
      
+      const { data: menuData } = await getAuthMenuListApi();
+        // 根据不同模式过滤菜单
+      const filteredMenu = modeStore.currentMode === '比对式' 
+        ? filterMenuByExcludedNames(menuData, ['testSource', 'testScript', 'controlSource'])
+        : filterMenuByExcludedNames(menuData, ['standardDevice']);
+  
+      this.authMenuList = filteredMenu;
+    
     },
     // Set RouteName
     async setRouteName(name: string) {
@@ -73,3 +83,21 @@ export const useAuthStore = defineStore({
     },
   },
 });
+
+
+/**
+ * 通用菜单过滤函数
+ * @param menuList 菜单列表
+ * @param excludedNames 需要排除的菜单名称数组
+ * @returns 过滤后的菜单列表
+ */
+function filterMenuByExcludedNames(menuList: any[], excludedNames: string[]): any[] {
+  return menuList.filter(menu => {
+    // 如果当前项有 children，递归处理子项
+    if (menu.children && menu.children.length > 0) {
+      menu.children = filterMenuByExcludedNames(menu.children, excludedNames);
+    }
+    // 过滤掉在排除列表中的菜单项
+    return !excludedNames.includes(menu.name);
+  });
+}

frontend/src/stores/modules/check.ts

@@ -3,25 +3,21 @@ import {CHECK_STORE_KEY} from "@/stores/constant";
 import type {CheckData} from "@/api/check/interface";
 import type {Plan} from '@/api/plan/interface'
 import {useAppSceneStore} from "@/stores/modules/mode";
-import { set } from "lodash";
-
-const AppSceneStore = useAppSceneStore()
-export const useCheckStore = defineStore("check", {
-    id: CHECK_STORE_KEY,
 
+export const useCheckStore = defineStore(CHECK_STORE_KEY, {
     state: () => ({
-        devices: Array<CheckData.Device>(),
-        plan: Object<Plan.ResPlan>(),
-        selectTestItems: Object<CheckData.SelectTestItem>({preTest: true, timeTest: false, channelsTest: false, test: true}),
-        checkType:1, // 0:手动检测 1:自动检测
+        devices: [] as CheckData.Device[],
+        plan: {} as Plan.ResPlan,
+        selectTestItems: {preTest: true, timeTest: false, channelsTest: false, test: true} as CheckData.SelectTestItem,
+        checkType: 1, // 0:手动检测 1:自动检测
         reCheckType: 1, // 0:不合格项复检 1:全部复检
-        showDetailType: 0 ,// 0:数据查询 1:误差体系跟换 2：正式检测
+        showDetailType: 0, // 0:数据查询 1:误差体系跟换 2：正式检测
         temperature: 0,
-        humidity: 0
+        humidity: 0,
+        chnNumList: [],//连线数据
+        nodesConnectable: true,//设置是能可以连线
     }),
-
     getters: {},
-
     actions: {
         addDevices(device: CheckData.Device[]) {
             this.devices.push(...device);
@@ -33,8 +29,9 @@ export const useCheckStore = defineStore("check", {
             this.devices = [];
         },
         initSelectTestItems() {
+            const appSceneStore = useAppSceneStore()
             this.selectTestItems.preTest = true
-            if (AppSceneStore.currentScene === '1') {
+            if (appSceneStore.currentScene === '1') {
                 this.selectTestItems.channelsTest = true
             } else {
                 this.selectTestItems.channelsTest = false
@@ -58,6 +55,13 @@ export const useCheckStore = defineStore("check", {
         },
         setHumidity(humidity: number) {
             this.humidity = humidity
-        }
+        },
+         setChnNum(chnNumList: string[]) {
+            this.chnNumList = chnNumList
+        },
+         setNodesConnectable(nodesConnectable: boolean) {
+            this.nodesConnectable = nodesConnectable
+        },
+
     }
 });

frontend/src/stores/modules/global.ts

@@ -1,5 +1,5 @@
 import { defineStore } from "pinia";
-import { GlobalState } from "@/stores/interface";
+import { type GlobalState } from "@/stores/interface";
 import { DEFAULT_PRIMARY} from "@/config";
 import piniaPersistConfig from "@/stores/helper/persist";
 import {GLOBAL_STORE_KEY} from "@/stores/constant";
@@ -49,7 +49,6 @@ export const useGlobalStore = defineStore({
     // Set GlobalState
     setGlobalState(...args: ObjToKeyValArray<GlobalState>) {
       this.$patch({ [args[0]]: args[1] });
-      console.log(DEFAULT_PRIMARY);
     }
   },
   persist: piniaPersistConfig(GLOBAL_STORE_KEY)

frontend/src/styles/reset.scss

@@ -140,3 +140,9 @@ body,
 :-webkit-any(article, aside, nav, section) h1 {
   font-size: 2em;
 }
+
+@import 'https://cdn.jsdelivr.net/npm/@vue-flow/core@1.45.0/dist/style.css';
+@import 'https://cdn.jsdelivr.net/npm/@vue-flow/core@1.45.0/dist/theme-default.css';
+@import 'https://cdn.jsdelivr.net/npm/@vue-flow/controls@latest/dist/style.css';
+@import 'https://cdn.jsdelivr.net/npm/@vue-flow/minimap@latest/dist/style.css';
+@import 'https://cdn.jsdelivr.net/npm/@vue-flow/node-resizer@latest/dist/style.css';

frontend/src/utils/jwtUtil.ts

@@ -0,0 +1,234 @@
+import { useUserStore } from "@/stores/modules/user";
+
+// JWT Token解析后的载荷接口
+export interface JwtPayload {
+    userId?: string;
+    loginName?: string;
+    exp?: number;
+    iat?: number;
+    [key: string]: any;
+}
+
+// Token信息摘要接口
+export interface TokenInfo {
+    userId: string | null;
+    loginName: string | null;
+    expiration: string | null;
+    isExpired: boolean;
+    remainingTime: string;
+}
+
+/**
+ * JWT工具类
+ * 提供JWT token的解析、验证等功能
+ */
+export class JwtUtil {
+    /**
+     * Base64URL解码
+     * @param str Base64URL编码的字符串
+     */
+    private static base64UrlDecode(str: string): string {
+        try {
+            // Base64URL转Base64
+            let base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+            
+            // 补齐padding
+            while (base64.length % 4) {
+                base64 += '=';
+            }
+            
+            // Base64解码
+            const decoded = atob(base64);
+            
+            // 处理UTF-8编码
+            return decodeURIComponent(
+                decoded
+                    .split('')
+                    .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+                    .join('')
+            );
+        } catch (error) {
+            throw new Error('Base64URL解码失败: ' + error);
+        }
+    }
+
+    /**
+     * 解析JWT Token获取载荷信息
+     * @param token JWT token字符串，如果不传则从store中获取
+     */
+    static parseToken(token?: string): JwtPayload | null {
+        try {
+            let targetToken = token;
+            
+            // 如果没有传入token，从store中获取
+            if (!targetToken) {
+                const userStore = useUserStore();
+                targetToken = userStore.accessToken;
+            }
+            
+            if (!targetToken) {
+                console.warn('Token不存在');
+                return null;
+            }
+
+            // JWT token由三部分组成，用.分割：header.payload.signature
+            const parts = targetToken.split('.');
+            if (parts.length !== 3) {
+                console.error('无效的JWT token格式');
+                return null;
+            }
+
+            // 解码payload部分（第二部分）
+            const payload = parts[1];
+            const decodedPayload = this.base64UrlDecode(payload);
+            const tokenData: JwtPayload = JSON.parse(decodedPayload);
+
+            return tokenData;
+        } catch (error) {
+            console.error('解析JWT Token失败:', error);
+            return null;
+        }
+    }
+
+    /**
+     * 获取指定字段的值
+     * @param field 字段名
+     * @param token JWT token字符串，可选
+     */
+    static getField<T = any>(field: string, token?: string): T | null {
+        const tokenData = this.parseToken(token);
+        return tokenData?.[field] || null;
+    }
+
+    /**
+     * 获取用户ID
+     * @param token JWT token字符串，可选
+     */
+    static getUserId(token?: string): string | null {
+        return this.getField<string>('userId', token);
+    }
+
+    /**
+     * 获取登录名
+     * @param token JWT token字符串，可选
+     */
+    static getLoginName(token?: string): string | null {
+        return this.getField<string>('loginName', token);
+    }
+
+    /**
+     * 获取Token过期时间戳（秒）
+     * @param token JWT token字符串，可选
+     */
+    static getExpiration(token?: string): number | null {
+        return this.getField<number>('exp', token);
+    }
+
+    /**
+     * 获取Token签发时间戳（秒）
+     * @param token JWT token字符串，可选
+     */
+    static getIssuedAt(token?: string): number | null {
+        return this.getField<number>('iat', token);
+    }
+
+    /**
+     * 检查Token是否过期
+     * @param token JWT token字符串，可选
+     */
+    static isExpired(token?: string): boolean {
+        const exp = this.getExpiration(token);
+        if (!exp) return true;
+        
+        // JWT中的exp是秒级时间戳，需要转换为毫秒
+        const expTime = exp * 1000;
+        return Date.now() >= expTime;
+    }
+
+    /**
+     * 获取Token剩余有效时间（毫秒）
+     * @param token JWT token字符串，可选
+     */
+    static getRemainingTime(token?: string): number {
+        const exp = this.getExpiration(token);
+        if (!exp) return 0;
+        
+        const expTime = exp * 1000;
+        const remaining = expTime - Date.now();
+        return Math.max(0, remaining);
+    }
+
+    /**
+     * 格式化剩余时间为可读字符串
+     * @param ms 毫秒数
+     */
+    static formatRemainingTime(ms: number): string {
+        if (ms <= 0) return '已过期';
+        
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        
+        if (days > 0) return `${days}天 ${hours % 24}小时`;
+        if (hours > 0) return `${hours}小时 ${minutes % 60}分钟`;
+        if (minutes > 0) return `${minutes}分钟 ${seconds % 60}秒`;
+        return `${seconds}秒`;
+    }
+
+    /**
+     * 获取完整的Token信息摘要
+     * @param token JWT token字符串，可选
+     */
+    static getTokenInfo(token?: string): TokenInfo {
+        const exp = this.getExpiration(token);
+        const remainingMs = this.getRemainingTime(token);
+        
+        return {
+            userId: this.getUserId(token),
+            loginName: this.getLoginName(token),
+            expiration: exp ? new Date(exp * 1000).toLocaleString() : null,
+            isExpired: this.isExpired(token),
+            remainingTime: this.formatRemainingTime(remainingMs)
+        };
+    }
+
+    /**
+     * 验证Token是否有效（格式正确且未过期）
+     * @param token JWT token字符串，可选
+     */
+    static isValid(token?: string): boolean {
+        const tokenData = this.parseToken(token);
+        return tokenData !== null && !this.isExpired(token);
+    }
+
+    /**
+     * 获取Token的头部信息
+     * @param token JWT token字符串，可选
+     */
+    static getHeader(token?: string): any | null {
+        try {
+            let targetToken = token;
+            
+            if (!targetToken) {
+                const userStore = useUserStore();
+                targetToken = userStore.accessToken;
+            }
+            
+            if (!targetToken) return null;
+
+            const parts = targetToken.split('.');
+            if (parts.length !== 3) return null;
+
+            const header = parts[0];
+            const decodedHeader = this.base64UrlDecode(header);
+            return JSON.parse(decodedHeader);
+        } catch (error) {
+            console.error('解析JWT Header失败:', error);
+            return null;
+        }
+    }
+}
+
+// 导出单例方法，方便直接调用
+export const jwtUtil = JwtUtil;

frontend/src/utils/mittBus.ts

@@ -1,5 +1,4 @@
 import mitt from "mitt";
 
 const mittBus = mitt();
-
 export default mittBus;

frontend/src/utils/webSocketClient.ts

@@ -1,185 +1,697 @@
-import {ElMessage} from "element-plus";
+/**
+ * WebSocket客户端服务
+ * 提供WebSocket连接管理、心跳机制、消息处理等功能
+ * 集成JWT token解析，支持自动获取用户登录名
+ * 
+ * @author hongawen
+ * @version 2.0
+ */
 
+import { ElMessage } from "element-plus";
+import { jwtUtil } from "./jwtUtil";
 
+// ============================================================================
+// 类型定义 (Types & Interfaces)
+// ============================================================================
+
+/**
+ * WebSocket消息接口定义（对应后端WebSocketVO结构）
+ */
+interface WebSocketMessage<T = any> {
+    type: string;           // 消息类型
+    requestId?: string;     // 请求ID
+    operateCode?: string;   // 操作代码
+    code?: number;          // 状态码
+    desc?: string;          // 描述信息
+    data?: T;              // 泛型数据
+}
+
+/**
+ * 回调函数类型定义
+ */
+type CallbackFunction<T = any> = (message: WebSocketMessage<T>) => void;
+
+/**
+ * WebSocket配置接口
+ */
+interface SocketConfig {
+    url: string;                    // WebSocket服务器地址
+    heartbeatInterval?: number;     // 心跳间隔时间(ms)
+    reconnectDelay?: number;        // 重连延迟时间(ms)
+    maxReconnectAttempts?: number;  // 最大重连次数
+    timeout?: number;               // 超时时间(ms)
+}
+
+/**
+ * 连接状态枚举
+ */
+enum ConnectionStatus {
+    DISCONNECTED = 'disconnected',   // 未连接
+    CONNECTING = 'connecting',       // 连接中
+    CONNECTED = 'connected',         // 已连接
+    RECONNECTING = 'reconnecting',   // 重连中
+    ERROR = 'error'                  // 连接错误
+}
+
+/**
+ * 常用的WebSocket消息类型定义命名空间
+ */
+namespace WebSocketMessageTypes {
+    /**
+     * 预检测相关消息
+     */
+    export interface PreTestMessage {
+        deviceId?: string;
+        status?: string;
+        progress?: number;
+        errorInfo?: string;
+    }
+    
+    /**
+     * 系数校准相关消息
+     */
+    export interface CoefficientMessage {
+        deviceId: string;
+        channel: number;
+        voltage?: string;
+        current?: string;
+        calibrationResult?: boolean;
+    }
+    
+    /**
+     * 正式检测相关消息
+     */
+    export interface TestMessage {
+        deviceId: string;
+        testType: string;
+        testResult?: 'success' | 'failed' | 'processing';
+        testData?: any;
+    }
+    
+    /**
+     * 通用响应消息
+     */
+    export interface CommonResponse {
+        success: boolean;
+        message?: string;
+        timestamp?: number;
+    }
+}
+
+// ============================================================================
+// 导出类型
+// ============================================================================
+
+export type { 
+    WebSocketMessage, 
+    CallbackFunction, 
+    SocketConfig, 
+    WebSocketMessageTypes
+};
+
+export { 
+    ConnectionStatus
+};
+
+// ============================================================================
+// 主要服务类
+// ============================================================================
+
+/**
+ * WebSocket服务类
+ * 单例模式实现，提供完整的WebSocket连接管理功能
+ */
 export default class SocketService {
-    static instance = null;
-    static get Instance() {
+    // ========================================================================
+    // 静态属性和方法 (Static)
+    // ========================================================================
+
+    /**
+     * 单例实例
+     */
+    private static instance: SocketService | null = null;
+    
+    /**
+     * 获取单例实例
+     * @returns SocketService实例
+     */
+    static get Instance(): SocketService {
         if (!this.instance) {
             this.instance = new SocketService();
         }
         return this.instance;
     }
-    // 和服务端连接的socket对象
-    ws = null;
-    // 存储回调函数
-    callBackMapping = {};
-    // 标识是否连接成功
-    connected = false;
-    // 记录重试的次数
-    sendRetryCount = 0;
-    // 重新连接尝试的次数
-    connectRetryCount = 0;
-    work:any;
-    workerBlobUrl:any;
-    lastActivityTime= 0; // 上次活动时间戳
-    lastResponseHeartTime = Date.now();//最后一次收到心跳回复时间
 
-    reconnectDelay= 5000; // 重新连接延迟，单位毫秒
+    // ========================================================================
+    // 实例属性 (Properties)
+    // ========================================================================
 
-    //  定义连接服务器的方法
-    connect() {
+    /**
+     * WebSocket连接实例
+     */
+    private ws: WebSocket | null = null;
+    
+    /**
+     * 消息回调函数映射表
+     */
+    private callBackMapping: Record<string, CallbackFunction<any>> = {};
+    
+    /**
+     * 当前连接状态
+     */
+    private connectionStatus: ConnectionStatus = ConnectionStatus.DISCONNECTED;
+    
+    /**
+     * 发送消息重试计数器
+     */
+    private sendRetryCount: number = 0;
+    
+    /**
+     * 连接重试计数器
+     */
+    private connectRetryCount: number = 0;
+    
+    /**
+     * 心跳Worker实例
+     */
+    private heartbeatWorker: Worker | null = null;
+    
+    /**
+     * Worker脚本的Blob URL
+     */
+    private workerBlobUrl: string | null = null;
+    
+    /**
+     * 最后一次收到心跳响应的时间戳
+     */
+    private lastResponseHeartTime: number = Date.now();
+    
+    /**
+     * WebSocket连接配置
+     */
+    private config: SocketConfig = {
+        // url: 'ws://127.0.0.1:7777/hello',
+        url: 'ws://192.168.1.124:7777/hello',
+        heartbeatInterval: 9000,        // 9秒心跳间隔
+        reconnectDelay: 5000,           // 5秒重连延迟
+        maxReconnectAttempts: 5,        // 最多重连5次
+        timeout: 30000                  // 30秒超时
+    };
 
-        // 连接服务器
+    // ========================================================================
+    // 构造函数 (Constructor)
+    // ========================================================================
+
+    /**
+     * 私有构造函数，防止外部直接实例化
+     */
+    private constructor() {
+        this.initializeProperties();
+    }
+
+    /**
+     * 初始化属性
+     */
+    private initializeProperties(): void {
+        this.lastResponseHeartTime = Date.now();
+    }
+
+    // ========================================================================
+    // Getter属性 (Computed)
+    // ========================================================================
+
+    /**
+     * 获取连接状态
+     * @returns 是否已连接
+     */
+    get connected(): boolean {
+        return this.connectionStatus === ConnectionStatus.CONNECTED;
+    }
+
+    // ========================================================================
+    // 公共方法 (Public Methods)
+    // ========================================================================
+
+    /**
+     * 配置WebSocket连接参数
+     * @param config 部分配置对象
+     */
+    public configure(config: Partial<SocketConfig>): void {
+        this.config = { ...this.config, ...config };
+    }
+
+    /**
+     * 连接WebSocket服务器（同步方式，保持向后兼容）
+     */
+    public connect(): Promise<void> | void {
+        // 检查浏览器支持
         if (!window.WebSocket) {
-            return console.log('您的浏览器不支持WebSocket');
+            console.log('您的浏览器不支持WebSocket');
+            return;
         }
 
-        // let token = $.cookie('123');
-        // let token = '4E6EF539AAF119D82AC4C2BC84FBA21F';
+        // 防止重复连接
+        if (this.connectionStatus === ConnectionStatus.CONNECTING || this.connected) {
+            console.warn('WebSocket已连接或正在连接中');
+            return;
+        }
+
+        this.connectionStatus = ConnectionStatus.CONNECTING;
+        
+        try {
+            this.ws = new WebSocket(this.buildWebSocketUrl());
+            this.setupEventHandlersLegacy();
+        } catch (error) {
+            this.connectionStatus = ConnectionStatus.ERROR;
+            console.error('WebSocket连接失败:', error);
+        }
+    }
+
+    /**
+     * 异步连接WebSocket服务器
+     * @returns Promise<void>
+     */
+    public connectAsync(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            // 检查浏览器支持
+            if (!window.WebSocket) {
+                const error = '您的浏览器不支持WebSocket';
+                console.error(error);
+                reject(new Error(error));
+                return;
+            }
+
+            // 防止重复连接
+            if (this.connectionStatus === ConnectionStatus.CONNECTING || this.connected) {
+                console.warn('WebSocket已连接或正在连接中');
+                resolve();
+                return;
+            }
+
+            this.connectionStatus = ConnectionStatus.CONNECTING;
+            
+            try {
+                this.ws = new WebSocket(this.buildWebSocketUrl());
+                this.setupEventHandlers(resolve, reject);
+            } catch (error) {
+                this.connectionStatus = ConnectionStatus.ERROR;
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * 注册消息回调函数（支持泛型）
+     * @param messageType 消息类型
+     * @param callback 回调函数
+     */
+    public registerCallBack<T = any>(messageType: string, callback: CallbackFunction<T>): void {
+        if (!messageType || typeof callback !== 'function') {
+            console.error('注册回调函数参数无效');
+            return;
+        }
+        this.callBackMapping[messageType] = callback;
+        console.log(`注册消息处理器: ${messageType}`);
+    }
+
+    /**
+     * 注销消息回调函数
+     * @param messageType 消息类型
+     */
+    public unRegisterCallBack(messageType: string): void {
+        if (this.callBackMapping[messageType]) {
+            delete this.callBackMapping[messageType];
+            console.log(`注销消息处理器: ${messageType}`);
+        }
+    }
+
+    /**
+     * 发送数据到WebSocket服务器
+     * @param data 要发送的数据
+     * @returns Promise<void>
+     */
+    public send(data: any): Promise<void> {
+        return new Promise((resolve, reject) => {
+            if (!this.connected || !this.ws) {
+                // 未连接时的重试机制
+                if (this.sendRetryCount < 3) {
+                    this.sendRetryCount++;
+                    setTimeout(() => {
+                        this.send(data).then(resolve).catch(reject);
+                    }, this.sendRetryCount * 500);
+                    return;
+                } else {
+                    reject(new Error('WebSocket未连接且重试失败'));
+                    return;
+                }
+            }
+
+            try {
+                // 重置重试计数
+                this.sendRetryCount = 0;
+                
+                // 尝试发送JSON数据，失败则发送原始数据
+                const message = typeof data === 'string' ? data : JSON.stringify(data);
+                this.ws.send(message);
+                
+                console.log('发送消息:', message);
+                resolve();
+            } catch (error) {
+                console.error('发送消息失败:', error);
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * 关闭WebSocket连接
+     */
+    public closeWs(): void {
+        console.log('正在关闭WebSocket连接...');
+        
+        // 清理心跳
+        this.clearHeartbeat();
+        
+        // 关闭连接
+        if (this.ws) {
+            this.ws.close(1000, '主动关闭连接');
+            this.ws = null;
+        }
+        
+        // 更新状态
+        this.connectionStatus = ConnectionStatus.DISCONNECTED;
+        this.connectRetryCount = 0;
+        this.sendRetryCount = 0;
+        
+        console.log('WebSocket连接已关闭');
+    }
+
+    /**
+     * 获取当前连接状态
+     * @returns 连接状态枚举值
+     */
+    public getConnectionStatus(): ConnectionStatus {
+        return this.connectionStatus;
+    }
+
+    /**
+     * 获取连接统计信息
+     * @returns 连接统计对象
+     */
+    public getConnectionStats(): {
+        status: ConnectionStatus;
+        connectRetryCount: number;
+        lastResponseHeartTime: number;
+    } {
+        return {
+            status: this.connectionStatus,
+            connectRetryCount: this.connectRetryCount,
+            lastResponseHeartTime: this.lastResponseHeartTime
+        };
+    }
 
 
-        const url = 'ws://127.0.0.1:7777/hello?name=cdf'
-        this.ws = new WebSocket(url);
-        // 连接成功的事件
+    // ========================================================================
+    // 私有方法 (Private Methods)
+    // ========================================================================
+
+    /**
+     * 构建完整的WebSocket URL
+     * 自动从JWT token中获取loginName作为name参数
+     * @returns 完整的WebSocket URL
+     */
+    private buildWebSocketUrl(): string {
+        const { url } = this.config;
+        
+        // 直接从JWT token中获取loginName作为name参数
+        const loginName = jwtUtil.getLoginName();
+        
+        if (loginName) {
+            const separator = url.includes('?') ? '&' : '?';
+            return `${url}${separator}name=${encodeURIComponent(loginName)}`;
+        }
+        
+        // 如果无法获取loginName，返回原始URL并输出警告
+        console.warn('无法从JWT token中获取loginName，WebSocket连接可能会失败');
+        return url;
+    }
+
+    /**
+     * 设置WebSocket事件处理器（异步版本）
+     * @param resolve Promise resolve回调
+     * @param reject Promise reject回调
+     */
+    private setupEventHandlers(resolve: () => void, reject: (error: Error) => void): void {
+        if (!this.ws) return;
+        
+        // 连接成功事件
+        this.ws.onopen = () => {
+            ElMessage.success("WebSocket连接服务端成功");
+            console.log('WebSocket连接成功');
+            this.connectionStatus = ConnectionStatus.CONNECTED;
+            this.connectRetryCount = 0;
+            this.startHeartbeat();
+            resolve();
+        };
+
+        // 连接关闭事件
+        this.ws.onclose = (event: CloseEvent) => {
+            console.log('WebSocket连接关闭', event.code, event.reason);
+            this.connectionStatus = ConnectionStatus.DISCONNECTED;
+            this.clearHeartbeat();
+            
+            // 非正常关闭且未超过最大重连次数，尝试重连
+            if (event.code !== 1000 && this.connectRetryCount < this.config.maxReconnectAttempts!) {
+                this.attemptReconnect();
+            }
+        };
+
+        // 连接错误事件
+        this.ws.onerror = (error: Event) => {
+            console.error('WebSocket连接错误:', error);
+            ElMessage.error("WebSocket连接异常");
+            this.connectionStatus = ConnectionStatus.ERROR;
+            reject(new Error('WebSocket连接失败'));
+        };
+
+        // 消息接收事件
+        this.ws.onmessage = (event: MessageEvent) => {
+            this.handleMessage(event);
+        };
+    }
+
+    /**
+     * 设置WebSocket事件处理器（兼容版本）
+     */
+    private setupEventHandlersLegacy(): void {
+        if (!this.ws) return;
+        
+        // 连接成功事件
         this.ws.onopen = () => {
             ElMessage.success("webSocket连接服务端成功了");
             console.log('连接服务端成功了');
-            this.connected = true;
-            // 重置重新连接的次数
+            this.connectionStatus = ConnectionStatus.CONNECTED;
             this.connectRetryCount = 0;
-            this.updateLastActivityTime();
             this.startHeartbeat();
         };
-        // 1.连接服务端失败
-        // 2.当连接成功之后, 服务器关闭的情况
-        this.ws.onclose = () => {
+
+        // 连接关闭事件
+        this.ws.onclose = (event: CloseEvent) => {
             console.log('连接webSocket服务端关闭');
-            this.connected = false;
-            this.connectRetryCount++;
+            this.connectionStatus = ConnectionStatus.DISCONNECTED;
             this.clearHeartbeat();
-           /* setTimeout(() => {
+            
+            // 保持原有的重连逻辑（被注释掉的）
+            // this.connectRetryCount++;
+            /* setTimeout(() => {
                 this.connect();
             }, 500 * this.connectRetryCount);*/
-
-
         };
 
+        // 连接错误事件
         this.ws.onerror = () => {
             ElMessage.error("webSocket连接异常！");
-
-
+            this.connectionStatus = ConnectionStatus.ERROR;
         };
 
+        // 消息接收事件
+        this.ws.onmessage = (event: MessageEvent) => {
+            this.handleMessage(event);
+        };
+    }
 
-        // 得到服务端发送过来的数据
-        this.ws.onmessage = (event) => {
-            // console.log('🚀 ~ SocketService ~ connect ~ event:', event)
-            if(event.data == 'over') {
-                //心跳消息处理
-                this.lastResponseHeartTime = Date.now();
-                this.updateLastActivityTime(); // 收到心跳响应时更新活动时间
-            }else {
-                let message: { [key: string]: any };
-                try {
-                    console.log('Received message:',event.data)
-                    message = JSON.parse(event.data);
-                } catch (e) {
-                    return console.error("消息解析失败", event.data, e);
-                }
+    /**
+     * 处理接收到的消息
+     * 支持心跳响应、JSON消息和普通文本消息
+     * @param event WebSocket消息事件
+     */
+    private handleMessage(event: MessageEvent): void {
+        // console.log('Received message:', event.data);
+        
+        // 心跳响应处理
+        if (event.data === 'over') {
+            console.log(`${new Date().toLocaleTimeString()} - 收到心跳响应`);
+            this.lastResponseHeartTime = Date.now();
+            return;
+        }
 
-                /* 通过接受服务端发送的type字段来回调函数 */
+        // 检查消息是否为空或无效
+        if (!event.data || event.data.trim() === '') {
+            console.warn('收到空消息，跳过处理');
+            return;
+        }
+
+        // 业务消息处理
+        try {
+            // 检查是否为JSON格式
+            if (typeof event.data === 'string' && (event.data.startsWith('{') || event.data.startsWith('['))) {
+                const message: WebSocketMessage = JSON.parse(event.data);
                 if (message?.type && this.callBackMapping[message.type]) {
                     this.callBackMapping[message.type](message);
                 } else {
-                    console.log("抛弃====>")
-                    console.log(event.data)
-                    /* 丢弃或继续写你的逻辑 */
+                    console.warn('未找到对应的消息处理器:', message.type);
+                }
+            } else {
+                // 非JSON格式的消息，作为普通文本处理
+                console.log('收到非JSON格式消息:', event.data);
+                // 可以添加文本消息的处理逻辑
+                if (this.callBackMapping['text']) {
+                    this.callBackMapping['text']({ 
+                        type: 'text', 
+                        data: event.data 
+                    });
                 }
             }
-
-
-        };
-    }
-
-
-
-
-
-    startHeartbeat() {
-        this.lastResponseHeartTime = Date.now();
-        const  _this = this
-        _this.workerBlobUrl  = window.URL.createObjectURL(new Blob(['(function(e){setInterval(function(){this.postMessage(null)},9000)})()']));
-
-        this.work = new Worker(_this.workerBlobUrl);
-        this.work.onmessage = function(e){
-            //判断多久没收到心跳响应
-
-            if(_this.lastActivityTime - _this.lastResponseHeartTime > 30000){
-                //说明已经三轮心跳没收到回复了，关闭检测，提示用户。
-                ElMessage.error("业务主体模块发生未知异常，请尝试重新启动！");
-                _this.clearHeartbeat();
-                return;
-            }
-            _this.sendHeartbeat();
-		}
-
-    }
-    sendHeartbeat() {
-        console.log(new Date()+"进入心跳消息发送。。。。。。。。。。。。。")
-        this.ws.send('alive');
-        this.updateLastActivityTime(); // 发送心跳后更新活动时间
-    }
-
-
-    updateLastActivityTime() {
-        this.lastActivityTime = Date.now();
-    }
-
-    clearHeartbeat() {
-        const  _this = this
-        if (_this.work) {
-            _this.work.terminate();
-            _this.work = null;
-        }
-        if (_this.workerBlobUrl) {
-            window.URL.revokeObjectURL(_this.workerBlobUrl); // 释放临时的Blob URL
-            _this.workerBlobUrl = null;
+            
+        } catch (error) {
+            console.error('消息解析失败:', event.data, error);
+            console.error('消息类型:', typeof event.data);
+            console.error('消息长度:', event.data?.length || 0);
         }
     }
 
+    // ========================================================================
+    // 重连机制相关方法
+    // ========================================================================
 
+    /**
+     * 尝试重新连接WebSocket
+     */
+    private attemptReconnect(): void {
+        if (this.connectionStatus === ConnectionStatus.RECONNECTING) {
+            return;
+        }
 
-    // 回调函数的注册
-    registerCallBack(socketType, callBack) {
-        this.callBackMapping[socketType] = callBack;
-    }
-    // 取消某一个回调函数
-    unRegisterCallBack(socketType) {
-        this.callBackMapping[socketType] = null;
-    }
-    // 发送数据的方法
-    send(data) {
-        // 判断此时此刻有没有连接成功
-        if (this.connected) {
-            this.sendRetryCount = 0;
+        this.connectionStatus = ConnectionStatus.RECONNECTING;
+        this.connectRetryCount++;
+        
+        const delay = this.config.reconnectDelay! * this.connectRetryCount;
+        
+        console.log(`尝试第${this.connectRetryCount}次重连，${delay}ms后开始...`);
+        
+        setTimeout(() => {
             try {
-                this.ws.send(JSON.stringify(data));
-            } catch (e) {
-                this.ws.send(data);
+                const result = this.connect();
+                if (result instanceof Promise) {
+                    result.catch((error: any) => {
+                        console.error('重连失败:', error);
+                    });
+                }
+            } catch (error: any) {
+                console.error('重连失败:', error);
             }
-        } else {
-            this.sendRetryCount++;
-            setTimeout(() => {
-                this.send(data);
-            }, this.sendRetryCount * 500);
+        }, delay);
+    }
+
+    // ========================================================================
+    // 心跳机制相关方法
+    // ========================================================================
+
+    /**
+     * 启动心跳机制
+     */
+    private startHeartbeat(): void {
+        this.lastResponseHeartTime = Date.now();
+        this.createHeartbeatWorker();
+    }
+
+    /**
+     * 创建心跳Worker
+     * 使用Worker在独立线程中处理心跳定时器，避免主线程阻塞
+     */
+    private createHeartbeatWorker(): void {
+        try {
+            // 创建Worker脚本
+            const workerScript = `
+                setInterval(function() {
+                    postMessage('heartbeat');
+                }, ${this.config.heartbeatInterval});
+            `;
+            
+            this.workerBlobUrl = window.URL.createObjectURL(
+                new Blob([workerScript], { type: 'application/javascript' })
+            );
+            
+            this.heartbeatWorker = new Worker(this.workerBlobUrl);
+            
+            // 心跳Worker消息处理
+            this.heartbeatWorker.onmessage = (event: MessageEvent) => {
+                this.handleHeartbeatTick();
+            };
+            
+            // Worker错误处理
+            this.heartbeatWorker.onerror = (error: ErrorEvent) => {
+                console.error('心跳Worker错误:', error);
+                this.clearHeartbeat();
+            };
+            
+        } catch (error) {
+            console.error('创建心跳Worker失败:', error);
         }
     }
 
-    // 断开方法
-    closeWs() {
-        if (this.connected) {
-            this.ws.close()
+    /**
+     * 处理心跳定时器事件
+     * 检查连接超时并发送心跳消息
+     */
+    private handleHeartbeatTick(): void {
+        // 检查是否超时（距离上次收到心跳响应的时间）
+        const timeSinceLastResponse = Date.now() - this.lastResponseHeartTime;
+        
+        if (timeSinceLastResponse > this.config.timeout!) {
+            console.error(`WebSocket心跳超时: ${timeSinceLastResponse}ms > ${this.config.timeout}ms`);
+            ElMessage.error("WebSocket连接超时，请检查网络连接！");
+            this.clearHeartbeat();
+            this.closeWs();
+            return;
         }
-        console.log('执行WS关闭命令..');
+        
+        this.sendHeartbeat();
     }
-}
+
+    /**
+     * 发送心跳消息到服务器
+     */
+    private sendHeartbeat(): void {
+        if (this.connected && this.ws) {
+            console.log(`${new Date().toLocaleTimeString()} - 发送心跳消息`);
+            this.ws.send('alive');
+        }
+    }
+
+    /**
+     * 清理心跳机制
+     * 终止Worker并清理相关资源
+     */
+    private clearHeartbeat(): void {
+        if (this.heartbeatWorker) {
+            this.heartbeatWorker.terminate();
+            this.heartbeatWorker = null;
+        }
+        
+        if (this.workerBlobUrl) {
+            window.URL.revokeObjectURL(this.workerBlobUrl);
+            this.workerBlobUrl = null;
+        }
+    }
+}

frontend/src/views/authority/resource/components/resourcePopup.vue

@@ -1,5 +1,5 @@
 <template>
-    <el-dialog :title="dialogTitle" :model-value="dialogVisible" @close="close" v-bind="dialogMiddle">
+    <el-dialog :title="dialogTitle" :model-value="dialogVisible" @close="close" v-bind="dialogMiddle" align-center>
       <el-form :model="formContent" ref='dialogFormRef' :rules='rules' class="form-two">
         <el-form-item label="上级菜单" prop="pid" :label-width="100">
           <el-tree-select

frontend/src/views/authority/role/components/rolePopup.vue

@@ -1,6 +1,6 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogSmall" @close="close" >
+  <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogSmall" @close="close" align-center>
     <div>
 
         <el-form :model="formContent" 

frontend/src/views/authority/role/components/roleResourcePopup.vue

@@ -1,6 +1,6 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog :model-value="dialogVisible" :title="dialogTitle"  v-bind="dialogMiddle" @close="close" >
+  <el-dialog :model-value="dialogVisible" :title="dialogTitle"  v-bind="dialogMiddle" @close="close" align-center>
     <div>
         <el-form :model="formContent" ref='dialogFormRef'>
       <el-tree

frontend/src/views/authority/user/components/passWordPopup.vue

@@ -1,6 +1,6 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog v-model='dialogVisible' :title="dialogTitle" v-bind="dialogSmall" @close="close">
+  <el-dialog v-model='dialogVisible' :title="dialogTitle" v-bind="dialogSmall" @close="close" align-center>
     <div>
         <el-form :model="formContent"
                   ref='dialogFormRef'

frontend/src/views/authority/user/components/userPopup.vue

@@ -1,6 +1,6 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog v-model='dialogVisible' :title="dialogTitle" v-bind="dialogSmall" @close="close" >
+  <el-dialog v-model='dialogVisible' :title="dialogTitle" v-bind="dialogSmall" @close="close" align-center>
     <div>
         <el-form :model="formContent"
                   ref='dialogFormRef'

frontend/src/views/home/components/RemoveableEdge.vue

@@ -0,0 +1,88 @@
+<script setup>
+import { BaseEdge, EdgeLabelRenderer, getBezierPath, useVueFlow } from '@vue-flow/core'
+import { computed } from 'vue'
+import { useCheckStore } from '@/stores/modules/check'
+
+const checkStore = useCheckStore()
+const props = defineProps({
+    id: {
+        type: String,
+        required: true
+    },
+    sourceX: {
+        type: Number,
+        required: true
+    },
+    sourceY: {
+        type: Number,
+        required: true
+    },
+    targetX: {
+        type: Number,
+        required: true
+    },
+    targetY: {
+        type: Number,
+        required: true
+    },
+    sourcePosition: {
+        type: String,
+        required: true
+    },
+    targetPosition: {
+        type: String,
+        required: true
+    },
+    markerEnd: {
+        type: String,
+        required: false
+    },
+    style: {
+        type: Object,
+        required: false
+    }
+})
+
+const { removeEdges } = useVueFlow()
+
+const path = computed(() => getBezierPath(props))
+const edgeStyle = computed(() => ({
+    ...props.style,
+    strokeWidth: 3
+}))
+</script>
+
+<script>
+export default {
+    inheritAttrs: false
+}
+</script>
+
+<template>
+    <BaseEdge :id="id" :style="edgeStyle" :path="path[0]" :marker-end="markerEnd" />
+    <EdgeLabelRenderer>
+        <div
+            :style="{
+                pointerEvents: 'all',
+                position: 'absolute',
+                transform: `translate(-50%, -50%) translate(${path[1]}px,${path[2]}px)`
+            }"
+            class="nodrag nopan"
+        >
+            <el-popconfirm v-if="checkStore.nodesConnectable" title="确定要删除这条连线吗？" @confirm="removeEdges(id)">
+                <template #reference>
+                    <el-icon class="edge-icon"><Delete /></el-icon>
+                </template>
+            </el-popconfirm>
+        </div>
+    </EdgeLabelRenderer>
+</template>
+<style scoped>
+.edge-icon {
+    background: white;
+    border-radius: 50%;
+    padding: 2px;
+    cursor: pointer;
+    box-shadow: 0 0 4px rgba(0, 0, 0, 0.2);
+}
+</style>

frontend/src/views/home/components/channelPairing.vue

@@ -0,0 +1,557 @@
+<template>
+    <div>
+        <div class="flow-container" style="overflow: hidden; position: relative"
+            :style="{ height: vueFlowElement + 'px' }">
+            <!-- <el-button @click="logConnections">打印当前配对</el-button>  -->
+            <VueFlow :nodes="nodes" :edges="edges" :connection-radius="30" :nodes-draggable="false" :dragging="false"
+                :zoom-on-scroll="false" :pan-on-drag="false" :disable-zoom-pan-on-connect="true"
+                :prevent-scrolling="true" :fit-view="true" :min-zoom="1" :max-zoom="1"
+                :nodesConnectable="checkStore.nodesConnectable" :elements-selectable="false" auto-connect
+                @connect="handleConnect" @connect-start="handleConnectStart" @connect-end="handleConnectEnd"
+                @pane-ready="onPaneReady" v-on:pane-mouse-move="false"></VueFlow>
+        </div>
+
+        <!-- 底部操作按钮 -->
+        <!-- <template #footer>
+            <div class="dialog-footer">
+                <el-button @click="dialogVisible = false">取消</el-button>
+                <el-button type="primary" @click="handleNext">下一步</el-button>
+            </div>
+        </template> -->
+        <!-- 手动检测-勾选检测项弹窗 -->
+        <!-- <SelectTestItemPopup ref="selectTestItemPopupRef" @openTestDialog="openTestDialog"></SelectTestItemPopup> -->
+    </div>
+</template>
+
+<script lang="ts" setup>
+import { h, ref, onMounted, PropType } from 'vue'
+import { VueFlow, useVueFlow } from '@vue-flow/core'
+import { dialogBig } from '@/utils/elementBind'
+import { Platform, Flag } from '@element-plus/icons-vue'
+import { Device } from '@/api/device/interface/device'
+import { StandardDevice } from '@/api/device/interface/standardDevice'
+import SelectTestItemPopup from '@/views/home/components/selectTestItemPopup.vue'
+import { ElMessage, stepProps } from 'element-plus'
+import CustomEdge from './RemoveableEdge.vue' // 导入自定义连接线组件
+import { jwtUtil } from '@/utils/jwtUtil'
+import { useCheckStore } from '@/stores/modules/check'
+const vueFlowElement = ref(442)
+const checkStore = useCheckStore()
+const dialogVisible = ref(false)
+const selectTestItemPopupRef = ref<InstanceType<typeof SelectTestItemPopup>>()
+const testPopup = ref()
+const dialogTitle = ref('手动检测')
+const prop = defineProps({
+    devIdList: {
+        type: Array as any,
+        default: []
+    },
+    pqStandardDevList: {
+        type: Array as any,
+        default: []
+    },
+    planIdKey: {
+        type: String,
+        default: ''
+    },
+    deviceMonitor: {
+        type: Map as PropType<Map<string, any[]>>,
+        default: () => new Map()
+    }
+})
+// 计算对话框高度
+const dialogHeight = ref(600)
+
+// 初始化 VueFlow，注册自定义连线类型
+const { edges, setViewport } = useVueFlow({
+    edgeTypes: {
+        default: CustomEdge
+    }
+})
+
+// 初始化时锁定画布位置
+const onPaneReady = () => {
+    setViewport({ x: 0, y: 0, zoom: 1 })
+}
+
+// 提取公共的label渲染函数
+const createLabel = (text: string, type: string, Key: number) => {
+    return h(
+        'div',
+        {
+            style: {
+                display: 'flex',
+                // flexDirection: 'column',
+                alignItems: 'center',
+                fontSize: '15px',
+                height: '75px',
+                // textAlign: 'center',
+                border: '1px solid #ccc',
+                borderRadius: '8px',
+                padding: '8px',
+                backgroundColor: '#f9f9f9'
+            }
+        },
+        [
+            // h(Platform, {
+            //     style: {
+            //         height: '40px',
+            //         marginBottom: '4px',
+            //         color: '#526ade'
+            //     }
+            // }),
+            h('img', {
+                src:
+                    Key == 2
+                        ? new URL('@/assets/images/inspected1.jpg', import.meta.url).href
+                        : new URL('@/assets/images/inspected2.png', import.meta.url).href,
+                // alt: '设备图标',
+                style: {
+                    width: '50px',
+                    marginRight: '5px'
+                    // 保持原有的颜色风格，如果需要可以调整滤镜
+                    // filter: 'invert(35%) sepia(65%) saturate(300%) hue-rotate(210deg)'
+                }
+            }),
+            h('div', { style: { textAlign: 'left' } }, ['设备名称：' + text, h('br'), '设备类型：' + type])
+            // h('div', null, '设备名称：' + text),
+            // h('div', null, '设备类型：' + type)
+        ]
+    ) as any
+}
+
+const createLabel3 = (text: string) => {
+    return h(
+        'div',
+        {
+            style: {
+                display: 'flex',
+                alignItems: 'center',
+                fontSize: '15px',
+                height: '35px',
+                textAlign: 'center',
+                border: '1px solid #ccc',
+                borderRadius: '8px',
+                // padding: '8px',
+                backgroundColor: '#f9f9f9'
+            }
+        },
+        [
+            h('div', {
+                style: {
+                    width: '8px',
+                    marginRight: '4px',
+                    color: '#526ade'
+                }
+            }),
+            text
+        ]
+    ) as any
+}
+
+const handleConnectStart = (params: any) => {
+    onPaneReady()
+}
+
+const handleConnectEnd = (params: any) => {
+    onPaneReady()
+}
+
+const handleConnect = (params: any) => {
+    console.log('连接信息:', params)
+    const sourceNode = nodes.value.find(node => node.id === params.source)
+    const targetNode = nodes.value.find(node => node.id === params.target)
+
+    // 连接规则验证
+    const isValidConnection = sourceNode?.type === 'input' && targetNode?.type === 'output'
+
+    if (!isValidConnection) {
+        removeEdge(params)
+        ElMessage.warning('只能从被检通道连接到标准通道')
+        return
+    }
+
+    // 过滤掉当前连接，检查是否还有重复的
+    const existingEdges = edges.value.filter(edge => edge.source === params.source || edge.target === params.target)
+
+    // 如果同源或同目标的连接超过1个，说明有重复
+    if (existingEdges.length > 1) {
+        const duplicateSource = existingEdges.filter(edge => edge.source === params.source).length > 1
+        const duplicateTarget = existingEdges.filter(edge => edge.target === params.target).length > 1
+
+        if (duplicateSource) {
+            removeEdge(params)
+            ElMessage.warning('该被检通道已经连接，不能重复连接')
+            return
+        }
+
+        if (duplicateTarget) {
+            removeEdge(params)
+            ElMessage.warning('该标准通道已经连接，不能重复连接')
+            return
+        }
+    }
+}
+
+// 删除不合法连接
+const removeEdge = (params: any) => {
+    const edgeIndex = edges.value.findIndex(edge => edge.source === params.source && edge.target === params.target)
+    if (edgeIndex !== -1) {
+        edges.value.splice(edgeIndex, 1)
+    }
+}
+
+const nodes = ref([])
+const planId = ref('')
+const devIds = ref<string[]>()
+const standardDevIds = ref<string[]>()
+
+const open = async () => {
+    console.log('开始打开通道配对')
+    edges.value = []
+    devIds.value = prop.devIdList.map(d => d.id)
+    standardDevIds.value = prop.pqStandardDevList.map(d => d.id)
+    planId.value = prop.planIdKey
+
+    nodes.value = createNodes(prop.devIdList, prop.pqStandardDevList, prop.deviceMonitor)
+    dialogVisible.value = true
+    onPaneReady()
+}
+
+onMounted(() => {
+    open()
+})
+const handleNext = async () => {
+    if (edges.value.length === 0) {
+        ElMessage.warning('请先完成通道配对')
+        return false
+    }
+    // const sourceKey = edge.source.replace('被检通道-', '').replace('-', '_');
+    let chnNumList: string[] = []
+    await edges.value.forEach(edge => {
+        const match = edge.source.split('-')
+
+        if (match) {
+            chnNumList.push(match[2])
+        }
+    })
+    const connections = edges.value.reduce(
+        (map, edge) => {
+            // 从source中提取设备ID和通道号: 被检通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const sourceKey = edge.source.replace('被检通道-', '').replace('-', '_')
+
+            // 从target中提取设备ID和通道号: 标准通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const targetValue = edge.target.replace('标准通道-', '').replace('-', '_')
+
+            map[sourceKey] = targetValue
+            return map
+        },
+        {} as Record<string, string>
+    )
+    await generateChannelMapping()
+
+    await checkStore.setChnNum(chnNumList)
+    return {
+        title: dialogTitle.value,
+        mapping: channelMapping.value,
+        plan: planId.value,
+        login: jwtUtil.getLoginName(),
+        devIdsArray: devIds.value,
+        standardDevIdsArray: standardDevIds.value,
+        pair: connections
+    }
+}
+
+const openTestDialog = async () => {
+    // 转换连接信息，只保留设备ID和通道号
+    const connections = edges.value.reduce(
+        (map, edge) => {
+            // 从source中提取设备ID和通道号: 被检通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const sourceKey = edge.source.replace('被检通道-', '').replace('-', '_')
+
+            // 从target中提取设备ID和通道号: 标准通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const targetValue = edge.target.replace('标准通道-', '').replace('-', '_')
+
+            map[sourceKey] = targetValue
+            return map
+        },
+        {} as Record<string, string>
+    )
+
+    generateChannelMapping()
+
+    setTimeout(() => {
+        testPopup.value?.open(
+            dialogTitle.value,
+            channelMapping.value,
+            planId.value,
+            jwtUtil.getLoginName(),
+            devIds.value,
+            standardDevIds.value,
+            connections
+        )
+    }, 100)
+}
+
+// 转换 edges.value 为 channelMapping 格式
+const channelMapping = ref<Record<string, Record<string, string>>>({})
+
+// 生成映射关系的方法
+const generateChannelMapping = () => {
+    const mapping: Record<string, Record<string, string>> = {}
+
+    edges.value.forEach(edge => {
+        // 解析 source 节点信息（被检通道）
+        const sourceParts = edge.source.split('-')
+        const sourceDeviceId = sourceParts[1]
+        const sourceChannel = sourceParts[2]
+
+        // 解析 target 节点信息（标准通道）
+        const targetParts = edge.target.split('-')
+        const targetDeviceId = targetParts[1]
+        const targetChannel = targetParts[2]
+
+        // 查找对应的节点以获取显示名称
+        const sourceDeviceNode = nodes.value.find(node => node.id === sourceDeviceId)
+
+        const targetDeviceNode = nodes.value.find(node => node.id === targetDeviceId)
+
+        if (sourceDeviceNode && targetDeviceNode) {
+            // 提取设备显示文本
+            const sourceDeviceText = sourceDeviceNode.data.label.children[1].children[0].children
+            const targetDeviceText = targetDeviceNode.data.label.children[1].children[0].children
+
+            // 构造键名 - 现在以标准设备为键
+            const targetKey = `${targetDeviceText}`.replace('设备名称：', '')
+            const sourceValue = `${sourceDeviceText}通道${sourceChannel}`.replace('设备名称：', '')
+
+            // 初始化对象
+            if (!mapping[targetKey]) {
+                mapping[targetKey] = {}
+            }
+
+            // 添加映射关系 - 标准设备通道 -> 被检设备信息
+            mapping[targetKey][`通道${targetChannel}`] = sourceValue
+        }
+    })
+
+    channelMapping.value = mapping
+}
+
+const createNodes = (device: Device.ResPqDev[], standardDev: StandardDevice.ResPqStandardDevice[], deviceMonitor: Map<string, any[]>) => {
+    const channelCounts: Record<string, number> = {}
+    device.forEach(device => {
+        channelCounts[device.id] = device.devChns || 0
+    })
+
+    const inspectionDevices = device.map(d => ({
+        id: d.id,
+        name: d.name,
+        type: 'normal',
+        deviceType: d.devType
+    }))
+
+    const channelCounts2: Record<string, number> = {}
+    standardDev.forEach(dev => {
+        const channelList = dev.inspectChannel ? dev.inspectChannel.split(',') : []
+        channelCounts2[dev.id] = channelList.length
+    })
+
+    const standardDevices = standardDev.map(d => ({
+        id: d.id,
+        name: d.name,
+        type: 'normal',
+        deviceType: d.devType
+    }))
+
+    const newNodes: any[] = []
+    const deviceChannelGroups: { deviceId: string; centerY: number }[] = []
+    const standardChannelGroups: any[] = []
+
+    const deviceWidth = 50
+    const inputChannelX = 350
+    const outputChannelX = 1050
+    const standardWidth = 1170
+
+    // 添加被检通道
+    // let currentYPosition = 50; // 初始Y位置
+    let actualChannelsTotalLength = 0;
+
+    for (const [deviceId, count] of Object.entries(channelCounts)) {
+        // 直接计算当前设备的通道数并累加，无需完整构建数组
+        actualChannelsTotalLength += deviceMonitor.has(deviceId)
+            ? (deviceMonitor.get(deviceId) || []).length
+            : count;
+    }
+
+    let currentYPosition = (vueFlowElement.value - 60 * actualChannelsTotalLength) / 2; // 初始Y位置
+    const deviceSpacing = 30; // 设备间的垂直间距
+
+    Object.entries(channelCounts).forEach(([deviceId, count]) => {
+        // 从deviceMonitor中获取实际通道信息
+        let actualChannels = []; // 存储实际的通道号
+
+        // 如果deviceMonitor中有该设备的数据，则使用实际监测点信息
+        if (deviceMonitor.has(deviceId)) {
+            const monitorPoints = deviceMonitor.get(deviceId) || [];
+            // 提取监测点的num值作为通道号
+            actualChannels = monitorPoints.map(point => point.num);
+            //console.log('deviceId', deviceId, '实际通道号:', actualChannels, '监测点:', monitorPoints);
+        } else {
+            // 如果没有monitor数据，默认使用连续的通道号
+            actualChannels = Array.from({ length: count }, (_, i) => i + 1);
+        }
+
+        const yPosition = currentYPosition;
+        // 遍历实际通道号而不是连续的数字
+        actualChannels.forEach((channelNum, index) => {
+            const channelId = `被检通道-${deviceId}-${channelNum}`;
+            newNodes.push({
+                id: channelId,
+                type: 'input',
+                data: { label: createLabel3(`被检通道${channelNum}`) },
+                position: { x: inputChannelX, y: yPosition + index * 50 },
+                sourcePosition: 'right',
+                style: { width: '120px', border: 'none', boxShadow: 'none' }
+            });
+
+            deviceChannelGroups.push({
+                deviceId,
+                centerY: 0
+            });
+        });
+
+        // 更新currentYPosition，为下一台设备留出空间
+        // 每台设备需要的空间 = 实际通道数 * 50 + 设备间距
+        currentYPosition += actualChannels.length * 50 + deviceSpacing;
+    });
+
+    // 添加标准通道
+    // let currentYPosition2 = 50; // 初始Y位置
+    let totalCount = 0;
+    // 遍历所有条目并累加 count 值
+    Object.entries(channelCounts2).forEach(([deviceId, count]) => {
+        totalCount += count;
+    });
+
+    let currentYPosition2 = (vueFlowElement.value - 60 * totalCount) / 2; // 初始Y位置; // 初始Y位置
+    const standardDeviceSpacing = 30; // 标准设备间的垂直间距
+
+    Object.entries(channelCounts2).forEach(([deviceId, count]) => {
+        const yPosition2 = currentYPosition2;
+
+        for (let i = 1; i <= count; i++) {
+            const channelId = `标准通道-${deviceId}-${i}`;
+            newNodes.push({
+                id: channelId,
+                type: 'output',
+                data: { label: createLabel3(`标准通道${i}`) },
+                position: { x: outputChannelX, y: yPosition2 + (i - 1) * 50 },
+                targetPosition: 'left',
+                style: { width: '120px', border: 'none', boxShadow: 'none' }
+            });
+
+            standardChannelGroups.push({
+                deviceId,
+                centerY: 0
+            });
+        }
+
+        // 更新currentYPosition2，为下一台标准设备留出空间
+        currentYPosition2 += count * 50 + standardDeviceSpacing;
+    });
+
+
+
+
+    // 添加被检设备
+    // let deviceCurrentYPosition = 50; // 与通道计算保持一致的初始位置
+    let deviceCurrentYPosition = (vueFlowElement.value - 60 * actualChannelsTotalLength) / 2;  // 与通道计算保持一致的初始位置
+    let lastDeviceId = ''; // 记录上一个处理的设备ID
+
+    deviceChannelGroups.forEach(({ deviceId, centerY }) => {
+        const device = inspectionDevices.find(d => d.id === deviceId)
+        if (device) {
+            // 只有当设备ID变化时才计算新位置
+            if (lastDeviceId !== deviceId) {
+                // 计算该设备对应的实际通道数量
+                let actualChannelCount = channelCounts[deviceId] || 0;
+
+                // 如果deviceMonitor中有该设备的数据，则使用实际监测点数量
+                if (deviceMonitor.has(deviceId)) {
+                    const monitorPoints = deviceMonitor.get(deviceId) || [];
+                    actualChannelCount = monitorPoints.length;
+                }
+
+                // 计算设备高度居中位置 - 基于该设备组的实际位置
+                const deviceCenterY = deviceCurrentYPosition + (actualChannelCount * 50) / 2 - 50
+                newNodes.push({
+                    id: device.id,
+                    data: { label: createLabel(device.name, device.deviceType, 1) },
+                    position: { x: deviceWidth, y: deviceCenterY },
+                    class: 'no-handle-node',
+                    style: { width: '300px', border: 'none', boxShadow: 'none' }
+                })
+
+                // 更新位置为下一台设备的起始位置
+                deviceCurrentYPosition += actualChannelCount * 50 + 30
+                // 更新上一个设备ID
+                lastDeviceId = deviceId
+            }
+        }
+    })
+
+
+
+
+
+
+    // 添加标准设备
+    // let standardDeviceCurrentYPosition = 50; // 与标准通道计算保持一致的初始位置
+    let standardDeviceCurrentYPosition = (vueFlowElement.value - 60 * totalCount) / 2; // 与标准通道计算保持一致的初始位置
+    let lastStandardDeviceId = ''; // 记录上一个处理的标准设备ID
+
+    standardChannelGroups.forEach(({ deviceId, centerY }) => {
+        const device = standardDevices.find(d => d.id === deviceId)
+        if (device) {
+            // 只有当设备ID变化时才计算新位置
+            if (lastStandardDeviceId !== deviceId) {
+                // 计算该标准设备对应的通道数量
+                const channelCount = channelCounts2[deviceId] || 0
+                // 计算设备高度居中位置 - 基于该设备组的实际位置
+                const deviceCenterY = standardDeviceCurrentYPosition + (channelCount * 50) / 2 - 50
+                newNodes.push({
+                    id: device.id,
+                    data: { label: createLabel(device.name, device.deviceType, 2) },
+                    position: { x: standardWidth, y: deviceCenterY },
+                    class: 'no-handle-node',
+                    style: { width: '300px', border: 'none', boxShadow: 'none' }
+                })
+
+                // 更新位置为下一台标准设备的起始位置
+                standardDeviceCurrentYPosition += channelCount * 50 + 30
+                // 更新上一个标准设备ID
+                lastStandardDeviceId = deviceId
+            }
+        }
+    })
+
+    //页面高度取决于设备通道
+    // dialogHeight.value = Math.max(yPosition.value, yPosition2.value)
+
+    return newNodes
+}
+
+defineExpose({ open, handleNext })
+</script>
+
+<style>
+.flow-container {
+    width: 100%;
+    overflow: hidden;
+}
+
+.vue-flow__node.no-handle-node .vue-flow__handle {
+    display: none !important;
+}
+</style>

frontend/src/views/home/components/channelsTest.vue

@@ -1,999 +0,0 @@
-<template>
-  <el-dialog v-model='dialogVisible' title="系数校准" v-bind="dialogBig" width="1550px" @close="handleCancel" :before-close="beforeClose">
-    <div class="test-dialog">
-      <div class="dialog-content">
-        <div class="right-title">
-          <!-- <div>系数校准表</div> -->
-          <div>{{ outputDsc }}</div>
-          <div>
-            <span style="  font-size: 18px;font-weight: 600;">
-              设备已合格 <span style="color: #91cc75">{{ qualified }}</span> 台/共 <span style="color: green">{{ total }}</span>
-              台
-            </span>
-            <!-- <el-button type="primary" loading
-              v-if="activeIndex > 0 && activeIndex < activeTotalNum">通道系数已校准3台/共3台</el-button>
-            <el-button type="primary" :disabled="true" v-if="activeIndex === activeTotalNum">通道系数已校准3台/共3台</el-button> -->
-          </div>
-        </div>
-        <div class="container">
-          <div class="dialog-left">
-            <el-steps direction="vertical" :active="active" :process-status="currentStepStatus" finish-status="success">
-              <el-step title="开始"/>
-              <el-step>
-                <template #title>
-                  <span>大电压/电流系数下装</span><br/>
-                  <span class="spanStyle">源输出为：</span><br/>
-                  <span class="spanStyle" v-if="active > 0">{{ big_V_Download }}</span><br/>
-                  <span class="spanStyle" v-if="active > 0">{{ big_I_Download }}</span>
-                  <el-icon v-if="active === 1 " class="loading-box">
-                    <el-icon-loading/>
-                  </el-icon>
-                </template>
-              </el-step>
-              <el-step>
-                <template #title>
-                  <span>小电压/电流系数下装</span><br/>
-                  <span class="spanStyle">源输出为：</span><br/>
-                  <span class="spanStyle" v-if="active > 1">{{ small_V_Download }}</span><br/>
-                  <span class="spanStyle" v-if="active > 1">{{ small_I_Download }}</span>
-                  <el-icon v-if="active === 2" class="loading-box">
-                    <el-icon-loading/>
-                  </el-icon>
-                </template>
-              </el-step>
-              <el-step>
-                <template #title>
-                  <span>大电压/电流校准</span><br/>
-                  <span class="spanStyle">源输出为：</span><br/>
-                  <span class="spanStyle" v-if="active > 2">{{ big_V_Adjust }}</span><br/>
-                  <span class="spanStyle" v-if="active > 2">{{ big_I_Adjust }}</span>
-                  <el-icon v-if="active === 3" class="loading-box">
-                    <el-icon-loading/>
-                  </el-icon>
-                </template>
-              </el-step>
-              <el-step>
-                <template #title>
-                  <span>小电压/电流校准</span><br/>
-                  <span class="spanStyle">源输出为：</span><br/>
-                  <span class="spanStyle" v-if="active > 3">{{ small_V_Adjust }}</span><br/>
-                  <span class="spanStyle" v-if="active > 3">{{ small_I_Adjust }}</span>
-                  <el-icon v-if="active === 4" class="loading-box">
-                    <el-icon-loading/>
-                  </el-icon>
-                </template>
-              </el-step>
-              <el-step title="结束"/>
-            </el-steps>
-          </div>
-          <div class="right-content">
-            <el-tabs type="border-card" v-model="editableTabsValue" :active-index="String(activeIndex)">
-              <el-tab-pane v-for="(device, index) in name" :key="index" :label="device">
-                <template #label>
-                    <span class="custom-tabs-label">
-                      <span>{{ device }}</span>
-                      <el-icon v-if="errorStates[index]" class="icon-style">
-                        <Failed/>
-                      </el-icon>
-                    </span>
-                </template>
-                <channelsTestTable
-                    :tableData="getTableDataForChannel(index)"
-                    :big_V_loading="big_V_loadingStates"
-                    :curV="CurV">
-                </channelsTestTable>
-              </el-tab-pane>
-            </el-tabs>
-          </div>
-        </div>
-      </div>
-    </div>
-    <template #footer>
-      <div class="dialog-footer">
-        <el-button type="primary" @click="handleSubmit" :disabled="isButtonDisabled">开始系数校准</el-button>
-      </div>
-    </template>
-  </el-dialog>
-
-</template>
-<script lang="tsx" setup name="channelsTest">
-import {type Device} from '@/api/device/interface/device';
-import {Failed} from '@element-plus/icons-vue'
-import {type Ref, ref, toRef, watch} from 'vue'
-import {dialogBig} from '@/utils/elementBind'
-import {ElMessageBox} from 'element-plus';
-import {getCoefficientCheck} from '@/api/home/channelsTest/index'
-import type {ChannelsTest} from '@/api/home/interface/channelsTest';
-import type {Plan} from '@/api/plan/interface';
-import {useUserStore} from "@/stores/modules/user";
-
-
-const activeIndex = ref(0)
-const activeTotalNum = ref(4)
-const qualified = ref(0)
-const outputDsc = ref('电压误差为：±0.1Un%； 电流误差为：±0.5%')
-const total = ref(0)
-const dialogVisible = ref(false)
-const active = ref(0)
-let timer1: NodeJS.Timeout | null = null; // 声明并初始化 timer1
-let timer2: NodeJS.Timeout | null = null; // 同样声明并初始化 timer2
-const name = ref<string[]>([])//系数校准所选设备名字数组
-const channel = ref<number[]>([])//系数校准所选设备通道数组
-const devIdArray = ref<string[]>([])//系数校准所选设备ID数组
-const select_Plan = ref<Plan.ReqPlan>()
-const planId = ref('')
-const isButtonDisabled = ref(false);
-const CurV = ref<number>()//额定电压
-// 在 setup 函数中
-const errorStates = ref(new Array(name.value.length).fill(false));
-//const loadingStates = ref(new Array(name.value.length).fill(false)); // 初始化 loading 状态
-const big_V_loadingStates = ref(false); // 初始化 大电压大电流下装loading 状态
-const small_V_loadingStates = ref(false); // 初始化 小电压小电流下装loading 状态
-const big_V_loadingStates2 = ref(false); // 初始化 大电压大电流校准loading 状态
-const small_V_loadingStates2 = ref(false); // 初始化 小电压小电流校准loading 状态
-const editableTabsValue = ref('0')
-const big_V_Download = ref('')
-const big_I_Download = ref('')
-const small_V_Download = ref('')
-const small_I_Download = ref('')
-const big_V_Adjust = ref('')
-const big_I_Adjust = ref('')
-const small_V_Adjust = ref('')
-const small_I_Adjust = ref('')
-const props = defineProps({
-  webMsgSend: {
-    type: Object,
-    default: () => ({})
-  }
-})
-const userStore = useUserStore()
-const tableDataMap = new Map<number, Ref<ChannelsTest.CoefficientVO[]>>([]);
-const currentStepStatus = ref<'error' | 'finish' | 'wait' | 'success' | 'process'>('finish');
-const webMsgSend = toRef(props, 'webMsgSend');
-
-watch(webMsgSend, function (newValue, oldValue) {
-  if (newValue.code == 10520) {
-    ElMessageBox.alert('报文解析异常！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10521) {
-    ElMessageBox.alert('程控源參数有误！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10522) {
-    ElMessageBox.alert('测试项解析有误！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10523) {
-    ElMessageBox.alert('源连接失败！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10524) {
-    ElMessageBox.alert('获取源控制权失败！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10525) {
-    ElMessageBox.alert('重置源失败！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10527) {
-    ElMessageBox.alert('源未进行初始化！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10528) {
-    ElMessageBox.alert('目标源有误(该用户已控制其他源，在关闭前无法操作新的源)！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10529) {
-    ElMessageBox.alert('源状态有误，无法响应报文(例如源处于输出状态，无法响应初始化报文)！', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10550) {
-    ElMessageBox.alert(`${newValue.data}设备连接异常！`, '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10551) {
-    ElMessageBox.alert(`${newValue.data}设备触发报告异常！`, '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else if (newValue.code == 10552) { //todo 10552之后还会发送消息吗？
-    ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
-      confirmButtonText: '确定',
-      type: 'error',
-    })
-    TableInit();
-  } else {
-    switch (newValue.requestId) {
-      case 'yjc_ytxjy':
-        switch (newValue.operateCode) {
-          case'INIT_GATHER':
-            if (newValue.code == -1) {
-              ElMessageBox.alert('源未知异常', '初始化失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            } else if (newValue.code == 10523) {
-              ElMessageBox.alert('源连接失败', '源连接失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-        }
-        break;
-      case 'YJC_xujy':
-        switch (newValue.operateCode) {
-          case 'OPER_GATHER':
-            if (newValue.code == 10552) {
-              ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            } else if (newValue.code == 10520) {
-              ElMessageBox.alert('解析报文异常,执行自动关闭,请重新发起检测', '解析报文异常', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-            break;
-          case 'DATA_REQUEST$02':
-            if (newValue.code == 25003) {
-              ElMessageBox.alert('相序校验未通过,执行自动关闭,请重新发起检测', '相序校验未通过', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-            break;
-        }
-        break;
-      case 'yjc_sbtxjy':
-        switch (newValue.operateCode) {
-          case 'INIT_GATHER$01':
-            if (newValue.code == 10550) {
-              ElMessageBox.alert('设备连接异常', '设备连接异常', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            } else if (newValue.code == 10551) {
-              ElMessageBox.alert('设备触发报告异常', '设备触发报告异常', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            } else if (newValue.code == 10552) {
-              ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            } else if (newValue.code == 10520) {
-              ElMessageBox.alert('解析报文异常,执行自动关闭,请重新发起检测', '解析报文异常', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-
-            break;
-        }
-        break;
-      case 'yjc_xyjy':
-        switch (newValue.operateCode) {
-          case 'VERIFY_MAPPING$01':
-            if (newValue.code == 10200) {
-              let data = JSON.parse(newValue.data)
-              ElMessageBox.alert(`脚本与icd检验失败! icd名称：${data['icdType']} -> 校验项：${data['dataType']}`, '初始化失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-            if (newValue.code == 10500) {
-              ElMessageBox.alert(`装置中未找到该icd！`, '初始化失败', {
-                confirmButtonText: '确定',
-                type: 'error',
-              })
-              TableInit();
-            }
-            break;
-        }
-        break;
-      case 'Coefficient_Check':
-        console.log("Coefficient_Checkactive", active.value);
-        switch (newValue.operateCode) {
-          case 'big_start'://大电压,电流下装
-            big_V_Download.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
-            big_I_Download.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
-            break;
-          case 'big_end'://大电压,电流下装
-            active.value++;
-            tableLoading('small', '系数下装')
-            break;
-        }
-        switch (newValue.operateCode) {
-          case 'small_start'://小电压,电流下装
-            small_V_Download.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
-            small_I_Download.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
-            break;
-          case 'small_end'://小电压,电流下装
-            active.value++;
-            tableLoading('big', '系数校准')
-            break;
-        }
-        switch (newValue.operateCode) {
-          case 'big_comp_start'://大电压,电流校准
-            big_V_Adjust.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
-            big_I_Adjust.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
-            break;
-          case 'big_comp_end'://大电压,电流校准
-            active.value++;
-            tableLoading('small', '系数校准')
-            break;
-        }
-        switch (newValue.operateCode) {
-          case 'small_comp_start'://小电压,电流校准
-            small_V_Adjust.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
-            small_I_Adjust.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
-            break;
-          case 'small_comp_end'://小电压,电流校准
-            active.value++;
-            active.value++;
-
-            for (let i = 0; i < name.value.length; i++) {
-              const currentDataRef = tableDataMap.get(i);
-              if (currentDataRef) {
-                const currentData = currentDataRef.value;
-                // 检查当前数据中有无不合格字段
-                const hasError = checkForErrors(currentData);
-                if (hasError) {
-                } else {
-                  qualified.value++;
-                }
-                updateErrorState(i, hasError);
-              }
-            }
-
-            //editableTabsValue.value = (tabNumber.value).toString();//显示下一个tab
-            isButtonDisabled.value = false; // 恢复按钮
-            break;
-        }
-        switch (newValue.operateCode) {
-          case 'DATA_CHNFACTOR$02'://表格
-            // 输出 key 为 0 的数组中的第一条 ChannelsTest.CoefficientVO 对象
-            for (let i = 0; i < name.value.length; i++) {
-              const targetArrayRef = tableDataMap.get(i);
-              if (targetArrayRef) {
-                const targetArray = targetArrayRef.value;
-                if (targetArray.length > 0) {
-                  const firstCoefficientVO = targetArray.find(item => item.monitorNum === newValue.data.monitorNum &&
-                      item.type === newValue.data.type &&
-                      item.desc === newValue.data.desc &&
-                      item.devName === newValue.data.devName);
-                  if (firstCoefficientVO) { // 检查 firstCoefficientVO 是否存在
-                    firstCoefficientVO.aVuData = parseFloat(newValue.data.aVuData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.aVuXi)) && isFinite(newValue.data.aVuXi)) {
-                      firstCoefficientVO.aVuXi = (parseFloat(newValue.data.aVuXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.aVuXi = newValue.data.aVuXi;
-                    }
-
-                    firstCoefficientVO.bVuData = parseFloat(newValue.data.bVuData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.bVuXi)) && isFinite(newValue.data.bVuXi)) {
-                      firstCoefficientVO.bVuXi = (parseFloat(newValue.data.bVuXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.bVuXi = newValue.data.bVuXi;
-                    }
-
-                    firstCoefficientVO.cVuData = parseFloat(newValue.data.cVuData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.cVuXi)) && isFinite(newValue.data.cVuXi)) {
-                      firstCoefficientVO.cVuXi = (parseFloat(newValue.data.cVuXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.cVuXi = newValue.data.cVuXi;
-                    }
-
-                    firstCoefficientVO.aIeData = parseFloat(newValue.data.aIeData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.aIeXi)) && isFinite(newValue.data.aIeXi)) {
-                      firstCoefficientVO.aIeXi = (parseFloat(newValue.data.aIeXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.aIeXi = newValue.data.aIeXi;
-                    }
-
-                    firstCoefficientVO.bIeData = parseFloat(newValue.data.bIeData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.bIeXi)) && isFinite(newValue.data.bIeXi)) {
-                      firstCoefficientVO.bIeXi = (parseFloat(newValue.data.bIeXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.bIeXi = newValue.data.bIeXi;
-                    }
-
-                    firstCoefficientVO.cIeData = parseFloat(newValue.data.cIeData).toFixed(4);
-
-                    if (!isNaN(parseFloat(newValue.data.cIeXi)) && isFinite(newValue.data.cIeXi)) {
-                      firstCoefficientVO.cIeXi = (parseFloat(newValue.data.cIeXi) / 10000).toFixed(4);
-                    } else {
-                      firstCoefficientVO.cIeXi = newValue.data.cIeXi;
-                    }
-
-                    firstCoefficientVO.aV = newValue.data.aV;
-                    firstCoefficientVO.bV = newValue.data.bV;
-                    firstCoefficientVO.cV = newValue.data.cV;
-                    firstCoefficientVO.aI = newValue.data.aI;
-                    firstCoefficientVO.bI = newValue.data.bI;
-                    firstCoefficientVO.cI = newValue.data.cI;
-                    //console.log(newValue.data.devName + '对象:', firstCoefficientVO);
-                    activeIndex.value++;
-                  } else {
-                    //console.log('未找到匹配的'+ newValue.data.devName+'对象');
-                  }
-                } else {
-                  //console.log(newValue.data.devName + '数组为空');
-                }
-              } else {
-                //console.log('未找到'+newValue.data.devName+'对应的数组');
-              }
-            }
-            break;
-        }
-        break;
-      case 'socket_timeout':
-        switch (newValue.operateCode) {
-          case 'VOLTAGE':
-            ElMessageBox.alert('连接超时！', '连接超时', {
-              confirmButtonText: '确定',
-              type: 'error',
-            })
-            TableInit();
-            break;
-        }
-        break;
-      case 'connect':
-        switch (newValue.operateCode) {
-          case "Source":
-            ElMessageBox.alert('源服务端连接失败', '源服务端连接失败', {
-              confirmButtonText: '确定',
-              type: 'error',
-            })
-            TableInit();
-            break;
-          case "Dev":
-            ElMessageBox.alert('设备服务端连接失败', '设备服务端连接失败', {
-              confirmButtonText: '确定',
-              type: 'error',
-            })
-            TableInit();
-            break;
-        }
-
-        break;
-    }
-  }
-})
-
-//出错系数检测初始化
-const TableInit = () => {
-  console.log("TableInitactive", active.value);
-  isButtonDisabled.value = false; // 恢复按钮
-  for (let i = 0; i < channel.value.length; i++) {
-    const currentTableData = initializeTableData(dataTemplates, i);
-    tableDataMap.set(i, currentTableData)
-
-    // const targetArrayRef = tableDataMap.get(i);
-    //     if (targetArrayRef) {
-    //         const targetArray = targetArrayRef.value;
-    //         if (targetArray.length > 0) {
-    //           targetArray.forEach(item => item.loading =false)
-    //        }
-    //     }
-  }
-  activeIndex.value = 0
-  qualified.value = 0
-  active.value = 0
-
-}
-
-//按行图标转动
-const tableLoading = (type: string, desc: string) => {
-  for (let i = 0; i < channel.value.length; i++) {
-
-    const targetArrayRef = tableDataMap.get(i);
-    if (targetArrayRef) {
-      const targetArray = targetArrayRef.value;
-      if (targetArray.length > 0) {
-        for (let j = 0; j < channel.value[i]; j++) {
-          const firstCoefficientVO = targetArray.find(item => item.monitorNum === (j + 1).toString() &&
-              item.type === type &&
-              item.desc === desc);
-          if (firstCoefficientVO) {
-            firstCoefficientVO.loading = true;
-          }
-        }
-      }
-    }
-  }
-}
-
-const dataTemplates: ChannelsTest.CoefficientVO[] = [
-  {
-    monitorNum: '1',
-    desc: '系数下装',
-    type: 'big',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: '',
-    aV: '—',
-    bV: '—',
-    cV: '—',
-    aI: '—',
-    bI: '—',
-    cI: '—',
-  },
-  {
-    monitorNum: '2',
-    desc: '系数下装',
-    type: 'small',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: '',
-    aV: '—',
-    bV: '—',
-    cV: '—',
-    aI: '—',
-    bI: '—',
-    cI: '—',
-  },
-  {
-    monitorNum: '3',
-    desc: '系数校准',
-    type: 'big',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: '',
-    aV: '—',
-    bV: '—',
-    cV: '—',
-    aI: '—',
-    bI: '—',
-    cI: '—',
-  },
-  {
-    monitorNum: '4',
-    desc: '系数校准',
-    type: 'small',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: '',
-    aV: '—',
-    bV: '—',
-    cV: '—',
-    aI: '—',
-    bI: '—',
-    cI: '—',
-  },
-
-];
-
-const dataTemplates2: ChannelsTest.CoefficientVO[] = [
-  {
-    monitorNum: '1',
-    desc: '系数下装',
-    type: 'big',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: ''
-  },
-  {
-    monitorNum: '2',
-    desc: '系数下装',
-    type: 'small',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: ''
-  },
-  {
-    monitorNum: '3',
-    desc: '系数校准',
-    type: 'big',
-    aVuData: '—',
-    aVuXi: '不合格',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: ''
-  },
-  {
-    monitorNum: '4',
-    desc: '系数校准',
-    type: 'small',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: ''
-  },
-
-];
-
-// 更新错误状态的方法
-const updateErrorState = (index: number, hasError: boolean) => {
-  errorStates.value[index] = hasError;
-};
-
-// 打开弹窗，可能是新增，也可能是编辑
-const open = (selection: Device.ResPqDev[], plan: Plan.ReqPlan) => {
-  CurV.value = selection[0]?.devVolt || 57.74;
-  isButtonDisabled.value = false; // 恢复按钮
-  select_Plan.value = plan
-  planId.value = selection[0]?.planId || '';
-  devIdArray.value = selection.map(item => item.id);
-  name.value = selection.map(item => item.name)
-  channel.value = selection.map(item => item.devChns)
-  dialogVisible.value = true;
-  total.value = name.value.length
-
-
-  // 初始化 loadingStates 为 false
-  // loadingStates.value = new Array(selection.length).fill(false);
-  errorStates.value = new Array(selection.length).fill(false);
-
-  for (let i = 0; i < channel.value.length; i++) {
-    const currentTableData = initializeTableData(dataTemplates, i);
-    tableDataMap.set(i, currentTableData)
-  }
-  //console.log('tableDataMap',tableDataMap);
-}
-
-
-const emit = defineEmits<{
-  (e: 'quitClicked'): void;
-  (e: 'submitClicked', callback: (resolve: (value: boolean) => void) => void): void;
-}>();
-
-
-
-const beforeClose = (done: () => void) => {
- ElMessageBox.confirm('是否退出系数校准?', '提示', {
-          confirmButtonText: '确定',
-          cancelButtonText: '取消',
-          type: 'warning',
-        }
-    ).then(() => {
-       handleCancel()
-    })
-}
-
-const handleCancel = () => {
-        //dataSocket.socketServe.closeWs()
-        // 清空 name, channel, total
-        name.value = [];
-        channel.value = [];
-        total.value = 0;
-        activeIndex.value = 0
-        qualified.value = 0
-        active.value = 0
-        dialogVisible.value = false
-        editableTabsValue.value = '0'
-        emit('quitClicked'); // 触发事件
-
-
-
-
-}
-
-const getTableDataForChannel = (index: number): any[] => {
-  const data = tableDataMap.get(index);
-  return data ? data.value : [];
-}
-
-
-watch(activeIndex, function (newValue, oldValue) {
-  if (activeIndex.value === 1) {
-    outputDsc.value = "电压误差为：±0.1Un%； 电流误差为：±0.5%";
-    // 当前源输出为：Ua=Ub=Uc=57.74V Ia=Ib=Ic=1A"
-  }
-})
-
-// 示例的 checkForErrors 函数，根据实际需求进行调整
-const checkForErrors = (data: ChannelsTest.CoefficientVO[]): boolean => {
-  // 这里假设不合格字段的标准是 status 为 '不合格' 或 isValid 为 false
-  return data.some(item =>
-      item.aVuXi === '不合格' ||
-      item.bVuXi === '不合格' ||
-      item.cVuXi === '不合格' ||
-      item.aIeXi === '不合格' ||
-      item.bIeXi === '不合格' ||
-      item.cIeXi === '不合格'
-  );
-};
-
-const handleSubmit = async () => {
-  // 创建一个 Promise 来等待父组件的回调
-  const response = await new Promise<boolean>((resolve) => {
-    emit('submitClicked', resolve);
-  });
-
-  if (!response) {
-    return;
-  }
-
-  isButtonDisabled.value = true; // 禁用按钮
-  tableLoading('big', '系数下装')
-  await getCoefficientCheck({
-    userPageId: "cdf",
-    devIds: devIdArray.value,
-    planId: planId.value,
-    errorSysId: select_Plan.value?.errorSysId,
-    scriptId: select_Plan.value?.scriptId,
-    operateType: '0', // '0'为预检测、‘1‘为正式检测
-    userId: userStore.userInfo.id
-  })
-  active.value++;
-
-  // 初始化 loadingStates 为 true
-  // loadingStates.value = new Array(name.value.length).fill(true);
-
-  return;
-  // 初始化 currentTableData
-  // let isTimer2Completed = false;
-
-
-  // //"80b4b4f52a4c4064a18319525f8ac13c",
-  // for (let i = 0; i < channel.value.length; i++) {
-  //   // 重置状态变量
-  //   active.value = 0;
-  //   //activeIndex.value = 0;
-  //   editableTabsValue.value = i.toString();
-  //   // 初始化并填充 currentTableData
-  //   const currentTableData = initializeTableData(dataTemplates2, i);
-  //   tableDataMap.set(i, currentTableData);
-  //   //activeIndex.value++;
-
-  //   // 清除之前的 timer1
-  //   clearInterval(timer1);
-  //   // 启动 timer1
-  //   timer1 = setInterval(() => {
-  //     active.value++;
-  //     if (active.value > 5) {
-  //       clearInterval(timer1);
-  //     }
-  //   }, 3000);
-
-  //   // 清除之前的 timer2
-  //   clearInterval(timer2);
-  //   // 启动 timer2
-  //   timer2 = setInterval(() => {
-  //     // 初始化并填充 currentTableData
-  //     const currentTableData = initializeTableData(i > 0 ? dataTemplates2 : dataTemplates2, i);
-  //     tableDataMap.set(i, currentTableData);
-  //     activeIndex.value++;
-
-  //     clearInterval(timer2);
-  //     const currentDataRef = tableDataMap.get(i);
-  //     if (currentDataRef) {
-  //       const currentData = currentDataRef.value;
-  //       // 检查当前数据中有无不合格字段
-  //       const hasError = checkForErrors(currentData);
-  //       if (hasError) {
-  //       } else {
-  //         qualified.value++;
-  //       }
-  //       updateErrorState(i, hasError);
-  //     }
-
-  //     // 设置标志变量为 true，表示 timer2 已经完成
-  //     isTimer2Completed = true;
-  //   }, 3000);
-
-  //   // 等待 timer2 完成
-  //   while (!isTimer2Completed) {
-  //     // 这里可以添加一个短暂的等待，避免死循环
-  //     await new Promise(resolve => setTimeout(resolve, 100));
-  //   }
-
-  //   // 重置标志变量
-  //   isTimer2Completed = false;
-  // }
-};
-
-// 提取初始化并填充 currentTableData 的函数
-const initializeTableData = (templates: ChannelsTest.CoefficientVO[], index: number): Ref<ChannelsTest.CoefficientVO[]> => {
-  const currentTableData = ref<ChannelsTest.CoefficientVO[]>([]);
-  for (let j = 0; j < channel.value[index]; j++) {
-    templates.forEach((template) => {
-      // 使用解构赋值排除 id 和 MonitorIdx 属性
-      const {devName, monitorNum: __, ...rest} = template;
-      currentTableData.value.push({
-        monitorNum: (j + 1).toString(),
-        devName: name.value[index],
-        ...rest,
-      });
-    });
-  }
-  return currentTableData;
-};
-
-
-// 对外映射
-defineExpose({open})
-</script>
-<style scoped>
-
-/* 确保 el-icon-loading 的动画效果没有被覆盖 */
-.loading-box {
-  animation: rotate 2s linear infinite;
-  font-size: 30px; /* 增大图标的大小 */
-}
-
-@keyframes rotate {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-.right-title {
-  display: flex;
-  flex-direction: row;
-  /* 横向排列 */
-  justify-content: space-between;
-  margin-bottom: 10px;
-}
-
-.custom-tabs-label .el-icon {
-  vertical-align: middle;
-}
-
-.custom-tabs-label span {
-  vertical-align: middle;
-  margin-left: 4px;
-}
-
-.dialog-content {
-  height: 510px;
-}
-
-.el-tabs--border-card {
-  height: 470px;
-}
-
-/* .el-icon svg {
-  color: #ff7171;
-} */
-
-.icon-style {
-  color: #ff7171;
-}
-
-.container {
-  display: flex;
-}
-
-.dialog-left {
-  flex: 1;
-}
-
-.right-content {
-  flex: 6;
-}
-
-.spanStyle {
-  font-size: 14px;
-}
-
-
-</style>

frontend/src/views/home/components/compareDataCheckRawDataTable.vue

@@ -0,0 +1,63 @@
+<template>
+  <div class="table-main">
+    <el-table
+        :data="prop.tableData"
+        stripe
+        border
+        :header-cell-style="{ textAlign: 'center' }"
+        :cell-style="{ textAlign: 'center' }"
+        height="368px"
+        style="width: 100%"
+    >
+      <el-table-column type="index" label="序号" width="70" fixed="left"/>
+
+      <el-table-column prop="dataA" :label="'被检设备'">
+        <el-table-column prop="timeDev" label="数据时间" width="200"/>
+        <el-table-column prop="uaDev" :label="'A相'+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.uaDev != null"/>
+        <el-table-column prop="ubDev" :label="setB+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.ubDev != null"/>
+        <el-table-column prop="ucDev" :label="'C相'+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.ucDev != null"/>
+        <el-table-column prop="utDev" :label="setT+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData[0]?.utDev != null"/>
+      </el-table-column>
+      <el-table-column prop="dataA" :label="'标准设备'">
+        <el-table-column prop="timeStdDev" label="数据时间" width="200"/>
+        <el-table-column prop="uaStdDev" :label="'A相'+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.uaStdDev != null"/>
+        <el-table-column prop="ubStdDev" :label="setB+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.ubStdDev != null"/>
+        <el-table-column prop="ucStdDev" :label="'C相'+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData.length==0||prop.tableData[0]?.ucStdDev != null"/>
+        <el-table-column prop="utStdDev" :label="setT+(outerUnit==''?'':'（'+outerUnit+'）')" v-if="prop.tableData[0]?.utStdDev != null"/>
+      </el-table-column>
+    </el-table>
+  </div>
+</template>
+
+<script lang="tsx" setup>
+import { computed } from 'vue'
+import { CheckData } from '@/api/check/interface'
+
+const prop = defineProps({
+    tableData: {
+        type: Array as () => CheckData.TableRow[],
+        default: []
+    },
+    currentCheckItem: {
+        type: String,
+        default: ''
+    }
+})
+
+const outerUnit = computed(() => {
+  return prop.tableData.length > 0 ? prop.tableData[0].unit : '';
+})
+
+const setB = computed(() => {
+  return prop.currentCheckItem == '三相电流不平衡度'
+      ? '负序不平衡度'
+      : prop.currentCheckItem == '三相电压不平衡度'
+          ? '负序不平衡度'
+          : 'B相'
+})
+const setT = computed(() => {
+  return prop.currentCheckItem == '频率' ? '频率' : 'T相'
+})
+</script>
+
+<style scoped></style>

frontend/src/views/home/components/compareDataCheckResultTable.vue

@@ -0,0 +1,196 @@
+<template>
+  <div class="table-main">
+    <el-table
+        :data="prop.tableData"
+        height="368px"
+        :header-cell-style="{ textAlign: 'center' }"
+        :cell-style="{ textAlign: 'center' }"
+    >
+<!--      <el-table-column type="index" label="序号" width="70" fixed="left" />-->
+      <el-table-column label="A相" v-if="prop.tableData.length==0|| prop.tableData[0]?.dataA">
+        <el-table-column prop="stdA" :label="'被检值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataA.data }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="dataA" :label="'标准值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataA.resultData }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="isDataA" label="检测结果">
+          <template #default="{ row }">
+            <el-tooltip effect="dark" placement="bottom">
+              <template #content>
+                误差范围：{{ addPercentSigns(row.dataA.radius, row.dataA.unit) }}
+                <br/>
+                误差值：{{ row.dataA.errorData }}{{ row.dataA.unit }}
+              </template>
+              <el-tag type="success" v-if="row.dataA.isData === 1">符合</el-tag>
+              <el-tag type="danger" v-if="row.dataA.isData === 2">不符合</el-tag>
+              <el-tag type="warning" v-if="row.dataA.isData === 4">/</el-tag>
+              <el-tag type="info" v-if="row.dataA.isData === 5">-</el-tag>
+            </el-tooltip>
+          </template>
+        </el-table-column>
+      </el-table-column>
+      <el-table-column :label="setB" v-if="prop.tableData.length==0|| prop.tableData[0]?.dataB">
+        <el-table-column prop="stdB" :label="'被检值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataB.data }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="dataB" :label="'标准值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataB.resultData }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="isDataB" label="检测结果">
+          <template #default="{ row }">
+            <el-tooltip effect="dark" placement="bottom">
+              <template #content>
+                误差范围：{{ addPercentSigns(row.dataB.radius, row.dataB.unit) }}
+                <br/>
+                误差值：{{ row.dataB.errorData }}{{ row.dataB.unit }}
+              </template>
+              <el-tag type="success" v-if="row.dataB.isData === 1">符合</el-tag>
+              <el-tag type="danger" v-if="row.dataB.isData === 2">不符合</el-tag>
+              <el-tag type="warning" v-if="row.dataB.isData === 4">/</el-tag>
+              <el-tag type="info" v-if="row.dataB.isData === 5">-</el-tag>
+            </el-tooltip>
+          </template>
+        </el-table-column>
+      </el-table-column>
+      <el-table-column label="C相" v-if="prop.tableData.length==0|| prop.tableData[0]?.dataC">
+        <el-table-column prop="stdC" :label="'被检值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataC.data }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="dataC" :label="'标准值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataC.resultData }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="isDataC" label="检测结果">
+          <template #default="{ row }">
+            <el-tooltip effect="dark" placement="bottom">
+              <template #content>
+                误差范围：{{ addPercentSigns(row.dataC.radius, row.dataC.unit) }}
+                <br/>
+                误差值：{{ row.dataC.errorData }}{{ row.dataC.unit }}
+              </template>
+              <el-tag type="success" v-if="row.dataC.isData === 1">符合</el-tag>
+              <el-tag type="danger" v-if="row.dataC.isData === 2">不符合</el-tag>
+              <el-tag type="warning" v-if="row.dataC.isData === 4">/</el-tag>
+              <el-tag type="info" v-if="row.dataC.isData === 5">-</el-tag>
+            </el-tooltip>
+          </template>
+        </el-table-column>
+      </el-table-column>
+      <el-table-column :label="setT" v-if="prop.tableData[0].dataT">
+        <el-table-column prop="stdT" :label="'被检值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataT.data }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="dataT" :label="'标准值'+(outerUnit==''?'':'（'+outerUnit+'）')">
+          <template #default="{ row }">
+            {{ row.dataT.resultData }}
+          </template>
+        </el-table-column>
+        <el-table-column prop="isDataT" label="检测结果">
+          <template #default="{ row }">
+            <el-tooltip effect="dark" placement="bottom">
+              <template #content>
+                误差范围：{{ addPercentSigns(row.dataT.radius, row.dataT.unit) }}
+                <br/>
+                误差值：{{ row.dataT.errorData }}{{ row.dataT.unit }}
+              </template>
+              <el-tag type="success" v-if="row.dataT.isData === 1">符合</el-tag>
+              <el-tag type="danger" v-if="row.dataT.isData === 2">不符合</el-tag>
+              <el-tag type="warning" v-if="row.dataT.isData === 4">/</el-tag>
+              <el-tag type="info" v-if="row.dataT.isData === 5">-</el-tag>
+            </el-tooltip>
+          </template>
+        </el-table-column>
+      </el-table-column>
+    </el-table>
+  </div>
+</template>
+
+<script lang="tsx" setup>
+import {computed} from 'vue'
+import {CheckData} from '@/api/check/interface'
+
+const prop = defineProps({
+  tableData: {
+    type: Array as () => CheckData.TableRow[],
+    default: []
+  },
+  currentCheckItem: {
+    type: String,
+    default: ''
+  }
+})
+
+
+
+// 添加单位
+const outerUnit = computed(() => {
+  return prop.tableData.length > 0 ? prop.tableData[0].unit : '';
+})
+
+
+
+
+const addPercentSigns = (text: string, unit: string) => {
+  return text
+      .split('~')
+      .map(part => `${part}${unit}`)
+      .join('~')
+}
+const setB = computed(() => {
+  return prop.currentCheckItem == '三相电流不平衡度'
+      ? '三相电流不平衡度'
+      : prop.currentCheckItem == '三相电压不平衡度'
+          ? '三相电压不平衡度'
+          : 'B相'
+})
+
+const setT = computed(() => {
+  return prop.currentCheckItem == '频率' ? '频率' : 'T相'
+})
+</script>
+
+<style scoped>
+.form-grid {
+    display: flex;
+    flex-direction: row; /* 横向排列 */
+    flex-wrap: wrap; /* 允许换行 */
+}
+
+.form-grid .el-form-item {
+    flex: 1 1 30%; /* 控件宽度 */
+    margin-right: 20px; /* 控件间距 */
+}
+
+.form-grid .el-form-item:last-child {
+    margin-right: 0; /* 最后一个控件不需要右边距 */
+}
+
+.dialog-footer {
+    display: flex;
+    justify-content: flex-start;
+    margin-bottom: 10px; /* 调整这里的值以增加或减少间距 */
+}
+
+.el-tabs {
+    margin-bottom: 20px; /* 添加底部边距 */
+}
+
+.el-table th,
+.el-table td {
+    text-align: center; /* 所有单元格文字居中 */
+}
+</style>

frontend/src/views/home/components/compareDataCheckSingleChannelSingleTestPopup.vue

@@ -0,0 +1,672 @@
+<template>
+    <el-dialog
+        :append-to-body="appendToBody"
+        class="dialog"
+        title="数据查询"
+        :model-value="visible"
+        @close="close"
+        v-bind="dialogBig"
+        :draggable="false"
+        width="1400px"
+    >
+        <div class="data-check-dialog">
+            <div>
+                <el-form :model="formContent" label-width="auto" class="form-three">
+                    <el-form-item label="误差体系">
+                        <el-select
+                            :disabled="checkStore.showDetailType === 2 || checkStore.showDetailType === 0"
+                            v-model="formContent.errorSysId"
+                            placeholder="请选择误差体系"
+                            autocomplete="off"
+                             @change="handleErrorSysChange"
+                        >
+                            <el-option
+                                v-for="option in pqErrorList"
+                                :key="option.id"
+                                :label="option.name"
+                                :value="option.id"
+                            />
+                        </el-select>
+                    </el-form-item>
+                    <el-form-item label="数据原则">
+                        <el-input v-model="formContent.dataRule" :disabled="true" />
+                    </el-form-item>
+                    <el-form-item label="设备名称">
+                        <el-input v-model="formContent.deviceName" :disabled="true" />
+                    </el-form-item>
+                    <el-form-item label="通道号">
+                        <el-select v-model="formContent.chnNum" @change="handleChnNumChange" :disabled="sourceKey == 1">
+                            <el-option v-for="item in chnList" :key="item" :label="item" :value="item" />
+                        </el-select>
+                    </el-form-item>
+                    <el-form-item label="检测次数" >
+                        <el-select v-model="formContent.num" clearable @change="handleNumChange" :disabled="sourceKey == 1">
+                            <el-option
+                                v-for="item in chnMapList[formContent.chnNum]"
+                                :key="item"
+                                :label="item"
+                                :value="item"
+                            />
+                        </el-select>
+                    </el-form-item>
+                    <el-form-item v-if="checkStore.showDetailType === 1">
+                        <el-button type="primary" :icon="Postcard">报告生成</el-button>
+                    </el-form-item>
+                    <el-form-item v-if="checkStore.showDetailType === 0">
+                        <el-button type="primary" :icon="Histogram" @click="handleReCalculate">重新计算</el-button>
+                    </el-form-item>
+                </el-form>
+            </div>
+            <div class="data-check-body">
+                <div class="content-left-tree" v-if="sourceKey == 2">
+                    <el-tree
+                        style="width: 200px"
+                        :data="scriptData"
+                        :props="defaultProps"
+                        highlight-current
+                        node-key="id"
+                        ref="treeRef"
+                        @node-click="handleNodeClick"
+                    >
+                     
+                    </el-tree>
+                </div>
+                <div class="content-right">
+                   <div class="content-right-title">
+                        <div style="width: 840px">
+                            <span class="content-right-title-text">当前检测项目：</span>
+                            <!-- 当code为'wave_data'时显示下拉框 -->
+                            <el-select 
+                                v-if="isWaveData" 
+                                v-model="selectedScriptName" 
+                                style="width: 200px"
+                                @change="handleScriptNameChange"
+                            >
+                                <el-option 
+                                    v-for="item in scriptNameOptions" 
+                                    :key="item.value" 
+                                    :label="item.label" 
+                                    :value="item.value" 
+                                />
+                            </el-select>
+                            <!-- 否则显示原来的文本 -->
+                            <span v-else style="color: var(--el-color-primary)">{{ rowList.scriptName }}</span>
+                        </div>
+                        <el-form-item
+                            style="margin: 0 auto; margin-bottom: 0px !important; width: 200px; position: absolute; left: 50%; transform: translateX(-50%);"
+                            label="录波次数" 
+                            v-if="isWaveData"
+                        >
+                             <el-select v-model="waveNumber" @change="handleWaveNumberChange">
+                                <el-option 
+                                    v-for="i in waveNumCount" 
+                                    :key="i" 
+                                    :label="i" 
+                                    :value="i" 
+                                />
+                            </el-select>
+                        </el-form-item>
+                        <el-form-item
+                            style="margin-left: 280px; margin-bottom: 0px !important; width: 300px"
+                            label="测试项" 
+                        >
+                            <el-select v-model="currentCheckItem">
+                                <el-option
+                                    v-for="item in tesList"
+                                    :key="item"
+                                    :label="item.replace(/\.0$/, '')"
+                                    :value="item"
+                                />
+                            </el-select>
+                        </el-form-item>
+                    </div>
+                    <div class="content-right-Tabs">
+                        <el-tabs type="border-card" v-model="activeTab">
+                            <el-tab-pane label="检测结果" name="resultTab">
+                                <CompareDataCheckResultTable
+                                    :tableData="checkResultData.length == 0 ? [] : currentCheckResultData"
+                                    :currentCheckItem="currentCheckItem"
+                                    :currentScriptTypeName="currentScriptTypeName"
+                                    v-if="activeTab === 'resultTab'"
+                                   
+                                />
+                            </el-tab-pane>
+                            <el-tab-pane label="原始数据" name="rawDataTab">
+                                <CompareDataCheckRawDataTable
+                                    v-if="activeTab === 'rawDataTab'"
+                                    :tableData="rawTableData.length == 0 ? [] : currentRawTableData"
+                                    :currentCheckItem="currentCheckItem"
+                                    :currentScriptTypeName="currentScriptTypeName"
+                                />
+                            </el-tab-pane>
+                        </el-tabs>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </el-dialog>
+</template>
+<script setup lang="ts">
+import { dialogBig } from '@/utils/elementBind'
+import { reactive, ref, watch, computed, nextTick } from 'vue'
+import CompareDataCheckResultTable from './compareDataCheckResultTable.vue'
+import CompareDataCheckRawDataTable from './compareDataCheckRawDataTable.vue'
+import { CheckData } from '@/api/check/interface'
+import { useCheckStore } from '@/stores/modules/check'
+import { Histogram, Postcard } from '@element-plus/icons-vue'
+import { getPqErrSysList } from '@/api/plan/plan'
+import { useModeStore } from '@/stores/modules/mode' // 引入模式 store
+import { useDictStore } from '@/stores/modules/dict'
+import { getContrastFormContent, getContrastResult, getScriptList,reCalculate ,changeErrorSystem,deleteTempTable} from '@/api/check/test'
+import { ElMessage } from 'element-plus'
+import {ResultEnum} from "@/enums/httpEnum";
+
+const { appendToBody } = withDefaults(
+    defineProps<{
+        appendToBody: boolean
+    }>(),
+    { appendToBody: true }
+)
+
+const checkStore = useCheckStore()
+const modeStore = useModeStore()
+const dictStore = useDictStore()
+const visible = ref(false)
+const treeRef = ref()
+
+const pqErrorList = reactive<{ id: string; name: string }[]>([])
+const activeTab = ref('resultTab')
+const currentCheckItem = ref<any>()
+const rowList: any = ref([])
+let scriptType: string | null = null
+
+const defaultProps = {
+    children: 'children',
+    label: 'scriptName'
+}
+
+const chnMapList: any = ref({})
+const waveNumCount = ref(0)
+const waveNumber = ref(1)
+const selectedScriptName = ref('')
+const pattern = ref('')
+// 添加以下内容
+const isWaveData = ref(false)
+const scriptNameOptions = ref<{label: string, value: string}[]>([])
+
+// 表单数据
+const formContent = reactive<CheckData.DataCheck>({
+    scriptName: '',
+    errorSysId: '',
+    dataRule: '',
+    deviceName: '',
+    chnNum: '',
+    deviceId: '',
+    num: ''
+})
+const sourceKey = ref(1) //1:正式检测进入页面 2:检测数据查询进入
+
+// 通道下拉列表
+const chnList: any = ref([])
+
+// 当前检测项目名称
+const currentScriptTypeName = ref('')
+// 检测结果表格数据
+const checkResultData = ref<CheckData.CheckResult[]>([])
+// 检测脚本配置数据
+const scriptData = ref<CheckData.ScriptItem[]>([])
+//录波对应当前检测项下拉框
+const selectScript = ref<CheckData.ScriptItem[]>([])
+// 原始数据表格数据
+const rawTableData = ref<CheckData.RawDataItem[]>([])
+const tesList: any = ref([])
+// 检测结果
+const currentCheckResultData = computed(() => {
+    const data = checkResultData.value[currentCheckItem.value]
+    return Array.isArray(data) ? data : []
+})
+const currentRawTableData = computed(() => {
+    const data = rawTableData.value[currentCheckItem.value]
+    return Array.isArray(data) ? data : []
+})
+
+
+const open = async (row: any, chnNum: string, deviceId: string | null, source: number) => {
+    isWaveData.value = false
+    pattern.value = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? ''//获取数据字典中对应的id
+    rowList.value = {}
+    formContent.deviceId = deviceId || ''
+    formContent.chnNum = chnNum
+    sourceKey.value = source
+    // 获取基本信息
+    await getBasicInformation(row.scriptType)
+    if (source == 1) {
+       // 正式检测进入页面 - 创建新的对象避免引用共享
+        rowList.value = {
+        scriptName: row.scriptName,
+        scriptType: row.scriptType,
+        // 复制其他需要的属性
+        devices: row.devices ? [...row.devices] : []
+        }
+    } 
+    // 检测数据查询进入---不区分检测数据查询和正式检测
+    await initScriptData()
+    visible.value = true
+    scriptType = null
+    formContent.errorSysId = checkStore.plan.errorSysId
+
+    pqErrorList.length = 0
+    // 获取误差体系
+    let { data: resPqErrorList } = await getPqErrSysList()
+    Object.assign(pqErrorList, resPqErrorList)
+     
+    initGetResult()
+    
+}
+
+const initGetResult = async () => {
+    // 判断是否为录波数据
+    const isLuoboData = (sourceKey.value == 1 && rowList.value.scriptName == "录波") || 
+                        (sourceKey.value == 2 && scriptData.value[0]?.code == "wave_data");
+    
+    if (isLuoboData) {
+        isWaveData.value = true
+        // 设置录波数据相关的选项
+        scriptNameOptions.value = selectScript.value.map(item => ({
+            label: item.scriptName,
+            value: item.scriptName
+        }))
+        
+        // 默认选中第一个选项
+        if (scriptNameOptions.value.length > 0) {
+            selectedScriptName.value = scriptNameOptions.value[0].value
+            // 更新rowList以匹配选中的script
+            const selectedItem = selectScript.value.find(item => item.scriptName === selectedScriptName.value)
+            if (selectedItem) {
+                rowList.value.scriptName = selectedScriptName.value
+                rowList.value.scriptType = selectedItem.id
+            }
+        }
+        await getResults('wave_data')
+    } else {
+        await getResults('')
+    }
+}
+
+
+// 查询大项树
+const initScriptData = async () => {
+    let response: any = await getScriptList({
+        devId: formContent.deviceId,
+        chnNum: formContent.chnNum,
+        num: formContent.num
+    })
+    
+    // 格式化脚本数据
+    let temp = response.data.map((item: any) => {
+        return {
+            ...item,
+            scriptName: item.scriptName
+        }
+    })
+
+    // 保存脚本数据
+    scriptData.value = temp
+
+    // 查找code为"录波"的项
+    let luoboItem = response.data.find((item: any) => item.code === 'wave_data');
+    // 如果找到了"录波"项，则使用其subitems，否则使用空数组
+    let temp2 = [];
+    if (luoboItem && luoboItem.subItems) {
+
+        // 格式化脚本数据
+        temp2 = luoboItem.subItems.map((item: any) => {
+            return {
+                ...item,
+                scriptName: item.scriptName
+            }
+        })
+    }
+    selectScript.value = temp2
+
+
+    // 只有在sourceKey == 2时才设置rowList和tree相关属性
+    if (sourceKey.value === 2 && temp.length > 0) {
+       
+        rowList.value.scriptName = temp[0].scriptName
+        rowList.value.scriptType = temp[0].id
+        selectedScriptName.value = temp[0].scriptName
+        setTimeout(() => {
+            treeRef.value?.setCurrentKey(temp[0].id)
+        }, 0)
+    }
+
+   
+}
+
+// 获取基本信息
+const getBasicInformation = async (scriptType: any) => {
+    checkResultData.value = []
+    rawTableData.value = []
+    const scriptType2 = ref('')
+    
+    if(sourceKey.value == 1){
+        scriptType2.value = scriptType
+    }else{
+        scriptType2.value = ''
+    } 
+
+     //确保scriptData已初始化
+    // if (scriptData.value.length === 0) {
+    //     await initScriptData()
+    // }
+
+    try {
+        const res: any = await getContrastFormContent({
+            planId: checkStore.plan.id,
+            scriptType: scriptType2.value,
+            deviceId: formContent.deviceId,
+            chnNum: formContent.chnNum,
+            num: formContent.num == '' ? null : parseInt(formContent.num),
+            patternId: pattern.value
+        })
+        
+        formContent.dataRule = res.data.dataRule
+        formContent.deviceName = res.data.deviceName
+        formContent.errorSysId = res.data.errorSysId
+        chnMapList.value = res.data.chnMap
+        
+        let chnMap: string[] = []
+        for (let key in res.data.chnMap) {
+            chnMap.push(key)
+        }
+        chnList.value = chnMap
+        formContent.chnNum = formContent.chnNum == null ? chnList.value[0] : formContent.chnNum
+        
+        // 设置检测次数默认值为chnMap数组的最后一位
+        if (chnMapList.value[formContent.chnNum] && chnMapList.value[formContent.chnNum].length > 0) {
+            // 获取当前通道号对应的检测次数数组，并设置为最后一个值（最大值）
+            const numList = chnMapList.value[formContent.chnNum]
+            formContent.num = numList[numList.length - 1]
+        }
+        waveNumCount.value = res.data.waveNumTotal
+        
+        
+    } catch (error) {
+        console.error('获取基本信息失败:', error)
+    }
+}
+
+const handleChnNumChange = async (value: string) => {
+    formContent.chnNum = value
+    // 更新检测次数为当前通道的最后一条记录
+    updateCheckNumForChn(value)
+    // 执行通用变更处理逻辑
+    await handleCommonChange()
+}
+
+// 处理检测次数变更
+const handleNumChange = async (value: string) => {
+    formContent.num = value
+    // 执行通用变更处理逻辑
+    await handleCommonChange()
+}
+// 通用的变更处理函数
+const handleCommonChange = async () => {
+    // 重新初始化脚本数据（更新左侧树）
+    await initScriptData()
+    
+    // 触发当前选中节点的点击事件，保持界面状态一致
+    if (sourceKey.value === 2 && scriptData.value.length > 0) {
+        // 查找当前选中的节点
+        const currentNode = scriptData.value.find((item: any) => item.id === rowList.value.scriptType)
+        if (currentNode) {
+            // 如果找到了当前节点，则触发点击事件
+            handleNodeClick(currentNode)
+        } else {
+            // 如果没有找到当前节点，则默认触发第一个节点的点击事件
+            handleNodeClick(scriptData.value[0])
+        }
+    } else if (sourceKey.value === 1 && rowList.value.scriptType) {
+        // 对于正式检测进入的情况，创建一个临时节点对象来触发handleNodeClick
+        const tempNode = {
+            scriptName: rowList.value.scriptName,
+            id: rowList.value.scriptType,
+            code: rowList.value.scriptName === "录波" ? 'wave_data' : ''
+        }
+        handleNodeClick(tempNode)
+    }
+}
+
+// 更新检测次数为指定通道的最后一条记录
+const updateCheckNumForChn = (chnNum: string) => {
+    if (chnMapList.value[chnNum] && chnMapList.value[chnNum].length > 0) {
+        // 获取当前通道号对应的检测次数数组，并设置为最后一个值（最大值）
+        const numList = chnMapList.value[chnNum]
+        formContent.num = numList[numList.length - 1]
+    }
+}
+
+// 左边树变化
+const handleNodeClick = (data: any) => {
+    rowList.value.scriptName = data.scriptName
+    rowList.value.scriptType = data.id
+    
+    // 判断是否为录波数据
+    if (data.code === 'wave_data') {
+        isWaveData.value = true
+        // 过滤掉"录波"选项，设置下拉框数据
+        scriptNameOptions.value = selectScript.value
+            //.filter(item => item.code !== 'wave_data' && item.code !== 'FREQ')
+            .map(item => ({
+                label: item.scriptName,
+                value: item.scriptName
+            }))
+
+        // 每次选中录波数据时都重置为第一个选项并触发getResults
+        if (scriptNameOptions.value.length > 0) {
+          
+            selectedScriptName.value = scriptNameOptions.value[0].value
+            // 更新rowList并触发getResults
+            rowList.value.scriptName = selectedScriptName.value
+            const selectedItem = selectScript.value.find(item => item.scriptName === selectedScriptName.value)
+ 
+            if (selectedItem) {
+                rowList.value.scriptType = selectedItem.id
+                getResults('wave_data')
+            }
+        }
+    } else {
+
+        isWaveData.value = false
+        getResults(data.code)
+    }
+}
+// 获取结果
+const getResults = async (code: any) => {
+    checkResultData.value = []
+    rawTableData.value = []
+
+    // 判断是否为录波数据请求
+    const isWaveDataRequest = code === 'wave_data' || isWaveData.value
+
+    getContrastResult({
+        planId: checkStore.plan.id,
+        scriptType: rowList.value.scriptType,
+        deviceId: formContent.deviceId,
+        chnNum: formContent.chnNum,
+        num: formContent.num == '' ? null : formContent.num,
+        waveNum:  isWaveDataRequest ?  waveNumber.value : null,
+        isWave:  isWaveDataRequest ,
+        patternId: pattern.value
+    }).then((res: any) => {
+        let list: string[] = []
+        for (let key in res.data.resultMap) {
+            list.push(key)
+        }
+        currentCheckItem.value = list[0]
+        tesList.value = list
+        checkResultData.value = res.data.resultMap
+        rawTableData.value = res.data.rawDataMap
+
+       
+    })
+}
+
+// 添加处理scriptName变化的方法
+const handleScriptNameChange = (value: string) => {
+    selectedScriptName.value = value
+    rowList.value.scriptName = value
+    // 查找选中项的scriptType
+    const selectedItem = selectScript.value.find(item => item.scriptName === value)
+    if (selectedItem) {
+        rowList.value.scriptType = selectedItem.id
+        getResults('wave_data')
+    }
+}
+
+// 添加处理waveNumber变化的方法
+const handleWaveNumberChange = (value: number) => {
+    waveNumber.value = value
+    // 当录波次数改变时，重新获取结果
+    getResults('wave_data')
+}
+
+const close = async () => {
+    visible.value = false
+    formContent.num = ''
+    // 可以在这里添加其他清理逻辑
+    if (checkStore.showDetailType === 1) {
+        await deleteTempTable(checkStore.plan.code + '')
+    }
+}
+
+const handleErrorSysChange = async () => {
+  changeErrorSystem({
+    planId: checkStore.plan.id,
+    scriptId: '',
+    errorSysId: formContent.errorSysId,
+    deviceId: formContent.deviceId,
+    code: checkStore.plan.code + '',
+    patternId: dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? '',
+  }).then((res) => {
+    if (res.code === ResultEnum.SUCCESS) {
+      ElMessage.success('切换误差体系成功')
+      handleChnNumChange(formContent.chnNum)
+    }
+  })
+}
+
+
+
+const handleReCalculate = async () => {
+  reCalculate({
+    planId: checkStore.plan.id,
+    scriptId: '',
+    errorSysId: formContent.errorSysId,
+    deviceId: formContent.deviceId,
+    code: checkStore.plan.code + '',
+    patternId: dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? '',
+  }).then((res) => {
+    if (res.code === ResultEnum.SUCCESS) {
+      ElMessage.success('重新计算成功！')
+      handleChnNumChange(formContent.chnNum)
+  
+    }
+   
+  })
+}
+
+defineExpose({
+    open
+})
+</script>
+
+<style lang="scss" scoped>
+.dialog {
+    display: flex;
+    flex-direction: column;
+
+    .data-check-dialog {
+        display: flex;
+        flex-direction: column;
+
+        .data-check-head {
+            display: flex;
+            flex-direction: row;
+            width: 100%;
+        }
+
+        .data-check-body {
+            height: 500px;
+            width: 100%;
+            display: flex;
+            flex-direction: row;
+
+            .content-left-tree {
+                width: 18%;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                max-height: 495px;
+
+                padding: 10px 0.5% 0px 0.5%;
+                border: 1px solid #ccc;
+                overflow-y: auto;
+                overflow-x: auto;
+                margin-right: 10px;
+                .content-tree {
+                    width: 100%;
+                    height: 100%;
+                    margin-top: 10px;
+
+                    .custom-tree-node {
+                        overflow-x: hidden !important;
+                        white-space: nowrap !important;
+                        text-overflow: ellipsis !important;
+                    }
+                }
+            }
+
+            .content-right {
+                width: 82%;
+
+                flex: 1;
+
+                .content-right-title {
+                    display: flex;
+                    padding: 10px 0;
+                    margin-top: 0px;
+                    line-height: 1.5;
+
+                    .content-right-title-text {
+                        font-size: 14px;
+                        font-weight: bold;
+                    }
+                }
+            }
+
+            .content-right-Tabs {
+                box-sizing: border-box;
+                margin-top: 10px;
+                margin-bottom: 10px;
+                display: flex;
+                .el-tabs {
+                    width: 100%;
+                }
+            }
+            .content-left {
+                height: 100%;
+                border: 1px solid #e0e0e0;
+                padding: 10px;
+                margin-right: 10px;
+                height: 410px;
+                overflow-y: auto;
+            }
+        }
+    }
+}
+:deep(.el-tabs--border-card > .el-tabs__content) {
+    height: 367px;
+}
+</style>

frontend/src/views/home/components/comparePreTest.vue

@@ -0,0 +1,624 @@
+<template>
+  <div>
+    <el-tabs type="border-card">
+      <el-tab-pane label="预检测项目">
+        <div class="form-grid">
+          <el-checkbox v-for="(item, index) in detectionOptions" v-model="item.selected" :key="index"
+                       :label="item.name" disabled></el-checkbox>
+        </div>
+      </el-tab-pane>
+    </el-tabs>
+
+    <div class="test-dialog">
+      <div class="dialog-left">
+        <el-steps direction="vertical" :active="activeIndex" :process-status="currentStepStatus"
+                  finish-status="success">
+          <el-step :status="step1" title="设备通讯校验"/>
+          <el-step :status="step2" title="模型一致性校验"/>
+          <el-step :status="step3" title="实时数据对齐验证" v-if="!props.onlyWave"/>
+          <el-step :status="step4" title="相序校验"/>
+          <!-- <el-step :status="step6" title="遥控录波功能验证"/> -->
+          <el-step :status="step5" :title="ts === 'error'? '检测失败':ts === 'process'? '检测中':ts === 'success'? '检测成功':'待检测'"/>
+        </el-steps>
+      </div>
+      <div class="dialog-right">
+        <el-collapse v-model="collapseActiveName" accordion>
+          <el-collapse-item title="设备通讯校验" name="1">
+            <div class="div-log">
+              <p v-for="(item, index) in step1InitLog" :key="index"
+                 :style="{ color: item.type === 'error' ? '#F56C6C' : 'var(--el-text-color-regular)' }">
+                {{ item.log }} <br/>
+              </p>
+            </div>
+          </el-collapse-item>
+          <el-collapse-item title="模型一致性校验" name="2">
+            <div class="div-log">
+              <p v-for="(item, index) in step2InitLog" :key="index"
+                 :style="{ color: item.type === 'error' ? '#F56C6C' : 'var(--el-text-color-regular)' }">
+                {{ item.log }} <br/>
+              </p>
+            </div>
+          </el-collapse-item>
+          <el-collapse-item  name="3" v-if="!props.onlyWave">
+              <template #title>
+                实时数据对齐验证
+                <el-icon class="title-icon" @click="openDialog" v-if="isShowDialog"><InfoFilled/></el-icon>
+              </template>
+            <div class="div-log">
+              <p v-for="(item, index) in step3InitLog" :key="index"
+                 :style="{ color: item.type === 'error' ? '#F56C6C' : 'var(--el-text-color-regular)' }">
+                {{ item.log }} 
+                <br/>
+              </p>
+            </div>
+          </el-collapse-item>
+           <el-collapse-item title="相序校验" name="4">
+            <div class="div-log">
+              <p v-for="(item, index) in step4InitLog" :key="index"
+                 :style="{ color: item.type === 'error' ? '#F56C6C' : 'var(--el-text-color-regular)' }">
+                {{ item.log }} <br/>
+              </p>
+            </div>
+          </el-collapse-item>
+          <!-- <el-collapse-item title="遥控录波功能验证" name="3">
+            <div class="div-log">
+              <p v-for="(item, index) in step3InitLog" :key="index"
+                 :style="{ color: item.type === 'error' ? '#F56C6C' : 'var(--el-text-color-regular)' }">
+                {{ item.log.split('&&')[0] }}
+                <br v-if="item.log.includes('&&')"/>
+                &nbsp;&nbsp;&nbsp;&nbsp;{{ item.log.split('&&')[1] }}
+
+                <br v-if="item.log.includes('&&')"/>
+                &nbsp;&nbsp;&nbsp;&nbsp;{{ item.log.split('&&')[2] }}
+
+              </p>
+            </div>
+          </el-collapse-item> -->
+        </el-collapse>
+      </div>
+    </div>
+  </div>
+  <RealTimeData ref="realTimeDataRef" />
+</template>
+<script lang="tsx" setup name="preTest">
+import {ElMessage, ElMessageBox, StepProps} from "element-plus";
+import {computed, defineExpose, PropType, ref, toRef, watch} from 'vue';
+import RealTimeData from './realTimeDataAlign.vue'
+
+const realTimeDataRef = ref()
+
+
+const step1InitLog = ref([
+  {
+    type: 'info',
+    log: '暂无数据，等待检测开始',
+  },
+])
+
+const step2InitLog = ref([
+  {
+    type: 'info',
+    log: '暂无数据，等待检测开始',
+  },
+])
+
+const step3InitLog = ref([
+  {
+    type: 'info',
+    log: '暂无数据，等待检测开始',
+  },
+])
+
+const step4InitLog = ref([
+  {
+    type: 'info',
+    log: '暂无数据，等待检测开始',
+  },
+])
+
+
+
+const isShowDialog = ref(false)
+const collapseActiveName = ref('1')
+const activeIndex = ref(0)
+const activeTotalNum = computed(() => {
+  let count = 4; // 基础步骤数：设备通讯校验、模型一致性校验、相序校验、最终状态
+  if (props.onlyWave) {
+    count++; // 添加实时数据对齐验证步骤
+  }
+  return count;
+});
+const step1 = ref<StepProps['status']>('wait')
+const step2 = ref<StepProps['status']>('wait')
+const step3 = ref<StepProps['status']>('wait')
+const step4 = ref<StepProps['status']>('wait')
+const step5 = ref<StepProps['status']>('wait')
+
+
+//定义与预检测配置数组
+const detectionOptions = ref([
+  {
+    id: 0,
+    name: "设备通讯校验",
+    selected: true,
+  },
+  {
+    id: 1,
+    name: "模型一致性校验",
+    selected: true,
+  },
+  {
+    id: 2,
+    name: "实时数据对齐验证",
+    selected: true,
+  },
+  {
+    id: 3,
+    name: "相序校验",
+    selected: true,
+  },
+]);
+
+const currentStepStatus = ref<'error' | 'finish' | 'wait' | 'success' | 'process'>('finish');
+
+const props = defineProps({
+  testStatus: {
+    type: String,
+    default: 'wait'
+  },
+  webMsgSend: {
+    type: Object,
+    default: () => ({})
+  },
+    mapping: {
+    type: Object as PropType<Record<string, Record<string, string>>>,
+    default: () => ({})
+  },
+  onlyWave: {
+    type: Boolean,
+    default: false
+  }
+})
+
+
+const testStatus = toRef(props, 'testStatus');
+const webMsgSend = toRef(props, 'webMsgSend');
+const ts = ref('');
+
+
+// 在 script setup 中定义接口
+interface ChannelData {
+  devNum: string;
+  standardDevInfo: string;
+  dataList: {
+    timeDev: string | null;
+    uaDev: number | null;
+    ubDev: number | null;
+    ucDev: number | null;
+    timeStdDev: string | null;
+    uaStdDev: number | null;
+    ubStdDev: number | null;
+    ucStdDev: number | null;
+  }[];
+}
+
+interface DeviceData {
+  devName: string;
+  channelDataList: ChannelData[];
+}
+
+// 修改 testDataStructure 的类型声明
+const testDataStructure = ref<Record<string, DeviceData>>({});
+
+watch(webMsgSend, function (newValue, oldValue) {
+  if(testStatus.value == 'success' || testStatus.value == 'error'){
+    return
+  }
+  if (testStatus.value !== 'waiting') {
+    if(newValue.code == 25004){
+      ElMessage.error('接收数据超时！')
+      ts.value = 'error'
+      step5.value = 'error'
+    }else if(newValue.code == 10550){
+      ElMessage.error('设备连接异常!')
+      ts.value = 'error'
+      step5.value = 'error'
+    }
+    switch (newValue.requestId) {
+      case 'yjc_sbtxjy':
+        switch (newValue.operateCode) {
+          case 'INIT_GATHER$02':
+            if (newValue.code == 10200) {
+              step1InitLog.value.push({
+                type: 'info',
+                log: newValue.data,
+              })
+
+            } else if (newValue.code == 10201) {
+              step1.value = 'process'
+              step1InitLog.value = [{
+                type: 'wait',
+                log: '正在进行设备通讯校验.....',
+              }];
+            }  else if (newValue.code == 10551) {
+              step1InitLog.value.push({
+                type: 'error',
+                log: newValue.data + '设备触发报告异常!',
+              })
+              step1.value = 'error'
+              ts.value = 'error'
+              step5.value = 'error'
+            } else if (newValue.code == 10552) {
+              step1InitLog.value = [{
+                type: 'error',
+                log: '存在已经初始化步骤,执行自动关闭,请重新发起检测！',
+              }];
+              step1.value = 'error'
+              ts.value = 'error'
+              step5.value = 'error'
+            } else if (newValue.code == 25001) {
+              activeIndex.value = 1
+              step1.value = 'success'
+              step2.value = 'process'
+            }
+            break;
+          case 'INIT_GATHER$03':
+            if (newValue.code == 10200) { 
+              step1InitLog.value.push({
+                type: 'info',
+                log: newValue.data,
+              })
+            }else if (newValue.code == 25001) {
+               step1InitLog.value.push({
+                type: 'info',
+                log: newValue.data,
+              })
+              activeIndex.value = 1
+              step1.value = 'success'
+              step2.value = 'process'
+            }
+            break; 
+          case 'DATA_REQUEST$03':
+             if (newValue.code == 25001) {
+              activeIndex.value = 1
+              step1.value = 'success'
+              step2.value = 'process'
+            }
+            break;  
+        }
+        break;
+      case 'record_wave_step1':
+      switch (newValue.operateCode) { 
+        case 'DATA_REQUEST$03':
+          if (newValue.code == 25002) { //某一路录波校验失败
+            step1InitLog.value.push({
+              type: 'error',
+              log: newValue.data ,
+            })
+          }else if (newValue.code == 25003) { //最终失败
+             step1.value = 'error'
+             ts.value = 'error'
+             step5.value = 'error'
+          }
+        }
+        break;
+      case 'yjc_mxyzxjy':
+        switch (newValue.operateCode){
+          case 'DATA_REQUEST$02': 
+          if (newValue.code == 10200) { //单个监测点成功
+            step2InitLog.value.push({
+              type: 'info',
+              log: newValue.data + '模型一致性检验成功!',
+            })
+          }else if (newValue.code == 10201) {
+              step2.value = 'process'
+              step2InitLog.value = [{
+                type: 'wait',
+                log: '正在进行模型一致性校验.....',
+              }];
+          } else if (newValue.code == 25002) { //单个监测点失败
+            step2InitLog.value.push({
+              type: 'error',
+              log: newValue.data +'模型一致性检验失败!',
+            })
+          }else if (newValue.code == 25001) { //最终成功
+            step2.value = 'success'
+            step3.value = 'process'
+            activeIndex.value = 2
+          }else if (newValue.code == 25003) { //最终失败
+             step2.value = 'error'
+             ts.value = 'error'
+             step5.value = 'error'
+          }
+          break;
+        }
+      break;
+      case 'yjc_align':
+        switch (newValue.operateCode){
+          case 'DATA_REQUEST$02': 
+            if (newValue.code == 10200) { //单个监测点成功
+                step3InitLog.value.push({
+                  type: 'info',
+                  log: newValue.data +'实时数据对齐检验成功!',
+                })
+            }else if (newValue.code == 10201) {
+              step3.value = 'process'
+              step3InitLog.value = [{
+                type: 'wait',
+                log: '正在进行实时数据对齐检验.....',
+              }];
+            }else if (newValue.code == 25002) { //单个监测点失败
+       
+               step3InitLog.value.push({
+                  type: 'error',
+                  log: newValue.data + '实时数据对齐检验失败!',
+               })
+            }else if (newValue.code == 25001 && newValue.data) { //最终成功
+              isShowDialog.value = true
+              step3.value = 'success'
+              step4.value = 'process'
+              activeIndex.value = 3
+              testDataStructure.value = newValue.data
+            }else if (newValue.code == 25003) { //最终失败
+         
+              isShowDialog.value = true
+              step3.value = 'error'
+              ts.value = 'error'
+              step5.value = 'error'
+              testDataStructure.value = newValue.data
+            }
+            break;
+        }
+      break;
+      case 'YJC_xujy':
+        switch (newValue.operateCode) {
+          case 'DATA_REQUEST$02':
+            if (newValue.code == 10200) {
+              step4InitLog.value.push({
+                type: 'info',
+                log: newValue.data,
+              })
+            }else if (newValue.code == 10201) {
+              step4.value = 'process'
+              step4InitLog.value = [{
+                type: 'wait',
+                log: '正在进行相序性检.....',
+              }];
+            } else if(newValue.code == 25002){
+              step4InitLog.value.push({
+                type: 'error',
+                log: newValue.data,
+              })
+            } else if (newValue.code == 25003) {
+              step4InitLog.value.push({
+                type: 'error',
+                log: newValue.data,
+              })
+              step4.value = 'error'
+              ts.value = 'error'
+              step5.value = 'error'
+            } else if (newValue.code == 25001) {
+              step4.value = 'success'
+              step5.value = 'success'
+              ts.value = 'success'
+              activeIndex.value = 4
+            }
+            break
+        }
+        break;
+      case 'quit':
+        break;
+      case 'connect':
+        switch (newValue.operateCode) {
+          case "Contrast_Dev":
+            step1.value = 'error'
+            step1InitLog.value = [{
+              type: 'error',
+              log: '设备服务端连接失败!',
+            }];
+            ts.value = 'error'
+            step5.value = 'error'
+            break;
+        }
+        break;
+      case 'unknown_operate':
+
+        break;
+      case 'error_flow_end':
+        ElMessageBox.alert(`当前流程存在异常结束！`, '检测失败', {
+          confirmButtonText: '确定',
+          type: 'error',
+        })
+        ts.value = 'error'
+        step5.value = 'error'
+        break;
+      case 'socket_timeout':
+        ElMessageBox.alert(`设备连接异常，请检查设备连接情况！`, '检测失败', {
+          confirmButtonText: '确定',
+          type: 'error',
+        })
+        ts.value = 'error'
+        step5.value = 'error'
+        break;
+      case 'server_error':
+        ElMessageBox.alert('服务端主动关闭连接!', '初始化失败', {
+          confirmButtonText: '确定',
+          type: 'error',
+        })
+        ts.value = 'error'
+        step5.value = 'error'
+        break;
+      case 'device_error':
+        ElMessageBox.alert('设备主动关闭连接!', '初始化失败', {
+          confirmButtonText: '确定',
+          type: 'error',
+        })
+        ts.value = 'error'
+        step5.value = 'error'
+        break;
+      case 'yjc_xyjy' :
+        switch (newValue.operateCode) {
+          case 'INIT_GATHER$03':
+            if (newValue.code == 10552) { 
+                ElMessageBox.alert('重复的初始化操作!', '检测失败', {
+                  confirmButtonText: '确定',
+                  type: 'error',
+                })
+                ts.value = 'error'
+                step5.value = 'error'
+            }
+          
+        }
+        break;
+    }
+  }
+})
+
+// watch(activeIndex, function (newValue, oldValue) {
+//   if (newValue <= activeTotalNum.value - 2) {
+//     collapseActiveName.value = (newValue + 1).toString()
+//   } else {
+//     collapseActiveName.value = newValue.toString()
+//   }
+// })
+
+watch(activeIndex, function (newValue, oldValue) {
+  if(props.onlyWave === true)
+  {
+    if (Number(collapseActiveName.value) < activeTotalNum.value - 2) {
+      if(newValue == 2){
+            collapseActiveName.value = '4'
+      }else{
+            collapseActiveName.value = (newValue + 1).toString()
+      }
+    }
+  } else
+  { 
+    if (Number(collapseActiveName.value) < activeTotalNum.value) {
+      collapseActiveName.value = (newValue + 1).toString()
+    }
+
+  }
+})
+
+//监听goods_sn的变化
+watch(testStatus, function (newValue, oldValue) {
+  ts.value = props.testStatus;
+  if (ts.value === 'start') {
+    ts.value = 'process'
+  } else if (ts.value === 'waiting') {
+    activeIndex.value = 0
+    step1InitLog.value = [
+      {
+        type: 'info',
+        log: '暂无数据，等待检测开始',
+      },
+    ]
+    step1.value = 'finish'
+    step2.value = 'wait'
+    step3.value = 'wait'
+    step4.value = 'wait'
+    step5.value = 'wait'
+  }
+})
+
+
+const emit = defineEmits(['update:testStatus']);
+//监听sn
+watch(ts, function (newValue, oldValue) {
+  //修改父组件
+  emit('update:testStatus', ts.value)
+})
+
+// 定义一个初始化参数的方法
+function initializeParameters() {
+  activeIndex.value = 0
+  step1.value = 'wait'
+  step2.value = 'wait'
+  step3.value = 'wait'
+  step4.value = 'wait'
+  step5.value = 'wait'
+
+  step1InitLog.value = [
+    {
+      type: 'info',
+      log: '暂无数据，等待检测开始',
+    },
+  ]
+  step2InitLog.value = [
+    {
+      type: 'info',
+      log: '暂无数据，等待检测开始',
+    },
+  ]
+  step3InitLog.value = [
+    {
+      type: 'info',
+      log: '暂无数据，等待检测开始',
+    },
+  ]
+  step4InitLog.value = [
+    {
+      type: 'info',
+      log: '暂无数据，等待检测开始',
+    },
+  ]
+
+  // 清空实时数据对齐验证的数据
+
+  testDataStructure.value = {}
+  isShowDialog.value = false
+}
+
+const openDialog = () => { 
+
+  realTimeDataRef.value.open(props.mapping,testDataStructure.value)
+}
+
+defineExpose({
+  initializeParameters,
+});
+</script>
+<style scoped lang="scss">
+.title-icon {
+  margin-left: 10px;
+  cursor: pointer;
+  font-size: 16px;
+  vertical-align: middle;
+}
+
+.test-dialog {
+  height: 350px;
+  display: flex;
+  flex-direction: row;
+  /* 横向排列 */
+  margin-top: 20px;
+}
+
+.dialog-left {
+  width: 15%;
+  margin-left: 20px;
+}
+
+.dialog-right {
+  margin-left: 20px;
+  width: 80%;
+  height: 100%;
+}
+
+.dialog-right :deep(.el-collapse-item__header) {
+  font-size: 16px;
+}
+
+.div-log {
+  height: 145px;
+  overflow-y: auto;
+  padding-left: 10px;
+
+  p {
+    margin: 5px 0;
+    font-size: 14px;
+  }
+
+}
+</style>

frontend/src/views/home/components/compareTest.vue

@@ -0,0 +1,894 @@
+<template>
+  <div>
+    <div class="dialog" v-bind="dialogBig">
+      <div class="dialog-title">
+        <div class="timeView">
+          <el-icon style="margin: 0px 5px">
+            <Clock/>
+          </el-icon>
+          <span>检测用时：{{ timeView }}</span>
+        </div>
+        <el-progress style="width: 82%; margin-right: 3%" :percentage="percentage" :color="customColors"/>
+        <el-button style="width: 10%" type="text" :icon="InfoFilled" @click="showTestLog">检测项进度</el-button>
+      </div>
+      <div class="dialog-content">
+        <el-table
+            :data="checkResultView"
+            row-key="scriptType"
+            height="450px"
+            :header-cell-style="{ background: 'var(--el-color-primary)', color: '#eee', textAlign: 'center' }"
+            style="width: 100%"
+            border
+        >
+          <el-table-column
+              fixed
+              prop="scriptName"
+              label="检测项目"
+              width="150px"
+              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 checkStore.chnNumList"
+                  :key="`${item.deviceId}${chnItem}`"
+                  :label="'通道' + chnItem"
+                  align="center"
+              >
+                <template #default="{ row }">
+                  <el-tooltip
+                      :content="
+                                            row.devices[index1].chnResult[index2].icon === 'More'
+                                                ? '暂无数据'
+                                                : row.devices[index1].chnResult[index2].icon === 'CircleCheckFilled'
+                                                  ? '符合'
+                                                  : row.devices[index1].chnResult[index2].icon === 'Close'
+                                                    ? '不符合'
+                                                    : row.devices[index1].chnResult[index2].icon ===
+                                                        'WarnTriangleFilled'
+                                                      ? '数据异常'
+                                                      : row.devices[index1].chnResult[index2].icon === 'Loading'
+                                                        ? '检测中'
+                                                        : '连接中断'
+                                        "
+                      placement="right"
+                  >
+                    <el-button
+                        :disabled="
+                                                row.devices[index1].chnResult[index2].color ===
+                                                    CheckData.ButtonColorEnum.INFO ||
+                                                row.devices[index1].chnResult[index2].color ===
+                                                    CheckData.ButtonColorEnum.LOADING
+                                            "
+                        :color="row.devices[index1].chnResult[index2].color"
+                        size="small"
+                        @click="handleClick(row, chnItem, row.scriptType)"
+                        style="align-self: center"
+                    >
+                      <el-icon
+                          v-if="row.devices[index1].chnResult[index2].icon === 'Loading'"
+                          class="loading-box"
+                          style="color: #fff"
+                      >
+                        <component :is="Loading"/>
+                      </el-icon>
+                      <el-icon v-else style="color: #fff">
+                        <component :is="row.devices[index1].chnResult[index2].icon"/>
+                      </el-icon>
+                    </el-button>
+                  </el-tooltip>
+                </template>
+              </el-table-column>
+            </el-table-column>
+          </template>
+        </el-table>
+      </div>
+    </div>
+    <div class="drawer-container">
+      <el-drawer v-model="drawer" title="检测项进度" direction="btt" :size="'38%'">
+        <div ref="scrollContainerRef" style="height: 100%; overflow-y: auto">
+          <p
+              v-for="(item, index) in testLogList"
+              :key="index"
+              :style="{
+                            color:
+                                item.type === 'error'
+                                    ? '#F56C6C'
+                                    : item.type === 'warning'
+                                      ? '#e6a23c'
+                                      : 'var(--el-text-color-regular)'
+                        }"
+          >
+            {{ item.log }}
+            <br/>
+          </p>
+        </div>
+      </el-drawer>
+    </div>
+
+    <CompareDataCheckSingleChannelSingleTestPopup
+        ref="dataCheckSingleChannelSingleTestPopupRef"
+        :append-to-body="true"
+    />
+  </div>
+</template>
+<script lang="tsx" setup name="test">
+import {InfoFilled, Loading} from '@element-plus/icons-vue'
+import CompareDataCheckSingleChannelSingleTestPopup from './compareDataCheckSingleChannelSingleTestPopup.vue'
+import {computed, ComputedRef, nextTick, onBeforeMount, onMounted, reactive, ref, toRef, watch} from 'vue'
+import {dialogBig} from '@/utils/elementBind'
+import {CheckData} from '@/api/check/interface'
+import {useCheckStore} from '@/stores/modules/check'
+import {ElMessage, ElMessageBox} from 'element-plus'
+import {getBigTestItem} from '@/api/check/test'
+import {getAutoGenerate} from '@/api/user/login'
+import {useModeStore} from '@/stores/modules/mode' // 引入模式 store
+import {useDictStore} from '@/stores/modules/dict'
+
+const checkStore = useCheckStore()
+const modeStore = useModeStore()
+const dictStore = useDictStore()
+// 最大通道数
+const MAX_CHN_SUM = 12
+
+// 总测试项数
+let checkTotal = 0
+
+const props = defineProps({
+  testStatus: {
+    type: String,
+    default: 'waiting'
+  },
+  stepsActive: {
+    type: Number
+  },
+  webMsgSend: {
+    type: Object,
+    default: () => ({})
+  }
+})
+
+const emit = defineEmits([
+  'update:testStatus',
+  'update:webMsgSend',
+  'sendPause',
+  'sendResume',
+  'sendReCheck',
+  'closeWebSocket'
+])
+
+// 用来保存测试项进度抽屉是否打开
+const drawer = ref(false)
+// 进度条颜色
+const customColors = [{color: '#91cc75', percentage: 100}]
+// 检测脚本数据
+let scriptData: CheckData.ScriptItem[] = []
+// 用来保存被检设备
+const deviceList = reactive<CheckData.Device[]>([])
+// 当前进行的测试项索引
+let activeIndex = 0
+// 百分比
+const percentage = ref(0)
+// 时间计数器
+let timer: any = null
+const timeCount = ref(0)
+const timeView = ref('00:00:00')
+//测试项开始检测时间（或继续检测时间）
+const startData = ref(new Date())
+//测试项检测结束时间（或暂停时的时间）
+const endData = ref(new Date())
+const timeDifference = ref(0)
+// 真正的检测结果（详细到通道）
+const checkResult = reactive<CheckData.ScriptChnItem[]>([])
+// 用来存放检测出现失败的测试项id。只要有一个通道检测不合格，则该检测项的id会被加入该数组。
+let errorCheckItem: Array<{ scriptType: string; type: CheckData.ChnCheckResultEnum }> = []
+// 用来存放检测日志
+const testLogList = reactive<CheckData.LogItem[]>([{type: 'info', log: '暂无数据，等待检测开始'}])
+// 添加一个响应式变量来跟踪是否需要显示录波项目
+const showWaveItem = ref(false)
+const testStatus = toRef(props, 'testStatus')
+const webMsgSend = toRef(props, 'webMsgSend')
+
+const scrollContainerRef = ref()
+const dataCheckSingleChannelSingleTestPopupRef =
+    ref<InstanceType<typeof CompareDataCheckSingleChannelSingleTestPopup>>()
+
+// 总通道数
+const chnSum = computed(() => {
+  let sum = 0
+  deviceList.forEach(item => {
+    sum += item.chnNum
+  })
+  return sum
+})
+
+// 用来展示的检测结果
+const checkResultView: ComputedRef<CheckData.ScriptChnViewItem[]> = computed(() => {
+  let result: CheckData.ScriptChnViewItem[] = checkResult.map(item => {
+    let temp: CheckData.ScriptChnViewItem = {
+      scriptType: item.scriptType,
+      scriptName: item.scriptName,
+      devices: []
+    }
+    item.devices.forEach(device => {
+      let tempChnBtnResult: CheckData.ButtonResult[] = []
+
+      if (chnSum.value <= MAX_CHN_SUM) {
+        for (let j = 0; j < device.chnResult.length; j++) {
+          switch (device.chnResult[j]) {
+            case CheckData.ChnCheckResultEnum.UNKNOWN:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.INFO, icon: 'More'})
+              break
+            case CheckData.ChnCheckResultEnum.LOADING:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.LOADING, icon: 'Loading'})
+              break
+            case CheckData.ChnCheckResultEnum.SUCCESS:
+              tempChnBtnResult.push({
+                color: CheckData.ButtonColorEnum.SUCCESS,
+                icon: 'CircleCheckFilled'
+              })
+              break
+            case CheckData.ChnCheckResultEnum.FAIL:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.DANGER, icon: 'Close'})
+              break
+            case CheckData.ChnCheckResultEnum.TIMEOUT:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.WARNING, icon: 'Link'})
+              break
+            case CheckData.ChnCheckResultEnum.ERRORDATA:
+              tempChnBtnResult.push({
+                color: CheckData.ButtonColorEnum.WARNING,
+                icon: 'WarnTriangleFilled'
+              })
+              break
+            case CheckData.ChnCheckResultEnum.NOT_PART_IN_ERROR:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.INFO, icon: 'Minus'})
+              break
+            default:
+              break
+          }
+        }
+      }
+
+      temp.devices.push({
+        deviceId: device.deviceId,
+        deviceName: device.deviceName,
+        chnResult: tempChnBtnResult
+      })
+    })
+    return temp
+  })
+  return result
+})
+
+watch(testStatus, function (newValue, oldValue) {
+  if (newValue == 'start' || newValue == 'waiting') {
+    if (!checkStore.selectTestItems.preTest && !checkStore.selectTestItems.channelsTest) {
+      ElMessage.success('初始化开始!')
+      emit('update:testStatus', 'test_init')
+      if (checkStore.selectTestItems.test && checkStore.selectTestItems.preTest) {
+        testLogList.push({type: 'info', log: `${new Date().toLocaleString()}：初始化开始！`})
+      }
+    } else {
+      emit('update:testStatus', 'process')
+    }
+    // 开始计时
+    startTimeCount()
+    showTestLog()
+
+    //startTimer() // todo 可移除
+    startData.value = new Date()
+    timeDifference.value = 0
+  } else if (newValue == 'error') {
+    stopTimeCount()
+  }
+})
+
+watch(
+    webMsgSend,
+    function (newValue, oldValue) {
+       switch (newValue.requestId) {
+        case 'record_wave_step1':
+            switch (newValue.code) {
+              case 10200:
+                setLogList('info', newValue.data)
+                break
+              case 25002:
+                setLogList('error', newValue.data)
+                break
+              case 25003:
+                ElMessageBox.alert('录波对齐失败!', {
+                    confirmButtonText: '确定',
+                    type: 'error'
+                })
+                stopTimeCount()
+                break
+              case 25001: {
+                // 当录波校验完成时，更新录波项目的按钮状态
+                setLogList('info', '录波校验完成！')
+                 // 解析返回的数据
+                const waveData = JSON.parse(newValue.data)
+                // 找到录波项目并更新其状态
+                const waveResultItem = checkResult.find(item => item.scriptType === 'wave_data')
+                // if (waveResultItem) {
+                //   // 将录波项目状态设置为SUCCESS
+                //   waveResultItem.devices.forEach(device => {
+                //     device.chnResult.fill(CheckData.ChnCheckResultEnum.SUCCESS)
+                //   })
+                // }
+                if (waveResultItem) {
+                  // 根据返回的chnResult更新各个设备的通道状态
+                  waveResultItem.devices.forEach(device => {
+                    const deviceData = waveData.find((d: any) => d.deviceId === device.deviceId)
+                    if (deviceData) {
+                      // 根据实际返回的chnResult更新状态
+                      deviceData.chnResult.forEach((result: number, index: number) => {
+                        // 创建数字到枚举的映射
+                      const resultMap: { [key: number]: CheckData.ChnCheckResultEnum } = {
+                        1: CheckData.ChnCheckResultEnum.SUCCESS,
+                        2: CheckData.ChnCheckResultEnum.FAIL,
+                        3: CheckData.ChnCheckResultEnum.TIMEOUT,
+                        4: CheckData.ChnCheckResultEnum.ERRORDATA,
+                        5: CheckData.ChnCheckResultEnum.NOT_PART_IN_ERROR
+                      }
+                      
+                      // 使用映射关系设置状态，如果没有对应的映射则设为UNKNOWN
+                      device.chnResult[index] = resultMap[result] || CheckData.ChnCheckResultEnum.UNKNOWN
+                      })
+                    }
+                  })
+                }
+                // 触发响应式更新
+                checkResult.splice(0, 0) 
+                stopTimeCount()
+                updatePercentage()
+                break
+              }
+            }
+          break
+        case 'connect':
+          switch (newValue.operateCode) {
+            case 'Contrast_Dev':
+              setLogList('error', '设备服务端连接失败!')
+              stopTimeCount()
+              break
+          }
+          break
+        case 'unknown_operate':
+          break
+        case 'error_flow_end':
+          ElMessageBox.alert(`当前流程存在异常结束！`, '检测失败', {
+            confirmButtonText: '确定',
+            type: 'error'
+          })
+          setLogList('error', '当前流程存在异常结束！')
+          stopTimeCount()
+          break
+        case 'socket_timeout':
+          ElMessageBox.alert(`设备连接异常，请检查设备连接情况！`, '检测失败', {
+            confirmButtonText: '确定',
+            type: 'error'
+          })
+          setLogList('error', '设备连接异常，请检查设备连接情况！')
+          stopTimeCount()
+          break
+        case 'server_error':
+          ElMessageBox.alert('服务端主动关闭连接!', '初始化失败', {
+            confirmButtonText: '确定',
+            type: 'error'
+          })
+          setLogList('error', '服务端主动关闭连接!')
+          stopTimeCount()
+          break
+        case 'device_error':
+          ElMessageBox.alert('设备主动关闭连接!', '初始化失败', {
+            confirmButtonText: '确定',
+            type: 'error'
+          })
+          setLogList('error', '设备主动关闭连接!')
+          stopTimeCount()
+          break
+        case 'yjc_xyjy' :
+          switch (newValue.operateCode) {
+            
+              case 'INIT_GATHER$03':
+                if (newValue.code == 10552) {
+                ElMessageBox.alert('重复的初始化操作!', '检测失败', {
+                    confirmButtonText: '确定',
+                    type: 'error',
+                  })
+                setLogList('error', '重复的初始化操作!')
+                stopTimeCount()
+              }   
+          }
+          break;  
+         case 'yjc_sbtxjy' :
+          switch (newValue.operateCode) {
+              case 'INIT_GATHER$02':
+                ElMessageBox.alert('重复的初始化操作!', '检测失败', {
+                  confirmButtonText: '确定',
+                  type: 'error',
+                })
+              setLogList('error', '重复的初始化操作!')
+              stopTimeCount()
+          }
+          break; 
+      }
+      if (checkStore.selectTestItems.preTest == false && newValue.requestId != 'formal_real') {
+        if (testLogList[0].log == '正在检测,请稍等...' || testLogList[0].log == '暂无数据，等待检测开始') {
+          testLogList.shift()
+          setLogList('info', '初始化开始!')
+        }
+        let str =
+            newValue.requestId == 'yjc_sbtxjy'
+                ? '设备通讯校验'
+                : newValue.requestId == 'yjc_mxyzxjy'
+                    ? '模型一致性检验'
+                    : newValue.requestId == 'yjc_align'
+                        ? '实时数据对齐检验'
+                        : newValue.requestId == 'YJC_xujy'
+                            ? '相序校验'
+                            : ''
+        // 预检测处理
+        switch (newValue.code) {
+          case 25001:
+            //  成功
+            if (newValue.data != undefined) return
+            setLogList('info', str + '成功!')
+            if (newValue.requestId == 'YJC_xujy') setLogList('info', '初始化成功!')
+            break
+          case 25003:
+            //  失败
+            if (newValue.data != undefined) return
+            setLogList('error', str + '失败!')
+            emit('update:testStatus', 'error')
+            stopTimeCount()
+            if (newValue.requestId == 'YJC_xujy') setLogList('info', '初始化失败!')
+            break
+
+        }
+      }
+      // 预监测 正式检测
+      else if (newValue.requestId == 'formal_real') {
+        if (testLogList[0].log == '正在检测,请稍等...' || testLogList[0].log == '暂无数据，等待检测开始') {
+          testLogList.shift()
+        }
+        switch (newValue.code) {
+          case 25001:
+          case 25005:
+            {
+                let result: CheckData.ScriptChnItem[] = []
+        
+                let message = JSON.parse(newValue.data)
+                // 当收到 25005 消息时，录波项目开始loading
+                if (newValue.code == 25005) {
+                  // 设置录波项目为LOADING状态
+                  const waveResultItem = checkResult.find(item => item.code === 'wave_data')
+                
+                  if (waveResultItem) {
+                    waveResultItem.devices.forEach(device => {
+                      device.chnResult.fill(CheckData.ChnCheckResultEnum.LOADING)
+                    })
+                  }
+              
+                }
+                scriptData.forEach(item => {
+                  // 处理当前节点的数据
+                  const temp: CheckData.ScriptChnItem = {
+                    scriptType: item.id,
+                    scriptName: item.scriptName,
+                    devices: []
+                  }
+               
+                  // 特殊处理录波项目 - 如果是25005消息且当前项目是录波项目，则使用已设置的状态
+                  if (newValue.code == 25005 && item.code === 'wave_data') {
+                    const existingWaveItem = checkResult.find(checkItem => checkItem.scriptType === 'wave_data')
+                    if (existingWaveItem) {
+                      temp.devices = [...existingWaveItem.devices] // 保留已设置的devices
+                    }
+                  } else {
+                    // 找到message中所有scriptName与当前item.code匹配的项
+                    const matchedDevices = message
+                        .filter((msg: any) => msg.scriptName === item.code)
+                        .map((msg: any) => ({
+                          deviceId: msg.deviceId,
+                          deviceName: msg.deviceName,
+                          chnResult: msg.chnResult
+                        }))
+
+                    // 添加匹配到的设备
+                    temp.devices.push(...matchedDevices)
+
+                    // 对于未匹配到的设备，也要添加占位符（特别是录波项目）
+                    if (item.code === 'wave_data') {
+                        deviceList.forEach(device => {
+                            const isDeviceExist = matchedDevices.some((matchedDevice: any) => matchedDevice.deviceId === device.deviceId)
+                            if (!isDeviceExist) {
+                                // 对于录波项目或未匹配到的设备，添加默认状态
+                                temp.devices.push({
+                                    deviceId: device.deviceId,
+                                    deviceName: device.deviceName,
+                                    chnResult: new Array(checkStore.chnNumList.length).fill(
+                                        item.code === 'wave_data' ? 
+                                        CheckData.ChnCheckResultEnum.UNKNOWN : 
+                                        CheckData.ChnCheckResultEnum.UNKNOWN
+                                    )
+                                })
+                            }
+                        })
+                    }
+                  }
+                  result.push(temp)
+                })
+
+                Object.assign(checkResult, result)
+                if (newValue.code == 25001) {
+                  setLogList('info', '检测完成！')
+                  stopTimeCount()
+                  updatePercentage()
+                }
+                if(newValue.code ==  25005){
+                  setLogList("error", '实时数据校验失败！开始录波校验...')
+                }
+                break
+            }
+           
+          case 25003:
+            setLogList('error', '检测失败！')
+            stopTimeCount()
+            updatePercentage()
+            break
+          default:
+            if (newValue.code != 10201) {
+              setLogList(newValue.code == 10200 ? 'info' : 'error', newValue.data)
+            }
+
+            break
+        }
+      }
+    },
+    {deep: true}
+)
+const setLogList = (state: 'error' | 'info' | 'warning', text: string) => {
+  testLogList.push({
+    type: state,
+    log: `${new Date().toLocaleString()}：` + text
+  })
+}
+
+// 更新进度条
+const updatePercentage = async () => {
+  if (testLogList.length - 1 < checkStore.chnNumList.length) {
+    percentage.value = Math.trunc(((testLogList.length - 1) / checkStore.chnNumList.length) * 100)
+  } else {
+    percentage.value = 100
+    emit('update:testStatus', 'success')
+
+    let {data: autoGenerate} = await getAutoGenerate()
+    if (autoGenerate == 1) {
+      //调用自动生成报告接口
+      let devIdList = checkStore.devices.map(item => {
+        return item.deviceId
+      })
+
+      // await generateDevReport({
+      //     planId: checkStore.plan.id,
+      //     devIdList: devIdList,
+      //     scriptId: checkStore.plan.scriptId,
+      //     planCode: checkStore.plan.code + ''
+      // })
+    }
+    stopTimeCount()
+    ElMessageBox.alert(
+        '检测全部结束,你可以停留在此页面查看检测结果，或返回首页进行复检、报告生成和归档等操作',
+        '检测完成',
+        {
+          confirmButtonText: '确定'
+        }
+    )
+    // 关闭WebSocket连接
+    emit('closeWebSocket')
+    //clear();
+  }
+}
+// ========== 时间计数器管理函数 ==========
+// 开始计时
+const startTimeCount = () => {
+  if (!timer) {
+    timer = setInterval(() => {
+      timeCount.value = timeCount.value + 1
+      timeView.value = secondToTime(timeCount.value)
+    }, 1000)
+  }
+  nextTick(() => {
+    setTimeout(() => {
+      initCheckResult(CheckData.ChnCheckResultEnum.LOADING)
+    }, 500)
+  })
+}
+
+// 停止计时
+const stopTimeCount = () => {
+  if (timer) {
+    clearInterval(timer)
+    timer = null
+  }
+}
+
+// 将秒数转换为 HH:MM:SS 格式
+const secondToTime = (second: number) => {
+  let h: string | number = Math.floor(second / 3600) // 小时
+  let m: string | number = Math.floor((second - h * 3600) / 60) // 分钟
+  let s: string | number = Math.floor(second % 60) // 秒
+
+  // 补齐前导零
+  h = h < 10 ? '0' + h : h
+  m = m < 10 ? '0' + m : m
+  s = s < 10 ? '0' + s : s
+  return h + ':' + m + ':' + s
+}
+
+onBeforeMount(async () => {
+})
+
+const showTestLog = () => {
+  drawer.value = true
+}
+
+// 初始化检测脚本数据
+const initScriptData = async () => {
+  scriptData = []
+  const pattern = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? ''
+  let response: any = await getBigTestItem({
+    reCheckType: checkStore.reCheckType,
+    planId: checkStore.plan.id,
+    devIds: checkStore.devices.map(item => item.deviceId),
+    patternId: pattern
+  })
+   // 格式化脚本数据，初始化时排除录波项目
+  let temp = response.data
+    .map((item: any) => {
+      return {
+        ...item,
+        scriptName: item.scriptName
+      }
+    })
+
+  // 保存脚本数据并设置总数
+  scriptData.push(...temp)
+  checkTotal = scriptData.length
+  console.log('shul',checkTotal)
+}
+// 初始化设备列表
+const initDeviceList = () => {
+  Object.assign(deviceList, checkStore.devices)
+}
+
+// 初始化检测结果 （详细到通道）
+const initCheckResult = (defaultValue: CheckData.ChnCheckResultEnum) => {
+  let result: CheckData.ScriptChnItem[] = []
+
+  scriptData.forEach(item => {
+    let temp: CheckData.ScriptChnItem = {
+      scriptType: item.id,
+      code: item.code,
+      scriptName: item.scriptName,
+      devices: []
+    }
+
+    for (let i = 0; i < deviceList?.length; i++) {
+      let tempChnResult: CheckData.ChnCheckResultEnum[] = []
+      for (let j = 0; j < checkStore.chnNumList.length; j++) {
+        // 录波项目初始化为UNKNOWN状态，其他项目使用传入的默认值
+        if (item.code === 'wave_data' && checkTotal > 1) {
+          tempChnResult.push(CheckData.ChnCheckResultEnum.UNKNOWN)
+        } else {
+          tempChnResult.push(defaultValue)
+        }
+      }
+      temp.devices.push({
+        deviceId: deviceList[i].deviceId,
+        deviceName: deviceList[i].deviceName,
+        chnResult: tempChnResult
+      })
+    }
+    result.push(temp)
+  })
+
+  Object.assign(checkResult, result)
+}
+
+const scrollToBottom = () => {
+  if (scrollContainerRef.value) {
+    scrollContainerRef.value.scrollTop = scrollContainerRef.value.scrollHeight + 70
+  }
+}
+
+watch(
+    testLogList,
+    () => {
+      scrollToBottom()
+    },
+    {deep: true}
+)
+
+// 点击查看（设备）通道检测详情。参数1：设备信息，参数2：通道号，-1：代表查看全部通道
+const handleClick = (item: any, chnNum: number, scriptType: string) => {
+  let checkResultItem = checkResult.find(obj => obj.scriptType === scriptType)
+  
+  let flag = -1
+  if (checkResultItem) {
+    let device = checkResultItem.devices.find(obj => obj.deviceId === item.deviceId)
+    if (device) {
+      let chnResult = device.chnResult
+      if (chnNum === -1) {
+        if (chnResult.findIndex(obj => obj === CheckData.ChnCheckResultEnum.TIMEOUT) !== -1) {
+          flag = 0
+        }
+        if (chnResult.findIndex(obj => obj === CheckData.ChnCheckResultEnum.ERRORDATA) !== -1) {
+          flag = 1
+        }
+      } else {
+        if (chnResult[chnNum - 1] === CheckData.ChnCheckResultEnum.TIMEOUT) {
+          flag = 0
+        }
+        if (chnResult[chnNum - 1] === CheckData.ChnCheckResultEnum.ERRORDATA) {
+          flag = 1
+        }
+      }
+    }
+  }
+
+  if (flag === 0) {
+    ElMessageBox.alert('连接超时，请检查设备通讯是否正常', '连接超时', {
+      confirmButtonText: '确定',
+      type: 'warning'
+    })
+  }
+  if (flag === -1 || flag === 1) {
+    checkStore.setShowDetailType(2)
+
+    dataCheckSingleChannelSingleTestPopupRef.value?.open(item, chnNum + '', item.devices[0].deviceId, 1)
+  }
+}
+
+const handlePause = () => {
+  //emit('sendPause')
+  testLogList.push({
+    type: 'error',
+    log: `${new Date().toLocaleString()}：当前测试小项正在执行中，将在该小项执行结束后暂停...`
+  })
+}
+const initializeParameters = async () => {
+  await initScriptData()
+  initDeviceList()
+  initCheckResult(CheckData.ChnCheckResultEnum.UNKNOWN)
+  percentage.value = 0
+  timeCount.value = 0
+  timeView.value = '00:00:00'
+  testLogList.splice(0, testLogList.length, {
+    type: 'info',
+    log: checkStore.selectTestItems.preTest ? '正在检测,请稍等...' : '暂无数据，等待检测开始'
+  })
+}
+
+//
+onMounted(() => {
+
+  if (!checkStore.selectTestItems.preTest) {
+    // 判断是否预检测
+    initializeParameters()
+  }
+})
+
+defineExpose({
+  initializeParameters,
+  handlePause,
+  showTestLog,
+  startTimeCount
+})
+</script>
+
+<style scoped lang="scss">
+:deep(.el-table .header-row) {
+  background-color: #f5f7fa;
+}
+
+:deep(.el-table .warning-row) {
+  color: red;
+}
+
+.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;
+
+  .timeView {
+    display: flex;
+    align-items: center;
+    color: #91cc75;
+    width: 28%;
+    margin-right: 0px;
+    text-align: left;
+    font-size: 26px;
+    font-weight: bold;
+  }
+}
+
+.dialog-content {
+  max-height: 450px;
+  overflow-y: hidden;
+}
+
+:deep(.el-collapse-item__header) {
+  height: 30px;
+}
+
+.dialog-log {
+  height: 50px;
+  overflow-y: hidden;
+
+  p {
+    margin: 5px 0;
+    font-size: 14px;
+  }
+}
+
+.drawer-container {
+  :deep(header.el-drawer__header) {
+    color: #fff !important;
+    background-color: var(--el-color-primary) !important;
+
+    .el-drawer__close-btn svg:hover {
+      color: #ccc !important;
+    }
+
+    .el-drawer__title {
+      color: #fff !important;
+    }
+  }
+}
+
+.loading-box {
+  animation: loading 1.5s linear infinite;
+}
+
+@keyframes loading {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+</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>

frontend/src/views/home/components/compareTestPopup.vue

@@ -0,0 +1,700 @@
+<template>
+    <el-dialog
+        :title="dialogTitle"
+        width="1550px"
+        :model-value="dialogVisible"
+        :before-close="beforeClose"
+        @close="handleClose"
+        height="1000px"
+        draggable
+    >
+        <div class="steps-container">
+            <el-steps
+                v-if="showSteps"
+                class="test-head-steps"
+                simple
+                :active="stepsActiveIndex"
+                process-status="finish"
+                finish-status="success"
+            >
+                <el-step
+                    title="通道配对"
+                    :icon="stepsActive > 0 || stepsActiveIndex > stepsTotalNum - 1 ? SuccessFilled : Switch"
+                    @click="handleStepClick(0)"
+                />
+                <el-step
+                    v-if="preTestSelected"
+                    title="预检测"
+                    :icon="stepsActive > 1 || stepsActiveIndex > stepsTotalNum - 1 ? SuccessFilled : Edit"
+                    @click="handleStepClick(1)"
+                />
+
+                <el-step
+                    v-if="testSelected"
+                    title="正式检测"
+                    :icon="stepsActive > 2 || stepsActiveIndex > stepsTotalNum - 1 ? SuccessFilled : Coin"
+                    @click="handleStepClick(2)"
+                />
+                <el-step title="检测完成" :icon="stepsActiveIndex > stepsTotalNum - 1 ? SuccessFilled : Key" />
+            </el-steps>
+        </div>
+        <keep-alive>
+            <ChannelPairing
+                v-if="stepsActiveView == 0"
+                ref="channelPairingRef"
+                :devIdList="prop.devIdList"
+                :pqStandardDevList="prop.pqStandardDevList"
+                :planIdKey="prop.planIdKey"
+                :deviceMonitor="deviceMonitor2"
+            />
+        </keep-alive>
+        <keep-alive>
+            <ComparePreTest
+                v-if="preTestSelected && stepsActiveView == 1"
+                ref="preTestRef"
+                v-model:testStatus="preTestStatus"
+                :webMsgSend="webMsgSend"
+                :mapping="channelMapping"
+                :onlyWave="onlyWave"
+            />
+        </keep-alive>
+        <keep-alive>
+            <CompareTest
+                v-if="testSelected && stepsActiveView == 2"
+                ref="testRef"
+                :webMsgSend="webMsgSend"
+                v-model:testStatus="TestStatus"
+                :stepsActive="stepsActive"
+            />
+        </keep-alive>
+
+        <template #footer>
+            <div>
+                <el-button
+                    type="primary"
+                    :icon="VideoPlay"
+                    v-if="ActiveStatue === 'waiting' && !(testSelected && stepsActiveIndex == 2)"
+                    @click="handleSubmitFast"
+                >
+                    开始检测
+                </el-button>
+                <!-- <el-button type="primary" v-if="TestStatus === 'test_init'" disabled>
+                    <el-icon class="loading-box" style="color: #fff; margin-right: 8px">
+                        <component :is="Refresh" />
+                    </el-icon>
+                    初始化中
+                </el-button> -->
+                <el-button type="primary" v-if="TestStatus == 'process'" :icon="VideoPause" @click="handlePause()">
+                    停止检测
+                </el-button>
+                <el-button type="warning" v-if="TestStatus === 'paused_ing'" disabled>
+                    <el-icon class="loading-box" style="color: #fff; margin-right: 8px">
+                        <component :is="Refresh" />
+                    </el-icon>
+                    暂停中
+                </el-button>
+                <el-button type="warning" v-if="TestStatus == 'paused'" :icon="VideoPlay" @click="sendResume">
+                    继续检测
+                </el-button>
+                <el-button
+                    type="warning"
+                    :icon="VideoPlay"
+                    v-if="
+                        nextStepText !== '下一步' &&
+                        (ActiveStatue === 'success' ||
+                            ActiveStatue === 'error' ||
+                            ActiveStatue === 'test_init_fail' ||
+                            ActiveStatue === 'connect_timeout' ||
+                            ActiveStatue === 'pause_timeout' ||
+                            ActiveStatue === 'waiting')
+                    "
+                    @click="handleSubmitAgain"
+                >
+                    重新检测
+                </el-button>
+                <el-button
+                    :type="ActiveStatue === 'success' ? 'primary' : 'danger'"
+                    :icon="Right"
+                    v-if="
+                        nextStepText !== '下一步' &&
+                        (ActiveStatue === 'success' ||
+                            ActiveStatue === 'error' ||
+                            ActiveStatue === 'test_init_fail' ||
+                            ActiveStatue === 'connect_timeout' ||
+                            ActiveStatue === 'pause_timeout')
+                    "
+                    @click="nextStep"
+                >
+                    {{ nextStepText }}
+                </el-button>
+                <el-button type="primary" @click="handleQuit" v-else>退出检测</el-button>
+            </div>
+        </template>
+    </el-dialog>
+</template>
+
+<script lang="tsx" setup name="testPopup">
+import { nextTick, PropType, reactive, ref, watch } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import {
+    Coin,
+    Edit,
+    Key,
+    Switch,
+    Refresh,
+    Right,
+    SuccessFilled,
+    UploadFilled,
+    VideoPause,
+    VideoPlay
+} from '@element-plus/icons-vue'
+import ComparePreTest from './comparePreTest.vue'
+import ChannelPairing from './channelPairing.vue'
+import { Device } from '@/api/device/interface/device'
+import CompareTest from './compareTest.vue'
+import socketClient from '@/utils/webSocketClient'
+import { useCheckStore } from '@/stores/modules/check'
+import { pauseTest, resumeTest, startPreTest, contrastTest } from '@/api/socket/socket'
+import { useUserStore } from '@/stores/modules/user'
+import { JwtUtil } from '@/utils/jwtUtil'
+import { StandardDevice } from '@/api/device/interface/standardDevice'
+
+const userStore = useUserStore()
+const checkStore = useCheckStore()
+const nextStepText = ref('下一步')
+const dialogVisible = ref(false)
+const channelPairingRef = ref()
+const showSteps = ref(false)
+
+const stepsTotalNum = ref(-1) //步骤总数
+const stepsActiveIndex = ref(0) //当前正在执行的步骤索引
+const stepsActiveView = ref(1) //当前正在执行的步骤在（预处理、守时校验、系数校准、正式检测）中的排序，仅用于页面显示
+const stepsActive = ref(-1) //当前正在执行的步骤在（预处理、守时校验、系数校准、正式检测）中的排序，实际记录步骤的状态，用于切换步骤
+const ActiveStatue = ref('waiting') //当前步骤状态
+const preTestStatus = ref('waiting') //预检测执行状态
+const TestStatus = ref('waiting') //正式检测执行状态
+const webMsgSend = ref() //webSocket推送的数据
+
+const dialogTitle = ref('')
+const showComponent = ref(true)
+const preTestRef = ref<InstanceType<typeof ComparePreTest> | null>(null)
+const testRef: any = ref(null)
+
+const prop = defineProps({
+    devIdList: {
+        type: Array as any,
+        default: []
+    },
+    pqStandardDevList: {
+        type: Array as any,
+        default: []
+    },
+    planIdKey: {
+        type: String,
+        default: ''
+    }
+})
+const dataSocket = reactive({
+    socketServe: socketClient.Instance
+})
+
+// 勾选的检测内容
+const preTestSelected = ref(true)
+const testSelected = ref(false)
+
+const initOperate = () => {
+    ActiveStatue.value = 'waiting'
+    preTestStatus.value = 'waiting'
+
+    TestStatus.value = 'waiting'
+
+    stepsActiveIndex.value = 0
+    showComponent.value = true
+    // 初始化勾选的检测内容
+    preTestSelected.value = checkStore.selectTestItems.preTest
+    testSelected.value = checkStore.selectTestItems.test
+
+    let count = 0
+    for (let key in checkStore.selectTestItems) {
+        if (checkStore.selectTestItems[key]) {
+            count++
+        }
+    }
+    stepsTotalNum.value = count + 1
+
+    if (preTestSelected.value) {
+        stepsActiveView.value = 0
+        stepsActive.value = 0
+        return
+    }
+    if (testSelected.value) {
+        stepsActiveView.value = 0
+        stepsActive.value = 0
+        return
+    }
+}
+
+const channelMapping = ref<Record<string, Record<string, string>>>({})
+const planId = ref('')
+const loginName = ref('')
+const devIds = ref<[]>()
+const standardDevIds = ref<[]>()
+const pairs = ref<any>()
+const testAgain = ref(false) //重新检测按钮是否显示
+const checkNumber = ref(0) //检测次数
+const deviceMonitor2= ref<Map<string, any[]>>();
+const onlyWave = ref(false);//计划数据源是否只有录波
+const open = async (
+    title: string,
+    mapping: any,
+    plan: string,
+    login: string,
+    devIdsArray: [],
+    standardDevIdsArray: [],
+    pair: any,
+    deviceMonitor:Map<string, any[]>,
+    planIsOnlyWave: boolean
+) => {
+    if (checkStore.selectTestItems.preTest && !checkStore.selectTestItems.test) {
+        testAgain.value = true
+    }
+    deviceMonitor2.value = deviceMonitor;
+    onlyWave.value = planIsOnlyWave;
+    checkStore.setNodesConnectable(true)
+    dialogTitle.value = title
+    channelMapping.value = mapping
+    planId.value = plan
+    loginName.value = login
+    devIds.value = devIdsArray
+    standardDevIds.value = standardDevIdsArray
+    pairs.value = pair
+    showSteps.value = true
+    initOperate()
+    dialogTitle.value = title
+    dialogVisible.value = true
+
+    // 等待组件渲染完成
+    await nextTick()
+
+    if (preTestRef.value) {
+        preTestRef.value.initializeParameters()
+    }
+
+    //开始创建webSocket客户端
+    socketClient.Instance.connect()
+    dataSocket.socketServe = socketClient.Instance
+    dataSocket.socketServe.registerCallBack('aaa', (res: { code: number }) => {
+        // console.log('Received message:', res)
+        // 处理来自服务器的消息
+        if (res.code === 20000) {
+            //ElMessage.error(message.message)
+            // loading.close()
+        } else {
+            webMsgSend.value = res
+        }
+    })
+}
+
+//预检测-重新检测
+const handleSubmitAgain = async () => {
+    if (checkStore.selectTestItems.preTest) {
+        stepsActiveIndex.value = 1
+        stepsActiveView.value = 1
+        stepsActive.value = 1
+    } else {
+        stepsActiveIndex.value = 1
+        stepsActiveView.value = 2
+        stepsActive.value = 2
+    }
+
+    let count = 0
+    for (let key in checkStore.selectTestItems) {
+        if (checkStore.selectTestItems[key]) {
+            count++
+        }
+    }
+    stepsTotalNum.value = count + 1
+
+    // 通知子组件清空并重新初始化
+    if (preTestRef.value) {
+        preTestRef.value.initializeParameters()
+    }
+    testRef.value && testRef.value.initializeParameters()
+
+    // 重置状态
+    nextStepText.value = '下一步'
+    ActiveStatue.value = 'waiting'
+    preTestStatus.value = 'waiting'
+    TestStatus.value = 'waiting'
+
+    await contrastTest({
+        planId: planId.value,
+        loginName: loginName.value,
+        devIds: devIds.value,
+        standardDevIds: standardDevIds.value,
+        pairs: pairs.value,
+        testItemList: [checkStore.selectTestItems.preTest, false, checkStore.selectTestItems.test],
+
+        userId: userStore.userInfo.id
+    })
+
+    preTestStatus.value = 'start'
+}
+
+//开始检测
+const handleSubmitFast = async () => {
+    if (channelPairingRef.value) {
+        const res = await channelPairingRef.value.handleNext()
+
+        if (!res) return
+        dialogTitle.value = res.title
+        channelMapping.value = res.mapping
+        planId.value = res.plan
+        loginName.value = res.login
+        devIds.value = res.devIdsArray
+        standardDevIds.value = res.standardDevIdsArray
+        pairs.value = res.pair
+        checkStore.setNodesConnectable(false)
+        // nodesConnectable.value = false
+    }
+    if (!dataSocket.socketServe.connected) {
+        ElMessage.error('webSocket连接中断！')
+        return
+    }
+    if (checkStore.selectTestItems.preTest) {
+        stepsActiveIndex.value = 1
+        stepsActiveView.value = 1
+        stepsActive.value = 1
+    } else {
+        stepsActiveIndex.value = 1
+        stepsActiveView.value = 2
+        stepsActive.value = 2
+    }
+
+    switch (stepsActive.value) {
+        case 1:
+            if (preTestStatus.value == 'waiting') {
+                if (checkStore.selectTestItems.preTest) {
+                    await contrastTest({
+                        planId: planId.value,
+                        loginName: loginName.value,
+                        devIds: devIds.value,
+                        standardDevIds: standardDevIds.value,
+                        pairs: pairs.value,
+                        testItemList: [checkStore.selectTestItems.preTest, false, checkStore.selectTestItems.test],
+
+                        userId: userStore.userInfo.id
+                    })
+                    preTestStatus.value = 'start'
+                    if (checkStore.selectTestItems.test) {
+                        console.log(111111)
+
+                        testRef.value.initializeParameters()
+                        testRef.value.showTestLog()
+                    }
+                }
+            }
+            break
+        case 2:
+            if (TestStatus.value == 'waiting') {
+                // 如果没有预检测,直接进行正式检测需要先初始化
+                if (!checkStore.selectTestItems.preTest && checkStore.selectTestItems.test) {
+                    await contrastTest({
+                        planId: planId.value,
+                        loginName: loginName.value,
+                        devIds: devIds.value,
+                        standardDevIds: standardDevIds.value,
+                        pairs: pairs.value,
+                        testItemList: [checkStore.selectTestItems.preTest, false, checkStore.selectTestItems.test],
+
+                        userId: userStore.userInfo.id
+                    })
+                }
+                TestStatus.value = 'start'
+            } else if (TestStatus.value == 'paused') {
+                // 发送继续指令
+                //sendResume()
+            }
+            break
+        default:
+            break
+    }
+}
+
+const emit = defineEmits<{
+    (e: 'quitClicked'): void
+}>()
+
+watch(preTestStatus, function (newValue, oldValue) {
+    console.log('预检测状态', newValue, oldValue)
+    ActiveStatue.value = newValue
+})
+
+watch(TestStatus, function (newValue, oldValue) {
+    console.log('正式检测状态', newValue, oldValue)
+
+    ActiveStatue.value = newValue
+})
+
+watch(stepsActiveIndex, function (newValue, oldValue) {
+    if (checkStore.selectTestItems.test && checkStore.selectTestItems.preTest && newValue == 2) {
+        setTimeout(() => {
+            testRef.value.initializeParameters()
+            testRef.value.showTestLog()
+            testRef.value.startTimeCount()
+        }, 500)
+    }
+    console.log('步骤索引', newValue, oldValue)
+})
+
+watch(ActiveStatue, function (newValue, oldValue) {
+    console.log('当前步骤状态-----', newValue)
+    console.log('stepsActiveIndex-----', stepsActiveIndex.value)
+    console.log('stepsTotalNum----', stepsTotalNum.value)
+    if (newValue === 'error') {
+        stepsActiveIndex.value = stepsTotalNum.value + 1
+        nextStepText.value = '检测失败'
+    }
+    if (newValue === 'success' && stepsActiveIndex.value === stepsTotalNum.value - 1) {
+        stepsActiveIndex.value += 2
+        nextStepText.value = '检测完成'
+    }
+    if (newValue === 'test_init_fail') {
+        stepsActiveIndex.value += 2
+        nextStepText.value = '初始化失败'
+    }
+    if (newValue === 'connect_timeout') {
+        stepsActiveIndex.value += 2
+        nextStepText.value = '连接超时'
+    }
+    if (newValue === 'pause_timeout') {
+        stepsActiveIndex.value += 2
+        // nextStepText.value = '结束测试'
+        nextStepText.value = '暂停超时'
+    }
+    if (newValue === 'success' && stepsActiveIndex.value < stepsTotalNum.value - 1) {
+        nextStep() // 实现自动点击，进入下一个测试内容
+        //handleSubmitFast()
+    }
+})
+
+const handleQuit = () => {
+    console.log('handleQuit', ActiveStatue.value)
+    if (
+        ActiveStatue.value !== 'success' &&
+        ActiveStatue.value !== 'waiting' &&
+        ActiveStatue.value !== 'paused' &&
+        ActiveStatue.value !== 'test_init_fail' &&
+        ActiveStatue.value !== 'connect_timeout' &&
+        ActiveStatue.value !== 'pause_timeout'
+    ) {
+        beforeClose(() => {})
+    } else {
+        handleClose()
+    }
+}
+
+const handlePause = () => {
+    sendPause()
+    testRef.value?.handlePause()
+}
+const sendPause = () => {
+    console.log('发起暂停请求')
+
+    TestStatus.value = 'paused_ing'
+    pauseTest()
+}
+const sendResume = () => {
+    console.log('发起继续检测请求')
+
+    resumeTest({
+        userPageId: JwtUtil.getLoginName(),
+        devIds: checkStore.devices.map(item => item.deviceId),
+        planId: checkStore.plan.id,
+        reCheckType: '2', //  0:'系数校验'，'1'为预检测、‘2‘为正式检测、'8'为不合格项复检
+        userId: userStore.userInfo.id,
+        temperature: checkStore.temperature,
+        humidity: checkStore.humidity
+    })
+    Object.assign(webMsgSend.value, {
+        requestId: 'Resume_Success'
+    })
+}
+
+const sendReCheck = () => {
+    console.log('发送重新检测指令')
+    startPreTest({
+        userPageId: JwtUtil.getLoginName(),
+        devIds: checkStore.devices.map(item => item.deviceId),
+        planId: checkStore.plan.id,
+        reCheckType: '2', // 0:'系数校验'，'1'为预检测、‘2‘为正式检测、'8'为不合格项复检
+        userId: userStore.userInfo.id,
+        temperature: checkStore.temperature,
+        humidity: checkStore.humidity,
+        testItemList: [
+            checkStore.selectTestItems.preTest,
+            checkStore.selectTestItems.channelsTest,
+            checkStore.selectTestItems.test
+        ]
+    }).then(res => {
+        console.log(res)
+        if (res.code === 'A001014') {
+            ElMessageBox.alert('装置配置异常', '初始化失败', {
+                confirmButtonText: '确定',
+                type: 'error'
+            })
+            TestStatus.value = 'test_init_fail'
+        }
+    })
+    TestStatus.value = 'start'
+}
+
+const closeWebSocket = () => {
+    dataSocket.socketServe.closeWs()
+}
+
+const nextStep = () => {
+    if (
+        stepsActiveIndex.value == stepsTotalNum.value + 1 ||
+        ActiveStatue.value === 'error' ||
+        ActiveStatue.value === 'test_init_fail' ||
+        ActiveStatue.value === 'connect_timeout' ||
+        ActiveStatue.value === 'pause_timeout'
+    ) {
+        handleClose()
+        return
+    }
+    if (ActiveStatue.value != 'error') {
+        ActiveStatue.value = 'waiting'
+        let tempStep = stepsActiveIndex.value
+        let idx = -1
+        stepsActiveIndex.value++
+        for (let selectTestItemsKey in checkStore.selectTestItems) {
+            if (tempStep == 0 && checkStore.selectTestItems[selectTestItemsKey]) {
+                console.log('selectTestItemsKey1')
+                stepsActiveView.value = idx
+                stepsActive.value = idx
+
+                return
+            }
+            if (checkStore.selectTestItems[selectTestItemsKey] && tempStep != 0) {
+                console.log('selectTestItemsKey2')
+                tempStep--
+            }
+            console.log('selectTestItemsKey3', idx)
+            idx++
+        }
+    }
+}
+
+const handleStepClick = (step: number) => {
+
+    if (step > stepsActive.value) {
+        return
+    } else {
+        stepsActiveView.value = step
+    }
+}
+
+function clearData() {
+    stepsTotalNum.value = -1
+    stepsActiveIndex.value = 1
+    stepsActiveView.value = -1
+    preTestStatus.value = 'waiting'
+    TestStatus.value = 'waiting'
+    ActiveStatue.value = 'waiting'
+    nextStepText.value = '下一步'
+}
+
+const beforeClose = (done: () => void) => {
+    if (stepsActiveIndex.value < stepsTotalNum.value && ActiveStatue.value != 'error') {
+        ElMessageBox.confirm('检测未完成，是否退出当前检测流程?', '提示', {
+            confirmButtonText: '确定',
+            cancelButtonText: '取消',
+            type: 'warning'
+        }).then(() => {
+            handleClose()
+        })
+    } else {
+        handleClose()
+    }
+}
+
+const handleClose = () => {
+    showSteps.value = false
+    dataSocket.socketServe.closeWs()
+    dialogVisible.value = false
+    clearData()
+    showComponent.value = false
+
+    emit('quitClicked') // 触发事件
+}
+
+// 对外映射
+defineExpose({ open })
+</script>
+
+<style scoped lang="scss">
+.test-head-steps {
+    ::v-deep .el-step {
+        .el-step__head.is-success {
+            color: #91cc75;
+        }
+
+        .el-step__title.is-success {
+            color: #91cc75;
+        }
+    }
+}
+
+:deep(.dialog-big .el-dialog__body) {
+    max-height: 840px !important;
+}
+
+.steps-container :deep(.test-head-steps) {
+    height: 80px;
+    margin-bottom: 10px;
+}
+
+.steps-container :deep(.el-step__title) {
+    font-size: 20px !important;
+    /* 设置标题字体大小 */
+    vertical-align: baseline !important;
+    display: inline-block;
+    /* 确保文字和图标在同一行 */
+    line-height: 1;
+    /* 调整行高以确保底部对齐 */
+}
+
+.steps-container :deep(.el-step__icon-inner) {
+    font-size: 18px !important;
+    vertical-align: baseline !important;
+    display: inline-block;
+    /* 确保文字和图标在同一行 */
+    line-height: 1;
+    /* 调整行高以确保底部对齐 */
+}
+
+.steps-container :deep(.el-step__icon) {
+    font-size: 18px !important;
+    vertical-align: baseline !important;
+    display: inline-block;
+    /* 确保文字和图标在同一行 */
+    line-height: 1;
+    /* 调整行高以确保底部对齐 */
+}
+
+.loading-box {
+    animation: loading 1.5s linear infinite;
+}
+
+@keyframes loading {
+    from {
+        transform: rotate(0deg);
+    }
+
+    to {
+        transform: rotate(360deg);
+    }
+}
+</style>

frontend/src/views/home/components/dataCheckResultTable.vue

@@ -87,7 +87,7 @@
 </template>
 
 <script lang="tsx" setup>
-import {defineProps} from 'vue';
+import {computed, defineProps} from 'vue';
 import {CheckData} from "@/api/check/interface";
 
 const {tableData, currentScriptTypeName} = defineProps<{

frontend/src/views/home/components/dataCheckSingleChannelSingleTestPopup.vue

@@ -8,7 +8,8 @@
             <el-input v-model='formContent.scriptName' :disabled="true"/>
           </el-form-item>
           <el-form-item label="误差体系">
-            <el-select :disabled="checkStore.showDetailType===2 || checkStore.showDetailType===0" v-model="formContent.errorSysId" placeholder="请选择误差体系" autocomplete="off"
+            <el-select :disabled="checkStore.showDetailType===2 || checkStore.showDetailType===0" v-model="formContent.errorSysId" placeholder="请选择误差体系"
+                       autocomplete="off"
                        @change="handleErrorSysChange">
               <el-option
                   v-for="(option) in pqErrorList"
@@ -67,7 +68,7 @@
           <div class="content-right-title">
             <div style="width: 840px;">
               <span class="content-right-title-text">当前检测项目：
-                  <el-popover trigger="hover" :content="currentDesc" :width="popoverWidth" placement="right">
+                  <el-popover trigger="hover" :content="currentDesc" width="500px" placement="right">
                     <template #reference>
                       <el-button type="text" style="font-size: 14px;">
                         {{ currentScriptTypeName }}
@@ -107,7 +108,6 @@ import {reactive, ref, watch} from 'vue'
 import DataCheckResultTable from './dataCheckResultTable.vue'
 import DataCheckRawDataTable from './dataCheckRawDataTable.vue'
 import {CheckData} from "@/api/check/interface";
-import {useDictStore} from "@/stores/modules/dict";
 import {useCheckStore} from "@/stores/modules/check";
 import {changeErrorSystem, deleteTempTable, exportRawData, getFormData, getTableData, getTreeData, reCalculate} from "@/api/check/test";
 import {generateDevReport, getPqErrSysList} from '@/api/plan/plan'
@@ -115,6 +115,11 @@ import {useDownload} from "@/hooks/useDownload";
 import {Histogram, Postcard} from "@element-plus/icons-vue";
 import {ResultEnum} from "@/enums/httpEnum";
 import {ElMessage} from "element-plus";
+import {useDictStore} from "@/stores/modules/dict";
+import {useModeStore} from "@/stores/modules/mode";
+
+const dictStore = useDictStore()
+const modeStore = useModeStore()
 
 const {appendToBody} = withDefaults(defineProps<{
   appendToBody: boolean
@@ -125,7 +130,6 @@ const defaultProps = {
   children: "children",
 };
 
-const dictStore = useDictStore()
 const checkStore = useCheckStore()
 
 const visible = ref(false)
@@ -226,6 +230,7 @@ const handleErrorSysChange = async () => {
     errorSysId: formContent.errorSysId,
     deviceId: deviceId,
     code: checkStore.plan.code + '',
+    patternId: dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? '',
   }).then((res) => {
     if (res.code === ResultEnum.SUCCESS) {
       ElMessage.success('切换误差体系成功')
@@ -440,7 +445,7 @@ const open = async (_deviceId: string, chnNum: string, _scriptType: string | nul
 }
 
 const handleGenerateReport = async () => {
-  await generateDevReport({'planId': checkStore.plan.id, 'devIdList': [deviceId],'scriptId':checkStore.plan.scriptId,'planCode':planCode})
+  await generateDevReport({'planId': checkStore.plan.id, 'devIdList': [deviceId], 'scriptId': checkStore.plan.scriptId, 'planCode': planCode})
   ElMessage.success({message: `报告生成成功！`})
 }
 
@@ -450,7 +455,8 @@ const handleReCalculate = async () => {
     scriptId: checkStore.plan.scriptId,
     errorSysId: formContent.errorSysId,
     deviceId: deviceId,
-    code: checkStore.plan.code + ''
+    code: checkStore.plan.code + '',
+    patternId: dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? '',
   }).then((res) => {
     ElMessage.success('重新计算成功！')
     // if (originErrorSysId != formContent.errorSysId) {
@@ -596,7 +602,7 @@ const dataToShow = (num: number): string => {
   if (num == null || num == undefined) {
     return '/'
   }
-  return num+''
+  return num + ''
 }
 
 

frontend/src/views/home/components/deviceConnectionPopup.vue

@@ -0,0 +1,516 @@
+<template>
+    <!-- <el-dialog title="设备通道配对" v-model="dialogVisible" v-bind="dialogBig">
+        <div
+            class="flow-container"
+            style="overflow: hidden; position: relative"
+            :style="{ height: dialogHeight + 'px' }"
+        >
+            <VueFlow
+                :nodes="nodes"
+                :edges="edges"
+                :connection-radius="30"
+                :nodes-draggable="false"
+                :dragging="false"
+                :zoom-on-scroll="false"
+                :pan-on-drag="false"
+                :disable-zoom-pan-on-connect="true"
+                :prevent-scrolling="true"
+                :fit-view="true"
+                :min-zoom="1"
+                :max-zoom="1"
+                :elements-selectable="false"
+                auto-connect
+                @connect="handleConnect"
+                @connect-start="handleConnectStart"
+                @connect-end="handleConnectEnd"
+                @pane-ready="onPaneReady"
+                v-on:pane-mouse-move="false"
+            ></VueFlow>
+        </div>
+
+        <template #footer>
+            <div class="dialog-footer">
+                <el-button @click="dialogVisible = false">取消</el-button>
+                <el-button type="primary" @click="handleNext">下一步</el-button>
+            </div>
+        </template>
+    </el-dialog> -->
+    <!-- devIdList.value
+    pqStandardDevList.value
+    planIdKey.value -->
+    <!-- 手动检测-勾选检测项弹窗 -->
+    <SelectTestItemPopup ref="selectTestItemPopupRef" @openTestDialog="openTestDialog"></SelectTestItemPopup>
+    <CompareTestPopup
+        ref="testPopup"
+        :key="compareTestKey" 
+        v-if="CompareTestVisible"
+        :devIdList="devIdList"
+        :pqStandardDevList="pqStandardDevList"
+        :planIdKey="planIdKey"
+    ></CompareTestPopup>
+</template>
+
+<script lang="ts" setup>
+import { h, ref } from 'vue'
+import { VueFlow, useVueFlow } from '@vue-flow/core'
+import { dialogBig } from '@/utils/elementBind'
+import { Platform, Flag } from '@element-plus/icons-vue'
+import { Device } from '@/api/device/interface/device'
+import { StandardDevice } from '@/api/device/interface/standardDevice'
+import SelectTestItemPopup from '@/views/home/components/selectTestItemPopup.vue'
+import CompareTestPopup from './compareTestPopup.vue'
+import { ElMessage } from 'element-plus'
+import CustomEdge from './RemoveableEdge.vue' // 导入自定义连接线组件
+import { jwtUtil } from '@/utils/jwtUtil'
+import { useCheckStore } from '@/stores/modules/check'
+import { Plan } from '@/api/plan/interface'
+import { fa } from 'element-plus/es/locale'
+
+const checkStore = useCheckStore()
+const dialogVisible = ref(false)
+const selectTestItemPopupRef = ref<InstanceType<typeof SelectTestItemPopup>>()
+const testPopup = ref()
+const dialogTitle = ref('手动检测')
+const compareTestKey = ref(0)
+// 计算对话框高度
+const dialogHeight = ref(600)
+const CompareTestVisible = ref(false)
+// 初始化 VueFlow，注册自定义连线类型
+const { edges, setViewport } = useVueFlow({
+    edgeTypes: {
+        default: CustomEdge
+    }
+})
+
+// 初始化时锁定画布位置
+const onPaneReady = () => {
+    setViewport({ x: 0, y: 0, zoom: 1 })
+}
+
+// 提取公共的label渲染函数
+const createLabel = (text: string, type: string) => {
+    return h(
+        'div',
+        {
+            style: {
+                display: 'flex',
+                flexDirection: 'column',
+                alignItems: 'center',
+                fontSize: '15px',
+                textAlign: 'center',
+                border: '1px solid #ccc',
+                borderRadius: '8px',
+                padding: '8px',
+                backgroundColor: '#f9f9f9'
+            }
+        },
+        [
+            h(Platform, {
+                style: {
+                    width: '20px',
+                    marginBottom: '4px',
+                    color: '#526ade'
+                }
+            }),
+            h('div', null, '设备名称：' + text),
+            h('div', null, '设备类型：' + type)
+        ]
+    ) as any
+}
+
+const createLabel3 = (text: string) => {
+    return h(
+        'div',
+        {
+            style: {
+                display: 'flex',
+                alignItems: 'center',
+                fontSize: '15px',
+                textAlign: 'center',
+                border: '1px solid #ccc',
+                borderRadius: '8px',
+                padding: '8px',
+                backgroundColor: '#f9f9f9'
+            }
+        },
+        [
+            h(Flag, {
+                style: {
+                    width: '20px',
+                    marginRight: '4px',
+                    color: '#526ade'
+                }
+            }),
+            text
+        ]
+    ) as any
+}
+
+const handleConnectStart = (params: any) => {
+    onPaneReady()
+}
+
+const handleConnectEnd = (params: any) => {
+    onPaneReady()
+}
+
+const handleConnect = (params: any) => {
+    console.log('连接信息:', params)
+    const sourceNode = nodes.value.find(node => node.id === params.source)
+    const targetNode = nodes.value.find(node => node.id === params.target)
+
+    // 连接规则验证
+    const isValidConnection = sourceNode?.type === 'input' && targetNode?.type === 'output'
+
+    if (!isValidConnection) {
+        removeEdge(params)
+        ElMessage.warning('只能从被检通道连接到标准通道')
+        return
+    }
+
+    // 过滤掉当前连接，检查是否还有重复的
+    const existingEdges = edges.value.filter(edge => edge.source === params.source || edge.target === params.target)
+
+    // 如果同源或同目标的连接超过1个，说明有重复
+    if (existingEdges.length > 1) {
+        const duplicateSource = existingEdges.filter(edge => edge.source === params.source).length > 1
+        const duplicateTarget = existingEdges.filter(edge => edge.target === params.target).length > 1
+
+        if (duplicateSource) {
+            removeEdge(params)
+            ElMessage.warning('该被检通道已经连接，不能重复连接')
+            return
+        }
+
+        if (duplicateTarget) {
+            removeEdge(params)
+            ElMessage.warning('该标准通道已经连接，不能重复连接')
+            return
+        }
+    }
+}
+
+// 删除不合法连接
+const removeEdge = (params: any) => {
+    const edgeIndex = edges.value.findIndex(edge => edge.source === params.source && edge.target === params.target)
+    if (edgeIndex !== -1) {
+        edges.value.splice(edgeIndex, 1)
+    }
+}
+
+const nodes = ref([])
+const planId = ref('')
+const devIds = ref<string[]>()
+const standardDevIds = ref<string[]>()
+const devIdList = ref<Device.ResPqDev[]>([])
+const pqStandardDevList = ref<StandardDevice.ResPqStandardDevice[]>([])
+const planIdKey = ref<string>('')
+const deviceMonitor = ref<Map<string, any[]>>();
+const planIsOnlyWave = ref(false)
+const open = async (
+    
+    device: Device.ResPqDev[],
+    standardDev: StandardDevice.ResPqStandardDevice[],
+    fatherPlanId: string,
+    DeviceMonitoringMap: Map<string, any[]>,
+    checkType: string,
+    isOnlyWave:boolean
+) => {
+    planIsOnlyWave.value = isOnlyWave
+    CompareTestVisible.value = false
+    devIdList.value = device
+    pqStandardDevList.value = standardDev
+    planIdKey.value = fatherPlanId
+    deviceMonitor.value = DeviceMonitoringMap
+    if(checkType == "一键检测"){
+        openTestDialog()
+    }else{
+        selectTestItemPopupRef.value?.open()
+    }
+  
+    // edges.value = []
+
+    // devIds.value = device.map(d => d.id)
+    // standardDevIds.value = standardDev.map(d => d.id)
+    // planId.value = fatherPlanId
+    // nodes.value = createNodes(device, standardDev)
+    // edges.value = []
+
+    // devIds.value = device.map(d => d.id)
+    // standardDevIds.value = standardDev.map(d => d.id)
+    // planId.value = fatherPlanId
+    // nodes.value = createNodes(device, standardDev)
+    // dialogVisible.value = true
+    // onPaneReady()
+}
+
+const handleNext = async () => {
+    if (edges.value.length === 0) {
+        ElMessage.warning('请先完成通道配对')
+        return
+    }
+    // const sourceKey = edge.source.replace('被检通道-', '').replace('-', '_');
+    let chnNumList: string[] = []
+    await edges.value.forEach(edge => {
+        const match = edge.source.split('-')
+
+        if (match) {
+            chnNumList.push(match[2])
+        }
+    })
+
+    await checkStore.setChnNum(chnNumList)
+    CompareTestVisible.value = false
+    dialogVisible.value = false
+
+    selectTestItemPopupRef.value?.open()
+}
+
+const openTestDialog = async () => {
+    compareTestKey.value++  // 每次调用时更新key
+    CompareTestVisible.value = true
+    // 转换连接信息，只保留设备ID和通道号
+    const connections = edges.value.reduce(
+        (map, edge) => {
+            // 从source中提取设备ID和通道号: 被检通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const sourceKey = edge.source.replace('被检通道-', '').replace('-', '_')
+
+            // 从target中提取设备ID和通道号: 标准通道-{deviceId}-{channelNum} => {deviceId}-{channelNum}
+            const targetValue = edge.target.replace('标准通道-', '').replace('-', '_')
+
+            map[sourceKey] = targetValue
+            return map
+        },
+        {} as Record<string, string>
+    )
+
+    generateChannelMapping()
+
+    setTimeout(() => {
+
+        testPopup.value?.open(
+            dialogTitle.value,
+            channelMapping.value,
+            planId.value,
+            jwtUtil.getLoginName(),
+            devIds.value,
+            standardDevIds.value,
+            connections,
+            deviceMonitor.value ,
+            planIsOnlyWave.value
+        )
+    }, 100)
+}
+
+// 转换 edges.value 为 channelMapping 格式
+const channelMapping = ref<Record<string, Record<string, string>>>({})
+
+// 生成映射关系的方法
+const generateChannelMapping = () => {
+    const mapping: Record<string, Record<string, string>> = {}
+
+    edges.value.forEach(edge => {
+        // 解析 source 节点信息（被检通道）
+        const sourceParts = edge.source.split('-')
+        const sourceDeviceId = sourceParts[1]
+        const sourceChannel = sourceParts[2]
+
+        // 解析 target 节点信息（标准通道）
+        const targetParts = edge.target.split('-')
+        const targetDeviceId = targetParts[1]
+        const targetChannel = targetParts[2]
+
+        // 查找对应的节点以获取显示名称
+        const sourceDeviceNode = nodes.value.find(node => node.id === sourceDeviceId)
+        const targetDeviceNode = nodes.value.find(node => node.id === targetDeviceId)
+
+        if (sourceDeviceNode && targetDeviceNode) {
+            // 提取设备显示文本
+            const sourceDeviceText = sourceDeviceNode.data.label.children[1].children
+            const targetDeviceText = targetDeviceNode.data.label.children[1].children
+
+            // 构造键名 - 现在以标准设备为键
+            const targetKey = `${targetDeviceText}`.replace('设备名称：', '')
+            const sourceValue = `${sourceDeviceText}通道${sourceChannel}`.replace('设备名称：', '')
+
+            // 初始化对象
+            if (!mapping[targetKey]) {
+                mapping[targetKey] = {}
+            }
+
+            // 添加映射关系 - 标准设备通道 -> 被检设备信息
+            mapping[targetKey][`通道${targetChannel}`] = sourceValue
+        }
+    })
+
+    channelMapping.value = mapping
+}
+
+const createNodes = (device: Device.ResPqDev[], standardDev: StandardDevice.ResPqStandardDevice[]) => {
+    const channelCounts: Record<string, number> = {}
+    device.forEach(device => {
+        channelCounts[device.id] = device.devChns || 0
+    })
+
+    const inspectionDevices = device.map(d => ({
+        id: d.id,
+        name: d.name,
+        type: 'normal',
+        deviceType: d.devType
+    }))
+
+    const channelCounts2: Record<string, number> = {}
+    standardDev.forEach(dev => {
+        const channelList = dev.inspectChannel ? dev.inspectChannel.split(',') : []
+        channelCounts2[dev.id] = channelList.length
+    })
+
+    const standardDevices = standardDev.map(d => ({
+        id: d.id,
+        name: d.name,
+        type: 'normal',
+        deviceType: d.devType
+    }))
+
+    const newNodes: any[] = []
+    const deviceChannelGroups: { deviceId: string; centerY: number }[] = []
+    const standardChannelGroups: any[] = []
+
+    const deviceWidth = 0
+    const inputChannelX = 200
+    const outputChannelX = 800
+    const standardWidth = 950
+
+    const yPosition = ref(25)
+    const yPosition2 = ref(25)
+
+    // 添加被检通道
+    Object.entries(channelCounts).forEach(([deviceId, count]) => {
+        for (let i = 1; i <= count; i++) {
+            const channelId = `被检通道-${deviceId}-${i}`
+            newNodes.push({
+                id: channelId,
+                type: 'input',
+                data: { label: createLabel3(`被检通道${i}`) },
+                position: { x: inputChannelX, y: yPosition.value },
+                sourcePosition: 'right',
+                style: { width: '150px', border: 'none', boxShadow: 'none' }
+            })
+
+            // 计算设备节点Y坐标（居中显示）
+            if (i == 1 && count == 1) {
+                deviceChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition.value - 25
+                })
+            } else if (i == 2 && count == 2) {
+                deviceChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition.value - 50
+                })
+            } else if (i == 3 && count == 3) {
+                deviceChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition.value - 75
+                })
+            } else if (i == 4 && count == 4) {
+                deviceChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition.value - 100
+                })
+            }
+
+            yPosition.value += 50
+        }
+        yPosition.value += 50
+    })
+
+    // 添加标准通道
+    Object.entries(channelCounts2).forEach(([deviceId, count]) => {
+        for (let i = 1; i <= count; i++) {
+            const channelId = `标准通道-${deviceId}-${i}`
+            newNodes.push({
+                id: channelId,
+                type: 'output',
+                data: { label: createLabel3(`标准通道${i}`) },
+                position: { x: outputChannelX, y: yPosition2.value },
+                targetPosition: 'left',
+                style: { width: '150px', border: 'none', boxShadow: 'none' }
+            })
+
+            // 计算设备节点Y坐标（居中显示）
+            if (i == 1 && count == 1) {
+                standardChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition2.value - 25
+                })
+            } else if (i == 2 && count == 2) {
+                standardChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition2.value - 50
+                })
+            } else if (i == 3 && count == 3) {
+                standardChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition2.value - 100
+                })
+            } else if (i == 4 && count == 4) {
+                standardChannelGroups.push({
+                    deviceId,
+                    centerY: yPosition2.value - 100
+                })
+            }
+
+            yPosition2.value += 50
+        }
+        yPosition2.value += 50
+    })
+
+    // 添加被检设备
+    deviceChannelGroups.forEach(({ deviceId, centerY }) => {
+        const device = inspectionDevices.find(d => d.id === deviceId)
+        if (device) {
+            newNodes.push({
+                id: device.id,
+                data: { label: createLabel(device.name, device.deviceType) },
+                position: { x: deviceWidth, y: centerY },
+                class: 'no-handle-node',
+                style: { width: '200px', border: 'none', boxShadow: 'none' }
+            })
+        }
+    })
+
+    // 添加标准设备
+    standardChannelGroups.forEach(({ deviceId, centerY }) => {
+        const device = standardDevices.find(d => d.id === deviceId)
+        if (device) {
+            newNodes.push({
+                id: device.id,
+                data: { label: createLabel(device.name, device.deviceType) },
+                position: { x: standardWidth, y: centerY },
+                class: 'no-handle-node',
+                style: { width: '200px', border: 'none', boxShadow: 'none' }
+            })
+        }
+    })
+
+    //页面高度取决于设备通道
+    dialogHeight.value = Math.max(yPosition.value, yPosition2.value)
+
+    return newNodes
+}
+
+defineExpose({ open })
+</script>
+
+<style>
+.flow-container {
+    width: 100%;
+   
+    overflow: hidden;
+}
+
+.vue-flow__node.no-handle-node .vue-flow__handle {
+    display: none !important;
+}
+</style>

frontend/src/views/home/components/factorTest.vue

@@ -2,16 +2,12 @@
   <div class="dialog" v-bind="dialogBig">
     <div class="dialog-content">
       <div class="right-title">
-        <!-- <div>系数校准表</div> -->
         <div>{{ outputDsc }}</div>
         <div>
             <span style="  font-size: 18px;font-weight: 600;">
               设备已合格 <span style="color: #91cc75">{{ qualified }}</span> 台/共 <span style="color: green">{{ total }}</span>
               台
             </span>
-          <!-- <el-button type="primary" loading
-            v-if="activeIndex > 0 && activeIndex < activeTotalNum">通道系数已校准3台/共3台</el-button>
-          <el-button type="primary" :disabled="true" v-if="activeIndex === activeTotalNum">通道系数已校准3台/共3台</el-button> -->
         </div>
       </div>
       <div class="container">
@@ -90,6 +86,21 @@
 </template>
 
 <script lang="tsx" setup name="FactorTest">
+/**
+ * 系数校准组件
+ * 
+ * 功能概述：
+ * 1. 对电力设备进行系数校准，确保测量精度
+ * 2. 包含4个校准步骤：大/小电压电流系数的下装和校准
+ * 3. 支持多设备并行校准，实时显示校准数据和结果
+ * 4. 校准完成后自动统计合格设备数量并通知父组件
+ * 
+ * 校准流程：
+ * 第1步：大电压/电流系数下装 - 向设备下发大幅值的系数参数
+ * 第2步：小电压/电流系数下装 - 向设备下发小幅值的系数参数  
+ * 第3步：大电压/电流校准 - 使用大幅值进行校准测试
+ * 第4步：小电压/电流校准 - 使用小幅值进行校准测试
+ */
 import {type Device} from '@/api/device/interface/device';
 import {Failed} from '@element-plus/icons-vue'
 import {onBeforeMount, type Ref, ref, toRef, watch} from 'vue'
@@ -101,182 +112,235 @@ import type {Plan} from '@/api/plan/interface';
 import {useCheckStore} from "@/stores/modules/check";
 import {useUserStore} from "@/stores/modules/user";
 
+// ==================== 状态管理 ====================
 const checkStore = useCheckStore()
-const activeIndex = ref(0)
-const activeTotalNum = ref(4)
-const qualified = ref(0)
-const outputDsc = ref('电压误差为：±0.1Un%； 电流误差为：±0.5%')
-const total = ref(0)
-const dialogVisible = ref(false)
-const active = ref(0)
-let timer1: NodeJS.Timeout | null = null; // 声明并初始化 timer1
-let timer2: NodeJS.Timeout | null = null; // 同样声明并初始化 timer2
-const name = ref<string[]>([])//系数校准所选设备名字数组
-const channel = ref<number[]>([])//系数校准所选设备通道数组
-const devIdArray = ref<string[]>([])//系数校准所选设备ID数组
-const select_Plan = ref<Plan.ReqPlan>()
-const planId = ref('')
-const isButtonDisabled = ref(false);
-const CurV = ref<number>()//额定电压
-// 在 setup 函数中
-const errorStates = ref(new Array(name.value.length).fill(false));
-//const loadingStates = ref(new Array(name.value.length).fill(false)); // 初始化 loading 状态
-const big_V_loadingStates = ref(false); // 初始化 大电压大电流下装loading 状态
-const small_V_loadingStates = ref(false); // 初始化 小电压小电流下装loading 状态
-const big_V_loadingStates2 = ref(false); // 初始化 大电压大电流校准loading 状态
-const small_V_loadingStates2 = ref(false); // 初始化 小电压小电流校准loading 状态
-const editableTabsValue = ref('0')
-const big_V_Download = ref('')
-const big_I_Download = ref('')
-const small_V_Download = ref('')
-const small_I_Download = ref('')
-const big_V_Adjust = ref('')
-const big_I_Adjust = ref('')
-const small_V_Adjust = ref('')
-const small_I_Adjust = ref('')
+const userStore = useUserStore()
+
+// ==================== 界面控制变量 ====================
+const activeIndex = ref(0)          // 当前活跃的表格数据索引
+const activeTotalNum = ref(4)        // 总步骤数
+const qualified = ref(0)             // 已合格的设备数量
+const outputDsc = ref('电压误差为：±0.1Un%； 电流误差为：±0.5%') // 输出描述信息
+const total = ref(0)                 // 设备总数
+const dialogVisible = ref(false)     // 弹窗显示状态
+const active = ref(0)                // 当前激活的校准步骤（0-5）
+const editableTabsValue = ref('0')   // 当前选中的标签页
+
+// ==================== 定时器管理 ====================
+let timer1: NodeJS.Timeout | null = null // 定时器1
+let timer2: NodeJS.Timeout | null = null // 定时器2
+
+// ==================== 设备信息管理 ====================
+const name = ref<string[]>([])           // 系数校准所选设备名称数组
+const channel = ref<number[]>([])        // 系数校准所选设备通道数量数组
+const devIdArray = ref<string[]>([])     // 系数校准所选设备ID数组
+const select_Plan = ref<Plan.ReqPlan>()  // 选中的检测计划
+const planId = ref('')                   // 计划ID
+const CurV = ref<number>()               // 额定电压值
+
+// ==================== 状态控制变量 ====================
+const isButtonDisabled = ref(false)     // 按钮禁用状态
+const errorStates = ref(new Array(name.value.length).fill(false)) // 各设备错误状态数组
+
+// ==================== 加载状态管理 ====================
+const big_V_loadingStates = ref(false)    // 大电压大电流下装加载状态
+const small_V_loadingStates = ref(false)  // 小电压小电流下装加载状态  
+const big_V_loadingStates2 = ref(false)   // 大电压大电流校准加载状态
+const small_V_loadingStates2 = ref(false) // 小电压小电流校准加载状态
+
+// ==================== 源输出参数显示 ====================
+const big_V_Download = ref('')     // 大电压下装时的电压输出显示
+const big_I_Download = ref('')     // 大电压下装时的电流输出显示
+const small_V_Download = ref('')   // 小电压下装时的电压输出显示  
+const small_I_Download = ref('')   // 小电压下装时的电流输出显示
+const big_V_Adjust = ref('')       // 大电压校准时的电压输出显示
+const big_I_Adjust = ref('')       // 大电压校准时的电流输出显示
+const small_V_Adjust = ref('')     // 小电压校准时的电压输出显示
+const small_I_Adjust = ref('')     // 小电压校准时的电流输出显示
+// ==================== 组件Props定义 ====================
 const props = defineProps({
   testStatus: {
     type: String,
-    default: 'wait'
+    default: 'wait'    // 从父组件接收的测试状态
   },
   webMsgSend: {
     type: Object,
-    default: () => ({})
+    default: () => ({}) // 从父组件接收的WebSocket消息
   },
 })
-const userStore = useUserStore()
+
+// ==================== 响应式Props引用 ====================
 const testStatus = toRef(props, 'testStatus');
-const tableDataMap = new Map<number, Ref<ChannelsTest.CoefficientVO[]>>([]);
-const currentStepStatus = ref<'error' | 'finish' | 'wait' | 'success' | 'process'>('finish');
 const webMsgSend = toRef(props, 'webMsgSend');
 
+// ==================== 数据管理 ====================
+const tableDataMap = new Map<number, Ref<ChannelsTest.CoefficientVO[]>>([]);  // 存储每个设备的表格数据映射
+const currentStepStatus = ref<'error' | 'finish' | 'wait' | 'success' | 'process'>('finish'); // 当前步骤状态
+
+// ==================== 组件生命周期 ====================
 onBeforeMount(() => {
-  // 初始化
-  initData()
+  initData() // 组件挂载前初始化数据
 })
+
+/**
+ * 初始化组件数据
+ * 从store中获取设备信息，初始化表格数据和状态变量
+ */
 const initData = () => {
- 
-  CurV.value = checkStore.devices[0]?.devVolt || 57.74;
-  isButtonDisabled.value = false; // 恢复按钮
-  select_Plan.value = checkStore.plan
-  planId.value = checkStore.devices[0]?.planId || '';
-  devIdArray.value = checkStore.devices.map(item => item.deviceId);
-  name.value = checkStore.devices.map(item => item.deviceName)
-  channel.value = checkStore.devices.map(item => item.chnNum)
-  dialogVisible.value = true;
-  total.value = name.value.length
+  // 获取设备基础信息
+  CurV.value = checkStore.devices[0]?.devVolt || 57.74;  // 获取额定电压，默认57.74V
+  isButtonDisabled.value = false;                        // 恢复按钮可用状态
+  select_Plan.value = checkStore.plan                   // 获取检测计划
+  planId.value = checkStore.devices[0]?.planId || '';   // 获取计划ID
+  
+  // 提取设备信息数组
+  devIdArray.value = checkStore.devices.map(item => item.deviceId);   // 设备ID数组
+  name.value = checkStore.devices.map(item => item.deviceName);       // 设备名称数组
+  channel.value = checkStore.devices.map(item => item.chnNum);        // 设备通道数量数组
+  
+  // 设置界面状态
+  dialogVisible.value = true;       // 显示弹窗
+  total.value = name.value.length;  // 设置设备总数
 
-
-  // 初始化 loadingStates 为 false
-  // loadingStates.value = new Array(selection.length).fill(false);
+  // 初始化错误状态数组，所有设备初始状态为无错误
   errorStates.value = new Array(checkStore.devices.length).fill(false);
 
+  // 为每个设备初始化表格数据
   for (let i = 0; i < channel.value.length; i++) {
     const currentTableData = initializeTableData(dataTemplates, i);
-    tableDataMap.set(i, currentTableData)
+    tableDataMap.set(i, currentTableData);  // 将表格数据存储到Map中，以设备索引为key
   }
-  //console.log('tableDataMap',tableDataMap);
 }
 
 
+// ==================== 状态监听器 ====================
+/**
+ * 监听父组件传入的测试状态变化
+ * 当父组件通知开始测试时，启动系数校准流程
+ */
 watch(testStatus, function (newValue, oldValue) {
   if (newValue === 'start') {
-      // 开始系数校准操作
-      handleSubmit()
-    }
+    // 父组件通知开始系数校准操作
+    handleSubmit()
+  }
 })
 
+/**
+ * 监听WebSocket消息，处理系数校准过程中的各种响应
+ * 主要处理：
+ * 1. 错误代码的统一处理
+ * 2. 系数校准流程的各个步骤响应
+ * 3. 表格数据的实时更新
+ */
 watch(webMsgSend, function (newValue, oldValue) {
   console.log('webMsgSend---code', newValue.code)
   console.log('webMsgSend---requestId', newValue.requestId)
+  
+  // 只有在非等待状态下才处理WebSocket消息
   if (testStatus.value !== 'waiting') {
+    // ==================== 通用错误代码处理 ====================
     if (newValue.code == 10520) {
+      // 报文解析异常
       ElMessageBox.alert('报文解析异常！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10521) {
+      // 程控源参数有误
       ElMessageBox.alert('程控源參数有误！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10522) {
+      // 测试项解析有误
       ElMessageBox.alert('测试项解析有误！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10523) {
+      // 源连接失败
       ElMessageBox.alert('源连接失败！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10524) {
+      // 获取源控制权失败
       ElMessageBox.alert('获取源控制权失败！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10525) {
+      // 重置源失败
       ElMessageBox.alert('重置源失败！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10527) {
+      // 源未进行初始化
       ElMessageBox.alert('源未进行初始化！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10528) {
+      // 目标源有误（用户已控制其他源）
       ElMessageBox.alert('目标源有误(该用户已控制其他源，在关闭前无法操作新的源)！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10529) {
+      // 源状态有误，无法响应报文
       ElMessageBox.alert('源状态有误，无法响应报文(例如源处于输出状态，无法响应初始化报文)！', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10550) {
+      // 设备连接异常
       ElMessageBox.alert(`${newValue.data}设备连接异常！`, '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else if (newValue.code == 10551) {
+      // 设备触发报告异常
       ElMessageBox.alert(`${newValue.data}设备触发报告异常！`, '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
-    } else if (newValue.code == 10552) { //todo 10552之后还会发送消息吗？
+    } else if (newValue.code == 10552) {
+      // 存在已经初始化步骤，执行自动关闭
       ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
         confirmButtonText: '确定',
         type: 'error',
       })
       TableInit();
     } else {
+      // ==================== 特定业务消息处理 ====================
       console.log('显示东西code', newValue.code)
       console.log('显示东西requestId', newValue.requestId)
       switch (newValue.requestId) {
-
+        // 处理源通讯校验相关消息
         case 'yjc_ytxjy':
           switch (newValue.operateCode) {
             case'INIT_GATHER':
               if (newValue.code == -1) {
+                // 源未知异常
                 ElMessageBox.alert('源未知异常', '初始化失败', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               } else if (newValue.code == 10523) {
+                // 源连接失败
                 ElMessageBox.alert('源连接失败', '源连接失败', {
                   confirmButtonText: '确定',
                   type: 'error',
@@ -285,16 +349,19 @@ watch(webMsgSend, function (newValue, oldValue) {
               }
           }
           break;
+        // 处理相序校验相关消息
         case 'YJC_xujy':
           switch (newValue.operateCode) {
             case 'OPER_GATHER':
               if (newValue.code == 10552) {
+                // 存在已经初始化步骤，执行自动关闭
                 ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               } else if (newValue.code == 10520) {
+                // 解析报文异常
                 ElMessageBox.alert('解析报文异常,执行自动关闭,请重新发起检测', '解析报文异常', {
                   confirmButtonText: '确定',
                   type: 'error',
@@ -304,6 +371,7 @@ watch(webMsgSend, function (newValue, oldValue) {
               break;
             case 'DATA_REQUEST$02':
               if (newValue.code == 25003) {
+                // 相序校验未通过
                 ElMessageBox.alert('相序校验未通过,执行自动关闭,请重新发起检测', '相序校验未通过', {
                   confirmButtonText: '确定',
                   type: 'error',
@@ -313,42 +381,48 @@ watch(webMsgSend, function (newValue, oldValue) {
               break;
           }
           break;
+        // 处理设备通讯校验相关消息
         case 'yjc_sbtxjy':
           switch (newValue.operateCode) {
             case 'INIT_GATHER$01':
               if (newValue.code == 10550) {
+                // 设备连接异常
                 ElMessageBox.alert('设备连接异常', '设备连接异常', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               } else if (newValue.code == 10551) {
+                // 设备触发报告异常
                 ElMessageBox.alert('设备触发报告异常', '设备触发报告异常', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               } else if (newValue.code == 10552) {
+                // 存在已经初始化步骤，执行自动关闭
                 ElMessageBox.alert('存在已经初始化步骤,执行自动关闭,请重新发起检测', '初始化失败', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               } else if (newValue.code == 10520) {
+                // 解析报文异常
                 ElMessageBox.alert('解析报文异常,执行自动关闭,请重新发起检测', '解析报文异常', {
                   confirmButtonText: '确定',
                   type: 'error',
                 })
                 TableInit();
               }
-
               break;
           }
           break;
+        // 处理协议校验相关消息
         case 'yjc_xyjy':
           switch (newValue.operateCode) {
             case 'VERIFY_MAPPING$01':
-              if (newValue.code == 10200) {
+              if (newValue.code == 25002) {
+                // 脚本与ICD校验失败
                 let data = JSON.parse(newValue.data)
                 ElMessageBox.alert(`脚本与icd校验失败！icd名称：${data['icdType']} -> 校验项：${data['dataType']}`, '初始化失败', {
                   confirmButtonText: '确定',
@@ -357,6 +431,7 @@ watch(webMsgSend, function (newValue, oldValue) {
                 TableInit();
               }
               if (newValue.code == 10500) {
+                // 装置中未找到该ICD
                 ElMessageBox.alert(`装置中未找到该icd!`, '初始化失败', {
                   confirmButtonText: '确定',
                   type: 'error',
@@ -366,136 +441,162 @@ watch(webMsgSend, function (newValue, oldValue) {
               break;
           }
           break;
+        // ★★★ 处理系数校准核心业务消息 ★★★
         case 'Coefficient_Check':
           console.log("Coefficient_Checkactive", active.value);
+          
+          // ==================== 第1阶段：大电压/电流系数下装 ====================
           switch (newValue.operateCode) {
-            case 'big_start'://大电压,电流下装
+            case 'big_start':
+              // 大电压/电流系数下装开始，显示源输出参数
               big_V_Download.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
               big_I_Download.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
               break;
-            case 'big_end'://大电压,电流下装
-              active.value++;
-              tableLoading('small', '系数下装')
+            case 'big_end':
+              // 大电压/电流系数下装完成，进入下一阶段
+              active.value++; // 步骤进度+1
+              tableLoading('small', '系数下装') // 开始小电压/电流下装的加载动画
               break;
           }
+          
+          // ==================== 第2阶段：小电压/电流系数下装 ====================
           switch (newValue.operateCode) {
-            case 'small_start'://小电压,电流下装
+            case 'small_start':
+              // 小电压/电流系数下装开始，显示源输出参数
               small_V_Download.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
               small_I_Download.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
               break;
-            case 'small_end'://小电压,电流下装
-              active.value++;
-              tableLoading('big', '系数校准')
+            case 'small_end':
+              // 小电压/电流系数下装完成，进入校准阶段
+              active.value++; // 步骤进度+1
+              tableLoading('big', '系数校准') // 开始大电压/电流校准的加载动画
               break;
           }
+          
+          // ==================== 第3阶段：大电压/电流系数校准 ====================
           switch (newValue.operateCode) {
-            case 'big_comp_start'://大电压,电流校准
+            case 'big_comp_start':
+              // 大电压/电流系数校准开始，显示源输出参数
               big_V_Adjust.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
               big_I_Adjust.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
               break;
-            case 'big_comp_end'://大电压,电流校准
-              active.value++;
-              tableLoading('small', '系数校准')
+            case 'big_comp_end':
+              // 大电压/电流系数校准完成，进入最后阶段
+              active.value++; // 步骤进度+1
+              tableLoading('small', '系数校准') // 开始小电压/电流校准的加载动画
               break;
           }
+          
+          // ==================== 第4阶段：小电压/电流系数校准（最终阶段）====================
           switch (newValue.operateCode) {
-            case 'small_comp_start'://小电压,电流校准
+            case 'small_comp_start':
+              // 小电压/电流系数校准开始，显示源输出参数
               small_V_Adjust.value = 'Ua=Ub=Uc=' + newValue.data.devVolt + 'V';
               small_I_Adjust.value = 'Ia=Ib=Ic=' + newValue.data.devCurr + 'A';
               break;
-            case 'small_comp_end'://小电压,电流校准
-              active.value++;
-              active.value++;
+            case 'small_comp_end':
+              // ★★★ 小电压/电流系数校准完成 - 整个系数校准流程结束 ★★★
+              active.value++; // 步骤进度+1
+              active.value++; // 再+1，跳转到完成状态
 
+              // 统计所有设备的校准结果
               for (let i = 0; i < name.value.length; i++) {
                 const currentDataRef = tableDataMap.get(i);
                 if (currentDataRef) {
                   const currentData = currentDataRef.value;
-                  // 检查当前数据中有无不合格字段
+                  // 检查当前设备的校准数据是否合格
                   const hasError = checkForErrors(currentData);
-                  if (hasError) {
-                  } else {
-                    qualified.value++;
+                  if (!hasError) {
+                    qualified.value++; // 合格设备计数+1
                   }
-                  updateErrorState(i, hasError);
+                  updateErrorState(i, hasError); // 更新设备错误状态显示
                 }
               }
 
-              //editableTabsValue.value = (tabNumber.value).toString();//显示下一个tab
-              isButtonDisabled.value = false; // 恢复按钮
+              isButtonDisabled.value = false; // 恢复按钮可用状态
+              
+              // ★★★ 通知父组件系数校准成功完成，触发自动步骤切换 ★★★
               emit('update:testStatus', 'success')
               break;
           }
+          // ==================== 表格数据实时更新 ====================
           switch (newValue.operateCode) {
-            case 'DATA_CHNFACTOR$02'://表格
-              // 输出 key 为 0 的数组中的第一条 ChannelsTest.CoefficientVO 对象
+            case 'DATA_CHNFACTOR$02':
+              // 接收并更新表格中的系数校准数据
               console.log('表格', name.value)
+              
+              // 遍历所有设备，找到匹配的表格项并更新数据
               for (let i = 0; i < name.value.length; i++) {
                 const targetArrayRef = tableDataMap.get(i);
                 if (targetArrayRef) {
                   const targetArray = targetArrayRef.value;
                   if (targetArray.length > 0) {
-                    const firstCoefficientVO = targetArray.find(item => item.monitorNum === newValue.data.monitorNum &&
-                        item.type === newValue.data.type &&
-                        item.desc === newValue.data.desc &&
-                        item.devName === newValue.data.devName);
-                    if (firstCoefficientVO) { // 检查 firstCoefficientVO 是否存在
+                    // 根据监测点号、类型、描述和设备名称找到对应的表格行
+                    const firstCoefficientVO = targetArray.find(item => 
+                      item.monitorNum === newValue.data.monitorNum &&
+                      item.type === newValue.data.type &&
+                      item.desc === newValue.data.desc &&
+                      item.devName === newValue.data.devName);
+                      
+                    if (firstCoefficientVO) {
+                      // 更新A相电压数据和误差
                       firstCoefficientVO.aVuData = parseFloat(newValue.data.aVuData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.aVuXi)) && isFinite(newValue.data.aVuXi)) {
                         firstCoefficientVO.aVuXi = (parseFloat(newValue.data.aVuXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.aVuXi = newValue.data.aVuXi;
+                        firstCoefficientVO.aVuXi = newValue.data.aVuXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新B相电压数据和误差
                       firstCoefficientVO.bVuData = parseFloat(newValue.data.bVuData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.bVuXi)) && isFinite(newValue.data.bVuXi)) {
                         firstCoefficientVO.bVuXi = (parseFloat(newValue.data.bVuXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.bVuXi = newValue.data.bVuXi;
+                        firstCoefficientVO.bVuXi = newValue.data.bVuXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新C相电压数据和误差
                       firstCoefficientVO.cVuData = parseFloat(newValue.data.cVuData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.cVuXi)) && isFinite(newValue.data.cVuXi)) {
                         firstCoefficientVO.cVuXi = (parseFloat(newValue.data.cVuXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.cVuXi = newValue.data.cVuXi;
+                        firstCoefficientVO.cVuXi = newValue.data.cVuXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新A相电流数据和误差
                       firstCoefficientVO.aIeData = parseFloat(newValue.data.aIeData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.aIeXi)) && isFinite(newValue.data.aIeXi)) {
                         firstCoefficientVO.aIeXi = (parseFloat(newValue.data.aIeXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.aIeXi = newValue.data.aIeXi;
+                        firstCoefficientVO.aIeXi = newValue.data.aIeXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新B相电流数据和误差
                       firstCoefficientVO.bIeData = parseFloat(newValue.data.bIeData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.bIeXi)) && isFinite(newValue.data.bIeXi)) {
                         firstCoefficientVO.bIeXi = (parseFloat(newValue.data.bIeXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.bIeXi = newValue.data.bIeXi;
+                        firstCoefficientVO.bIeXi = newValue.data.bIeXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新C相电流数据和误差
                       firstCoefficientVO.cIeData = parseFloat(newValue.data.cIeData).toFixed(4);
-
                       if (!isNaN(parseFloat(newValue.data.cIeXi)) && isFinite(newValue.data.cIeXi)) {
                         firstCoefficientVO.cIeXi = (parseFloat(newValue.data.cIeXi) / 10000).toFixed(4);
                       } else {
-                        firstCoefficientVO.cIeXi = newValue.data.cIeXi;
+                        firstCoefficientVO.cIeXi = newValue.data.cIeXi; // 可能是"不合格"等文本
                       }
 
+                      // 更新三相电压和电流的原始值
                       firstCoefficientVO.aV = newValue.data.aV;
                       firstCoefficientVO.bV = newValue.data.bV;
                       firstCoefficientVO.cV = newValue.data.cV;
                       firstCoefficientVO.aI = newValue.data.aI;
                       firstCoefficientVO.bI = newValue.data.bI;
                       firstCoefficientVO.cI = newValue.data.cI;
+                      
                       console.log(newValue.data.devName + '对象:', firstCoefficientVO);
-                      activeIndex.value++;
+                      activeIndex.value++; // 更新活跃索引
                     } else {
                       console.log('未找到匹配的' + newValue.data.devName + '对象');
                     }
@@ -509,9 +610,11 @@ watch(webMsgSend, function (newValue, oldValue) {
               break;
           }
           break;
+        // 处理Socket连接超时
         case 'socket_timeout':
           switch (newValue.operateCode) {
             case 'VOLTAGE':
+              // 电压连接超时
               ElMessageBox.alert('连接超时！', '连接超时', {
                 confirmButtonText: '确定',
                 type: 'error',
@@ -520,9 +623,11 @@ watch(webMsgSend, function (newValue, oldValue) {
               break;
           }
           break;
+        // 处理连接失败
         case 'connect':
           switch (newValue.operateCode) {
             case "Source":
+              // 源服务端连接失败
               ElMessageBox.alert('源服务端连接失败', '源服务端连接失败', {
                 confirmButtonText: '确定',
                 type: 'error',
@@ -530,6 +635,7 @@ watch(webMsgSend, function (newValue, oldValue) {
               TableInit();
               break;
             case "Dev":
+              // 设备服务端连接失败
               ElMessageBox.alert('设备服务端连接失败', '设备服务端连接失败', {
                 confirmButtonText: '确定',
                 type: 'error',
@@ -537,57 +643,97 @@ watch(webMsgSend, function (newValue, oldValue) {
               TableInit();
               break;
           }
-
           break;
       }
     }
   }
 })
 
-//出错系数检测初始化
+// ==================== 错误处理函数 ====================
+/**
+ * 系数校准出错时的初始化处理
+ * 通知父组件检测失败，重置相关状态
+ */
 const TableInit = () => {
   console.log("出错系数检测",active.value);
-  emit('update:testStatus', 'test_init_fail')
-  // isButtonDisabled.value = false; // 恢复按钮
-  // for (let i = 0; i < channel.value.length; i++) {
-  //   const currentTableData = initializeTableData(dataTemplates, i);
-  //   tableDataMap.set(i, currentTableData)
-  // }
-  // activeIndex.value = 0
-  // qualified.value = 0
-  // active.value = 0
-
+  // 通知父组件系数校准失败
+  emit('update:testStatus', 'error')
 }
 
-//按行图标转动
+// ==================== 界面动画控制 ====================
+/**
+ * 控制表格中特定类型和描述的行显示加载动画
+ * @param type 类型：'big' | 'small'
+ * @param desc 描述：'系数下装' | '系数校准'
+ */
 const tableLoading = (type: string, desc: string) => {
   console.log('转动',channel.value)
+  
+  // 遍历所有设备
   for (let i = 0; i < channel.value.length; i++) {
-
     const targetArrayRef = tableDataMap.get(i);
     if (targetArrayRef) {
       const targetArray = targetArrayRef.value;
       if (targetArray.length > 0) {
+        // 遍历当前设备的所有通道
         for (let j = 0; j < channel.value[i]; j++) {
-          const firstCoefficientVO = targetArray.find(item => item.monitorNum === (j + 1).toString() &&
-              item.type === type &&
-              item.desc === desc);
+          // 找到对应类型和描述的表格行
+          const firstCoefficientVO = targetArray.find(item => 
+            item.monitorNum === (j + 1).toString() &&
+            item.type === type &&
+            item.desc === desc);
           if (firstCoefficientVO) {
-            firstCoefficientVO.loading = true;
+            firstCoefficientVO.loading = true; // 开启加载动画
           }
         }
       }
-    }else{
+    } else {
       console.log('不转了')
     }
   }
 }
 
+// ==================== 表格数据模板 ====================
+/**
+ * 系数校准表格的数据模板
+ * 每个设备的每个通道都会根据这4个模板生成对应的表格行
+ * 
+ * 模板说明：
+ * 1. 监测点1 - 大幅值系数下装
+ * 2. 监测点2 - 小幅值系数下装  
+ * 3. 监测点3 - 大幅值系数校准
+ * 4. 监测点4 - 小幅值系数校准
+ */
 const dataTemplates: ChannelsTest.CoefficientVO[] = [
   {
-    monitorNum: '1',
-    desc: '系数下装',
-    type: 'big',
+    monitorNum: '1',      // 监测点编号
+    desc: '系数下装',     // 操作描述
+    type: 'big',          // 幅值类型：大幅值
+    aVuData: '—',         // A相电压测量值
+    aVuXi: '—',           // A相电压误差
+    bVuData: '—',         // B相电压测量值
+    bVuXi: '—',           // B相电压误差
+    cVuData: '—',         // C相电压测量值
+    cVuXi: '—',           // C相电压误差
+    aIeData: '—',         // A相电流测量值
+    aIeXi: '—',           // A相电流误差
+    bIeData: '—',         // B相电流测量值
+    bIeXi: '—',           // B相电流误差
+    cIeData: '—',         // C相电流测量值
+    cIeXi: '—',           // C相电流误差
+    loading: false,       // 加载状态
+    devName: '',          // 设备名称（动态填充）
+    aV: '—',              // A相电压原始值
+    bV: '—',              // B相电压原始值
+    cV: '—',              // C相电压原始值
+    aI: '—',              // A相电流原始值
+    bI: '—',              // B相电流原始值
+    cI: '—',              // C相电流原始值
+  },
+  {
+    monitorNum: '2',      // 监测点编号
+    desc: '系数下装',     // 操作描述
+    type: 'small',        // 幅值类型：小幅值
     aVuData: '—',
     aVuXi: '—',
     bVuData: '—',
@@ -610,9 +756,9 @@ const dataTemplates: ChannelsTest.CoefficientVO[] = [
     cI: '—',
   },
   {
-    monitorNum: '2',
-    desc: '系数下装',
-    type: 'small',
+    monitorNum: '3',      // 监测点编号
+    desc: '系数校准',     // 操作描述
+    type: 'big',          // 幅值类型：大幅值
     aVuData: '—',
     aVuXi: '—',
     bVuData: '—',
@@ -635,9 +781,9 @@ const dataTemplates: ChannelsTest.CoefficientVO[] = [
     cI: '—',
   },
   {
-    monitorNum: '3',
-    desc: '系数校准',
-    type: 'big',
+    monitorNum: '4',      // 监测点编号
+    desc: '系数校准',     // 操作描述
+    type: 'small',        // 幅值类型：小幅值
     aVuData: '—',
     aVuXi: '—',
     bVuData: '—',
@@ -659,64 +805,51 @@ const dataTemplates: ChannelsTest.CoefficientVO[] = [
     bI: '—',
     cI: '—',
   },
-  {
-    monitorNum: '4',
-    desc: '系数校准',
-    type: 'small',
-    aVuData: '—',
-    aVuXi: '—',
-    bVuData: '—',
-    bVuXi: '—',
-    cVuData: '—',
-    cVuXi: '—',
-    aIeData: '—',
-    aIeXi: '—',
-    bIeData: '—',
-    bIeXi: '—',
-    cIeData: '—',
-    cIeXi: '—',
-    loading: false,
-    devName: '',
-    aV: '—',
-    bV: '—',
-    cV: '—',
-    aI: '—',
-    bI: '—',
-    cI: '—',
-  },
-
 ];
 
 
-// 更新错误状态的方法
+// ==================== 工具函数 ====================
+/**
+ * 更新设备错误状态显示
+ * @param index 设备索引
+ * @param hasError 是否有错误
+ */
 const updateErrorState = (index: number, hasError: boolean) => {
   errorStates.value[index] = hasError;
 };
 
-
-// const emit = defineEmits<{
-  
-//   (e: 'submitClicked', callback: (resolve: (value: boolean) => void) => void): void;
-// }>();
-
-const emit = defineEmits(['update:testStatus']);
-
+/**
+ * 获取指定设备的表格数据
+ * @param index 设备索引
+ * @returns 返回对应设备的表格数据数组
+ */
 const getTableDataForChannel = (index: number): any[] => {
   const data = tableDataMap.get(index);
   return data ? data.value : [];
 }
 
+// ==================== 父子组件通信 ====================
+const emit = defineEmits(['update:testStatus']);
 
+
+// ==================== 界面状态监听 ====================
+/**
+ * 监听活跃索引变化，更新界面描述信息
+ */
 watch(activeIndex, function (newValue, oldValue) {
   if (activeIndex.value === 1) {
     outputDsc.value = "电压误差为：±0.1Un%； 电流误差为：±0.5%";
-    // 当前源输出为：Ua=Ub=Uc=57.74V Ia=Ib=Ic=1A"
   }
 })
 
-// 示例的 checkForErrors 函数，根据实际需求进行调整
+// ==================== 业务逻辑函数 ====================
+/**
+ * 检查设备校准数据是否存在错误
+ * @param data 设备的校准数据数组
+ * @returns 返回是否存在不合格项
+ */
 const checkForErrors = (data: ChannelsTest.CoefficientVO[]): boolean => {
-  // 这里假设不合格字段的标准是 status 为 '不合格' 或 isValid 为 false
+  // 检查各相电压和电流的误差值是否为"不合格"
   return data.some(item =>
       item.aVuXi === '不合格' ||
       item.bVuXi === '不合格' ||
@@ -727,43 +860,35 @@ const checkForErrors = (data: ChannelsTest.CoefficientVO[]): boolean => {
   );
 };
 
+/**
+ * 处理系数校准开始事件
+ * 由父组件通过状态监听触发
+ */
 const handleSubmit = async () => {
-  // 创建一个 Promise 来等待父组件的回调
-  // const response = await new Promise<boolean>((resolve) => {
-  //   emit('submitClicked', resolve);
-  // });
-
-  // if (!response) {
-  //   return;
-  // }()
-
-  isButtonDisabled.value = true; // 禁用按钮
-  tableLoading('big', '系数下装')
-/*  await getCoefficientCheck({
-    userPageId: "cdf",
-    devIds: devIdArray.value,
-    planId: planId.value,
-    errorSysId: select_Plan.value?.errorSysId,
-    scriptId: select_Plan.value?.scriptId,
-    operateType: '0', // '0'为预检测、‘1‘为正式检测
-    userId:userStore.userInfo.id
-  })*/
-  active.value++;  
-
+  isButtonDisabled.value = true; // 禁用按钮，防止重复提交
+  tableLoading('big', '系数下装') // 开启大幅值系数下装的加载动画
+  active.value++; // 步骤进度+1，进入第一个校准阶段
   console.log('开始检测active.value', active.value)
 };
 
-// 提取初始化并填充 currentTableData 的函数
+/**
+ * 为指定设备初始化表格数据
+ * @param templates 数据模板数组
+ * @param index 设备索引
+ * @returns 返回初始化后的表格数据引用
+ */
 const initializeTableData = (templates: ChannelsTest.CoefficientVO[], index: number): Ref<ChannelsTest.CoefficientVO[]> => {
   const currentTableData = ref<ChannelsTest.CoefficientVO[]>([]);
+  
+  // 为当前设备的每个通道生成表格数据
   for (let j = 0; j < channel.value[index]; j++) {
     templates.forEach((template) => {
-      // 使用解构赋值排除 id 和 MonitorIdx 属性
+      // 使用解构赋值复制模板，排除不需要的属性
       const {devName, monitorNum: __, ...rest} = template;
       currentTableData.value.push({
-        monitorNum: (j + 1).toString(),
-        devName: name.value[index],
-        ...rest,
+        monitorNum: (j + 1).toString(),  // 监测点号从1开始
+        devName: name.value[index],      // 设置设备名称
+        ...rest,                         // 其他模板属性
       });
     });
   }
@@ -813,9 +938,6 @@ const initializeTableData = (templates: ChannelsTest.CoefficientVO[], index: num
   height: 470px;
 }
 
-/* .el-icon svg {
-  color: #ff7171;
-} */
 
 .icon-style {
   color: #ff7171;

frontend/src/views/home/components/matchPopup.vue

@@ -1,202 +0,0 @@
-<template>
-    <!-- 基础信息弹出框 -->
-  <el-dialog :model-value="visible" title="被检监测点匹配" v-bind="dialogSmall"  @close="handleCancel"  width="500" draggable>
-     <div>
-       <el-form :model="formData" ref='formRuleRef' :rules='rules' change-event="selectChange">
-         <el-form-item label="监测点名称：" :label-width="100">
-            <el-tree-select v-model="value1" :data="sourcesList" style="width: 240px" />
-        </el-form-item>
-        <el-form-item label="监测点名称：" :label-width="100">
-            <el-tree-select v-model="value2" :data="sourcesList" style="width: 240px" />
-        </el-form-item>
-        <el-form-item label="监测点名称：" :label-width="100">
-            <el-tree-select v-model="value3" :data="sourcesList" style="width: 240px" />
-        </el-form-item>
-        <el-form-item label="监测点名称：" :label-width="100">
-            <el-tree-select v-model="value4" :data="sourcesList" style="width: 240px" />
-        </el-form-item>
-       </el-form>
-     </div>
-       <template #footer>
-         <div class="dialog-footer">
-           <el-button @click="handleCancel">取 消</el-button>
-           <el-button type="primary" @click="handleSubmit">确 定</el-button>
-         </div>
-       </template>
-     </el-dialog>
- </template>
- 
- <script setup lang="ts">
-   import{ElMessage, FormInstance,FormItemRule}from'element-plus'
-   import { defineProps, defineEmits, reactive,watch,ref, Ref } from 'vue';
-   import { dialogSmall} from '@/utils/elementBind'
-   import {dictPattern,dictTestState,dictReportState,dictResult,testPlanDataList,sourceDataList,deviceDataList,testSoureDataList,testScriptDataList,testErrSystDataList,planData,testFatherPlanList} from '@/api/plan/planData'
- 
-   const selectChange = (val: any) => {
-    console.log(val)
-  }
-const value1 = ref()
-const value2 = ref()
-const value3 = ref()
-const value4 = ref()
-
-const sourcesList = [
-  {
-    value: '1',
-    label: '高精度设备-PQV520-1',
-    disabled: false,
-    children: [
-      {
-        value: '1-1',
-        label: '监测点1',
-        disabled: false,
-      },
-      {
-        value: '1-2',
-        label: '监测点2',
-        disabled: false,
-      },
-    ],
-  },
-  {
-    value: '2',
-    label: '高精度设备-PQV520-2',
-    disabled: false,
-    children: [
-      {
-        value: '2-1',
-        label: '监测点1',
-        disabled: false,
-      },
-      {
-        value: '2-2',
-        label: '监测点2',
-        disabled: false,
-      },
-    ],
-  },
-  {
-    value: '3',
-    label: '高精度设备-PQV520-3',
-    disabled: false,
-    children: [
-      {
-        value: '3-1',
-        label: '监测点1',
-        disabled: false,
-      },
-      {
-        value: '3-2',
-        label: '监测点2',
-        disabled: false,
-      },
-    ],
-  },
-  {
-    value: '4',
-    label: '高精度设备-PQV520-4',
-    disabled: false,
-    children: [
-      {
-        value: '4-1',
-        label: '监测点1',
-        disabled: false,
-      },
-      {
-        value: '4-2',
-        label: '监测点2',
-        disabled: false,
-      },
-    ],
-  },
-]
-
-   const props = defineProps<{
-     visible: boolean;
-   }>();
- 
-   const fatherPlanList = [
-   { label: '/', value: 'type0' },
-   { label: '检测计划1', value: 'type1' },
-   { label: '检测计划2', value: 'type2' },
-   { label: '检测计划3', value: 'type3' },
-   { label: '检测计划4', value: 'type4' },
- ];
- 
- const sourceList = [
-   { label: '分钟统计数据最大值', value: 'type0' },
-   { label: '分钟统计数据最大值', value: 'type1' },
-   { label: '分钟统计数据CP95值', value: 'type2' },
- ];
- 
- const scriptList = [
-   { label: '/', value: 'type0' },
-   { label: '国网入网检测脚本（单影响量-模拟式）', value: 'type1' },
-   { label: '国网入网检测脚本（Q/GDW 10650.4 - 2021) 数字式', value: 'type1' },
- ];
- 
- const errorList = [
-   { label: 'Q/GDW 1650.2- 2016', value: 'type0' },
-   { label: 'Q/GDW 10650.2 - 2021', value: 'type1' },
- ];
- 
- 
- const emit = defineEmits<{
-     (e: 'update:visible', value: boolean): void;
-     (e: 'submit', data: any): void;
-   }>();
-   
- // 定义规则
- const formRuleRef = ref<FormInstance>()
- const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
-     name: [{ required: true, message: '检测计划名称必填！', trigger: 'blur' }],
-     source_Id: [{ required: true, message: '检测源必选！', trigger: 'blur' }],
-     dataSource_Id: [{ required: true, message: '数据源必选！', trigger: 'blur' }],
-     script_Id: [{ required: true, message: '检测脚本必选！', trigger: 'blur' }],
-     error_Sys_Id: [{ required: true, message: '误差体系必选！', trigger: 'blur' }],
-     // name: [{ required: true, message: '检测计划名称必填！', trigger: 'blur' }],
-     // father_Plan_Id: [{ required: true, message: '参照标准名称必填！', trigger: 'change' }],
-    
- });
- 
-   const handleCancel = () => {
-     //重置表单内容
-     //取消表单校验状态
-     formRuleRef.value && formRuleRef.value.resetFields()
-     emit('update:visible', false); // 关闭对话框
-   };
-   
-   const handleSubmit = () => {
- 
-     try {
-     formRuleRef.value?.validate((valid: boolean) => {
-     if (valid) 
-     {
-         // 将表单数据转为json,发送到后端
-         let confirmFormData = JSON.parse(JSON.stringify(props.formData));
-         //console.log(confirmFormData)
-         emit('submit', props.formData); // 提交表单数据
-         emit('update:visible', false); // 提交后关闭对话框             
-     } 
-     else 
-     {
-         ElMessage.error('请填选必填项！')
-     }
-     })
-     } catch (error) {
-         console.error('验证过程中发生错误', error)
-     }
-   };
-   
-   // 当 props.visible 改变时，更新 formData
-   watch(() => props.visible, (newVal) => {
-     if (!newVal) {
-       // 这里可以重置表单数据，如果需要的话
-      
-     }
-   });
- </script>
- 
- <style scoped>
- 
- </style>

frontend/src/views/home/components/preTest.vue

@@ -11,8 +11,7 @@
 
     <div class="test-dialog">
       <div class="dialog-left">
-        <el-steps direction="vertical" :active="activeIndex" :process-status="currentStepStatus"
-                  finish-status="success">
+        <el-steps direction="vertical" :active="activeIndex" finish-status="success">
           <el-step :status="step1" title="源通讯校验"/>
           <el-step :status="step2" title="设备通讯校验"/>
           <el-step :status="step3" title="协议校验"/>
@@ -67,9 +66,19 @@
 
 </template>
 <script lang="tsx" setup name="preTest">
+/**
+ * 预检测组件
+ * 负责电力设备检测中的预检测阶段，包含4个步骤：
+ * 1. 源通讯校验 - 验证源端通讯是否正常
+ * 2. 设备通讯校验 - 检查设备IP、端口、识别码、密钥
+ * 3. 协议校验 - 进行ICD报告触发测试
+ * 4. 相序校验 - 判断装置接线是否正确
+ */
 import {ElMessage, ElMessageBox} from "element-plus";
-import {defineExpose, toRef} from 'vue';
+import {defineExpose, ref, toRef, watch} from 'vue';
 
+// ==================== 日志数据存储 ====================
+// 各步骤的日志数据，用于在右侧折叠面板中显示实时日志
 const step1InitLog = ref([
   {
     type: 'info',
@@ -77,13 +86,6 @@ const step1InitLog = ref([
   },
 ])
 
-const step1Log = ref([
-  {
-    type: 'info',
-    log: '源通讯校验成功',
-  },
-])
-
 const step2InitLog = ref([
   {
     type: 'info',
@@ -91,25 +93,6 @@ const step2InitLog = ref([
   },
 ])
 
-const step2Log = ref([
-  {
-    type: 'info',
-    log: '被检设备：240001通讯校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240002通讯校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240003通讯校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240004通讯校验成功',
-  },
-])
-
 const step3InitLog = ref([
   {
     type: 'info',
@@ -117,26 +100,6 @@ const step3InitLog = ref([
   },
 ])
 
-const step3Log = ref([
-  {
-    type: 'info',
-    log: '被检设备：240001协议校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240002协议校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240003协议校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240004协议校验成功',
-  },
-])
-
-
 const step4InitLog = ref([
   {
     type: 'info',
@@ -144,35 +107,21 @@ const step4InitLog = ref([
   },
 ])
 
-const step4Log = ref([
-  {
-    type: 'info',
-    log: '被检设备：240001相序校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240002相序校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240003相序校验成功',
-  },
-  {
-    type: 'info',
-    log: '被检设备：240004相序校验成功',
-  },
-])
+// ==================== 界面状态控制 ====================
+const collapseActiveName = ref('1') // 当前展开的折叠面板
+const activeIndex = ref(0) // 当前激活的步骤索引（用于步骤条高亮）
+const activeTotalNum = ref(5) // 总步骤数
 
-const collapseActiveName = ref('1')
-const activeIndex = ref(0)
-const activeTotalNum = ref(5)
-const step1 = ref('wait')
-const step2 = ref('wait')
-const step3 = ref('wait')
-const step4 = ref('wait')
-const step5 = ref('wait')
+// ==================== 步骤状态管理 ====================
+// 各步骤的执行状态：wait/process/success/error
+const step1 = ref('wait') // 源通讯校验状态
+const step2 = ref('wait') // 设备通讯校验状态
+const step3 = ref('wait') // 协议校验状态
+const step4 = ref('wait') // 相序校验状态
+const step5 = ref('wait') // 整体检测结果状态
 
-//定义与预检测配置数组
+// ==================== 预检测项目配置 ====================
+// 定义预检测包含的检测项目（顶部tabs显示用，只读）
 const detectionOptions = ref([
   {
     id: 0,
@@ -193,45 +142,67 @@ const detectionOptions = ref([
     id: 3,
     name: "相序校验",//判断装置的接线是否正确
     selected: true,
-  },
-  //   {
-  //     id: 4,
-  //     name: "守时校验",//判断装置24小时内的守时误差是否小于1s
-  //     selected: true,
-  //   },
-  //   {
-  //     id: 5,
-  //     name: "通道系数校准",//通过私有协议与装置进行通讯，校准三相电压电流的通道系数
-  //     selected: true,
-  //   },
-  // {
-  //   id: 6,
-  //   name: "实时数据比对",
-  // },
-  // {
-  //   id: 7,
-  //   name: "录波数据比对",
-  // },
+  }
 ]);
 
-const currentStepStatus = ref<'error' | 'finish' | 'wait' | 'success' | 'process'>('finish');
 
+// ==================== 组件Props定义 ====================
 const props = defineProps({
   testStatus: {
     type: String,
-    default: 'wait'
+    default: 'wait' // 从父组件接收的测试状态
   },
   webMsgSend: {
     type: Object,
-    default: () => ({})
+    default: () => ({}) // 从父组件接收的WebSocket消息
   }
 })
 
-
+// ==================== 响应式Props引用 ====================
 const testStatus = toRef(props, 'testStatus');
 const webMsgSend = toRef(props, 'webMsgSend');
-const ts = ref('');
+const ts = ref(''); // 内部测试状态，用于向父组件同步
 
+// ==================== 错误处理函数 ====================
+/**
+ * 处理致命错误 - 会终止整个检测流程
+ * @param stepRef 当前步骤状态引用
+ * @param logRef 当前步骤日志引用  
+ * @param message 错误消息
+ */
+function handleFatalError(stepRef: any, logRef: any, message: string) {
+  stepRef.value = 'error';
+  ts.value = 'error';
+  step5.value = 'error';
+  logRef.value.push({
+    type: 'error',
+    log: message
+  });
+}
+
+/**
+ * 处理警告错误 - 只标记当前步骤失败，检测可继续
+ * @param stepRef 当前步骤状态引用
+ * @param logRef 当前步骤日志引用
+ * @param message 错误消息
+ */
+function handleWarningError(stepRef: any, logRef: any, message: string) {
+  stepRef.value = 'error';
+  logRef.value.push({
+    type: 'error',
+    log: message
+  });
+}
+
+// ==================== WebSocket消息处理 ====================
+/**
+ * 监听WebSocket消息，根据不同的requestId和operateCode处理各种检测状态
+ * 主要消息类型：
+ * - yjc_ytxjy: 源通讯校验
+ * - yjc_sbtxjy: 设备通讯校验  
+ * - yjc_xyjy: 协议校验
+ * - YJC_xujy: 相序校验
+ */
 watch(webMsgSend, function (newValue, oldValue) {
   if (testStatus.value !== 'waiting') {
     switch (newValue.requestId) {
@@ -254,33 +225,16 @@ watch(webMsgSend, function (newValue, oldValue) {
               }];
             } else if (newValue.code == 10552) {
               ElMessage.error(newValue.code)
-              step1.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step1, step1InitLog, '重复的初始化操作!')
             } else if (newValue.code == 10523) {
-              step1.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
-              step1InitLog.value = [{
-                type: 'error',
-                log: '源连接失败!',
-              }];
+              handleFatalError(step1, step1InitLog, '源连接失败!')
             } else if (newValue.code == -1) {
-              step1.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
-              step1InitLog.value = [{
-                type: 'error',
-                log: '源未知异常!',
-              }];
+              handleFatalError(step1, step1InitLog, '源未知异常!')
             }
             break;
-
-
         }
         break;
       case 'yjc_sbtxjy':
-
         switch (newValue.operateCode) {
           case 'INIT_GATHER$01':
             if (newValue.code == 10200) {
@@ -296,30 +250,11 @@ watch(webMsgSend, function (newValue, oldValue) {
                 log: '正在进行设备通讯校验.....',
               }];
             } else if (newValue.code == 10550) {
-              step2InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备连接异常!',
-              })
-              step2.value = 'error'
-              // ts.value = 'error'
-              // step5.value = 'error'
+              handleWarningError(step2, step2InitLog, newValue.data + '设备连接异常!')
             } else if (newValue.code == 10551) {
-              step2InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备触发报告异常!',
-              })
-              step2.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step2, step2InitLog, newValue.data + '设备触发报告异常!')
             } else if (newValue.code == 10552) {
-              //ElMessage.error("存在已经初始化步骤,已经自动关闭,请重新发起检测！")
-              step2InitLog.value = [{
-                type: 'wait',
-                log: '存在已经初始化步骤,执行自动关闭,请重新发起检测！',
-              }];
-              step2.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step2, step2InitLog, '存在已经初始化步骤,执行自动关闭,请重新发起检测！')
             } else if (newValue.code == 25001) {
               activeIndex.value = 2
               step2.value = 'success'
@@ -327,7 +262,6 @@ watch(webMsgSend, function (newValue, oldValue) {
             }
             break;
         }
-
         break;
       case 'yjc_xyjy':
         switch (newValue.operateCode) {
@@ -345,30 +279,11 @@ watch(webMsgSend, function (newValue, oldValue) {
                 log: '正在进行通讯协议校验.....',
               }];
             } else if (newValue.code == 10550) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备连接异常!',
-              })
-              step3.value = 'error'
-              // ts.value = 'error'
-              // step5.value = 'error'
+              handleWarningError(step3, step3InitLog, newValue.data + '设备连接异常!')
             } else if (newValue.code == 10551) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备触发报告异常!',
-              })
-              step3.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, newValue.data + '设备触发报告异常!')
             } else if (newValue.code == 10552) {
-              step3.value = 'error'
-              //ElMessage.error("存在已经初始化步骤,已经自动关闭,请重新发起检测！")
-              step3InitLog.value = [{
-                type: 'wait',
-                log: '存在已经初始化步骤,执行自动关闭,请重新发起检测！',
-              }];
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, '存在已经初始化步骤,执行自动关闭,请重新发起检测！')
             }
             break;
           case 'INIT_GATHER$02':
@@ -385,30 +300,11 @@ watch(webMsgSend, function (newValue, oldValue) {
                 log: '正在进行通讯协议校验.....',
               }];
             } else if (newValue.code == 10550) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备连接异常!',
-              })
-              step3.value = 'error'
-              // ts.value = 'error'
-              // step5.value = 'error'
+              handleWarningError(step3, step3InitLog, newValue.data + '设备连接异常!')
             } else if (newValue.code == 10551) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备触发报告异常!',
-              })
-              step3.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, newValue.data + '设备触发报告异常!')
             } else if (newValue.code == 10552) {
-              step3.value = 'error'
-              //ElMessage.error("存在已经初始化步骤,已经自动关闭,请重新发起检测！")
-              step3InitLog.value = [{
-                type: 'wait',
-                log: '存在已经初始化步骤,执行自动关闭,请重新发起检测！',
-              }];
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, '存在已经初始化步骤,执行自动关闭,请重新发起检测！')
             }
             break;
           case 'INIT_GATHER$03':
@@ -421,30 +317,11 @@ watch(webMsgSend, function (newValue, oldValue) {
             } else if (newValue.code == 10201) {
               step3.value = 'process'
             } else if (newValue.code == 10550) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备连接异常!',
-              })
-              step3.value = 'error'
-              // ts.value = 'error'
-              // step5.value = 'error'
+              handleWarningError(step3, step3InitLog, newValue.data + '设备连接异常!')
             } else if (newValue.code == 10551) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: newValue.data + '设备触发报告异常!',
-              })
-              step3.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, newValue.data + '设备触发报告异常!')
             } else if (newValue.code == 10552) {
-              //ElMessage.error("当前步骤已经初始化,执行自动关闭,请重新发起检测！")
-              step3.value = 'error'
-              step3InitLog.value = [{
-                type: 'wait',
-                log: '存在已经初始化步骤,执行自动关闭,请重新发起检测！',
-              }];
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, '存在已经初始化步骤,执行自动关闭,请重新发起检测！')
             }
             break;
           case 'VERIFY_MAPPING$01':
@@ -452,23 +329,11 @@ watch(webMsgSend, function (newValue, oldValue) {
               activeIndex.value = 3
               step3.value = 'success'
               step4.value = 'process'
-            } else if (newValue.code == 10200) {
+            } else if (newValue.code == 25002) {
               let data = JSON.parse(newValue.data)
-              step3InitLog.value.push({
-                type: 'error',
-                log: `脚本与icd检验失败! icd名称：${data['icdType']} -> 校验项：${data['dataType']}`,
-              })
-              step3.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, `脚本与icd检验失败! icd名称：${data['icdType']} -> 校验项：${data['dataType']}`)
             } else if (newValue.code == 10500) {
-              step3InitLog.value.push({
-                type: 'error',
-                log: `装置中未找到该icd！`,
-              })
-              step3.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step3, step3InitLog, '装置中未找到该icd！')
             }
             break;
         }
@@ -484,53 +349,36 @@ watch(webMsgSend, function (newValue, oldValue) {
 
             } else if (newValue.code == 10201) {
               step4.value = 'process'
-              step4InitLog.value = [{
+              step4InitLog.value.push({
                 type: 'wait',
                 log: '源参数下发中.....',
-              }];
+              });
             } else if (newValue.code == 10552) {
               ElMessage.error("存在已经初始化步骤,已经自动关闭,请重新发起检测！")
-              step4.value = 'error'
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step4, step4InitLog, '存在已经初始化步骤,执行自动关闭,请重新发起检测！')
             } else if (newValue.code == 10520) {
-              step4.value = 'error'
-              step4InitLog.value.push({
-                type: 'error',
-                log: '解析报文异常',
-              })
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step4, step4InitLog, '解析报文异常')
             }
             break;
-
           case 'DATA_REQUEST$02':
             if (newValue.code == 10200) {
               let type = 'info'
               if (newValue.data.includes('不合格')) {
                 type = 'error'
               }
-
               newValue.data.split('<br/>')
               step4InitLog.value.push({
                 type: type,
                 log: newValue.data,
               })
-
             } else if (newValue.code == 10201) {
               step4.value = 'process'
-              step4InitLog.value = [{
+              step4InitLog.value.push({
                 type: 'wait',
                 log: '获取数据相序校验数据!',
-              }];
+              });
             } else if (newValue.code == 25003) {
-              step4.value = 'error'
-              step4InitLog.value.push({
-                type: 'error',
-                log: '相序校验未通过!',
-              })
-              ts.value = 'error'
-              step5.value = 'error'
+              handleFatalError(step4, step4InitLog, '相序校验未通过!')
             } else if (newValue.code == 25001) {
               step4.value = 'success'
               step5.value = 'success'
@@ -544,71 +392,85 @@ watch(webMsgSend, function (newValue, oldValue) {
             console.log("@@@@", ts.value)
             break
         }
-
         break;
       case 'quit':
         break;
       case 'connect':
         switch (newValue.operateCode) {
           case "Source":
-            step1.value = 'error'
-            step1InitLog.value = [{
-              type: 'error',
-              log: '源服务端连接失败!',
-            }];
-            ts.value = 'error'
-            step5.value = 'error'
+            handleFatalError(step1, step1InitLog, '源服务端连接失败!')
             break;
           case "Dev":
-            step2.value = 'error'
-            step2InitLog.value = [{
-              type: 'error',
-              log: '设备服务端连接失败!',
-            }];
-            ts.value = 'error'
-            step5.value = 'error'
+            handleFatalError(step2, step2InitLog, '设备服务端连接失败!')
             break;
         }
         break;
       case 'unknown_operate':
-
         break;
       case 'error_flow_end':
-        ElMessageBox.alert(`设备连接异常，请检查设备连接情况！`, '检测失败', {
+        ElMessageBox.alert(`当前流程存在异常结束！`, '检测失败', {
           confirmButtonText: '确定',
           type: 'error',
         })
-        ts.value = 'error'
-        step5.value = 'error'
+        // 根据当前步骤选择对应的日志记录
+        const currentStepLog = activeIndex.value === 0 ? step1InitLog :
+                              activeIndex.value === 1 ? step2InitLog :
+                              activeIndex.value === 2 ? step3InitLog : step4InitLog
+        const currentStep = activeIndex.value === 0 ? step1 :
+                           activeIndex.value === 1 ? step2 :
+                           activeIndex.value === 2 ? step3 : step4
+        handleFatalError(currentStep, currentStepLog, '设备连接异常，检测终止！')
         break;
       case 'socket_timeout':
         ElMessageBox.alert(`设备连接异常，请检查设备连接情况！`, '检测失败', {
           confirmButtonText: '确定',
           type: 'error',
         })
-        ts.value = 'error'
-        step5.value = 'error'
+        // 根据当前步骤选择对应的日志记录
+        const timeoutStepLog = activeIndex.value === 0 ? step1InitLog :
+                              activeIndex.value === 1 ? step2InitLog :
+                              activeIndex.value === 2 ? step3InitLog : step4InitLog
+        const timeoutStep = activeIndex.value === 0 ? step1 :
+                           activeIndex.value === 1 ? step2 :
+                           activeIndex.value === 2 ? step3 : step4
+        handleFatalError(timeoutStep, timeoutStepLog, 'Socket连接超时，检测终止！')
         break;
       case 'server_error':
         ElMessageBox.alert('服务端主动关闭连接!', '初始化失败', {
           confirmButtonText: '确定',
           type: 'error',
         })
-        ts.value = 'error'
-        step5.value = 'error'
+        // 根据当前步骤选择对应的日志记录
+        const serverStepLog = activeIndex.value === 0 ? step1InitLog :
+                             activeIndex.value === 1 ? step2InitLog :
+                             activeIndex.value === 2 ? step3InitLog : step4InitLog
+        const serverStep = activeIndex.value === 0 ? step1 :
+                          activeIndex.value === 1 ? step2 :
+                          activeIndex.value === 2 ? step3 : step4
+        handleFatalError(serverStep, serverStepLog, '服务端主动关闭连接！')
         break;
       case 'device_error':
         ElMessageBox.alert('设备主动关闭连接!', '初始化失败', {
           confirmButtonText: '确定',
           type: 'error',
         })
-        ts.value = 'error'
-        step5.value = 'error'
+        // 根据当前步骤选择对应的日志记录
+        const deviceStepLog = activeIndex.value === 0 ? step1InitLog :
+                             activeIndex.value === 1 ? step2InitLog :
+                             activeIndex.value === 2 ? step3InitLog : step4InitLog
+        const deviceStep = activeIndex.value === 0 ? step1 :
+                          activeIndex.value === 1 ? step2 :
+                          activeIndex.value === 2 ? step3 : step4
+        handleFatalError(deviceStep, deviceStepLog, '设备主动关闭连接！')
         break;
     }
   }
 })
 
+// ==================== 界面联动控制 ====================
+/**
+ * 监听当前激活步骤，自动展开对应的日志折叠面板
+ */
 watch(activeIndex, function (newValue, oldValue) {
   if (newValue <= activeTotalNum.value - 2) {
     collapseActiveName.value = (newValue + 1).toString()
@@ -617,7 +479,10 @@ watch(activeIndex, function (newValue, oldValue) {
   }
 })
 
-//监听goods_sn的变化
+/**
+ * 监听父组件传入的测试状态变化
+ * 处理测试开始和重置逻辑
+ */
 watch(testStatus, function (newValue, oldValue) {
   ts.value = props.testStatus;
   if (ts.value === 'start') {
@@ -638,15 +503,23 @@ watch(testStatus, function (newValue, oldValue) {
   }
 })
 
+// ==================== 父子组件通信 ====================
 const emit = defineEmits(['update:testStatus']);
-//监听sn
+
+/**
+ * 监听内部测试状态变化，同步给父组件
+ * 实现双向数据绑定
+ */
 watch(ts, function (newValue, oldValue) {
-  //修改父组件
   emit('update:testStatus', ts.value)
 })
 
 
-// 定义一个初始化参数的方法
+// ==================== 对外暴露方法 ====================
+/**
+ * 初始化参数方法
+ * 由父组件调用，用于重置所有步骤状态和日志
+ */
 function initializeParameters() {
   activeIndex.value = 0
   step1.value = 'process'
@@ -683,6 +556,7 @@ function initializeParameters() {
 }
 
 
+// 暴露方法给父组件使用
 defineExpose({
   initializeParameters,
 });
@@ -695,9 +569,6 @@ defineExpose({
   flex-direction: row;
   /* 横向排列 */
   margin-top: 20px;
-  /* .dialog-left{
-        margin-right: 20px;
-    } */
 }
 
 .dialog-left {
@@ -705,19 +576,6 @@ defineExpose({
   margin-left: 20px;
 }
 
-/* .dialog-left :deep(.test-head-steps){
-       height: 80px;
-       /* margin-bottom: 10px;
-   } 
-   */
-
-/* .dialog-left  :deep(.el-step__title)  {
-   font-size: 18px !important; /* 设置标题字体大小
- } */
-
-/* .dialog-left  :deep(.el-step__icon-inner) {
-     font-size: 24px !important;
-   } */
 
 .dialog-right {
   margin-left: 20px;

frontend/src/views/home/components/realTimeDataAlign.vue

@@ -0,0 +1,292 @@
+<template>
+  <el-dialog title="实时数据详情" v-model='dialogVisible' @close="handleClose" v-bind="dialogBig">
+    <el-tabs v-model="activeTab" type="card">
+      <el-tab-pane 
+        v-for="(device, deviceName, index) in testDataStructure" 
+        :key="deviceName"
+        :name="`channel${index + 1}`">
+        <template #label>
+          <span>
+            {{ deviceName }}
+            <el-icon v-if="tabStatus[deviceName]" style="color: red; margin-left: 5px;">
+              <CircleClose />
+            </el-icon>
+            <el-icon v-else style="color: green; margin-left: 5px;">
+              <CircleCheck />
+            </el-icon>
+          </span>
+        </template>
+        <div class="table-toolbar">
+          <el-form-item label="标准设备通道号" prop="createId">
+            <el-select 
+              v-model="selectedChannels[deviceName]" 
+              placeholder="选择通道" 
+              style="width: 150px;"
+              @change="() => handleDutChannelChange(deviceName)">
+             <el-option 
+              v-for="channel in device.channelDataList" 
+              :key="channel.stdDevNum"
+              :label="`通道${channel.stdDevNum}`"
+              :value="`通道${channel.stdDevNum}`">
+            </el-option>
+            </el-select>
+            <span style="margin-left: 20px; font-size: 14px; color: var(--el-color-primary);">
+              标准设备：{{ deviceName }}-{{ selectedChannels[deviceName] }} ---> 被检设备：{{ formatDutChannelLabel(getMappedDutChannel(deviceName, selectedChannels[deviceName])) }}
+            </span>
+          </el-form-item>    
+          <el-button type="primary" @click="exportData">导出数据</el-button>
+        </div>
+        <el-table 
+          :data="tableDataMap[deviceName]" 
+          :header-cell-style="{ textAlign: 'center',backgroundColor: 'var(--el-color-primary)',color: '#fff' } "
+          :cell-style="{ textAlign: 'center' }"
+          style="width: 100%"
+          :style="{ height: '400px',maxHeight: '400px',overflow:'hidden'}">
+         
+          <el-table-column :label="`${deviceName}-${selectedChannels[deviceName] || '通道1'}`">
+            <el-table-column prop="timeStdDev" label="数据时标" width="200"/>
+            <el-table-column prop="uaStdDev" label="A相(V)"/>
+            <el-table-column prop="ubStdDev" label="B相(V)"/>
+            <el-table-column prop="ucStdDev" label="C相(V)"/>
+          </el-table-column>
+          <el-table-column :label="formatDutChannelLabel(getMappedDutChannel(deviceName, selectedChannels[deviceName]))">
+            <el-table-column prop="timeDev" label="数据时标" width="200"/>
+            <el-table-column prop="uaDev" label="A相(V)"/>
+            <el-table-column prop="ubDev" label="B相(V)"/>
+            <el-table-column prop="ucDev" label="C相(V)"/>
+          </el-table-column>
+        </el-table>
+      </el-tab-pane>
+    </el-tabs>
+  </el-dialog>
+</template>
+
+<script setup lang='tsx' name='realTimeDataAlign'>
+import { dialogBig } from "@/utils/elementBind";
+import { PropType, ref, nextTick } from "vue";
+import { ElMessage } from "element-plus";
+import { CircleCheck, CircleClose } from '@element-plus/icons-vue';
+import {exportAlignData} from "@/api/socket/socket";
+import {useDownload} from "@/hooks/useDownload";
+
+const dialogVisible = ref(false);
+const activeTab = ref('channel1');
+
+// 在 script setup 中定义接口
+interface ChannelData {
+  stdDevNum: string;
+  devInfo: string;
+  dataList: {
+    timeDev: string | null;
+    uaDev: number | null;
+    ubDev: number | null;
+    ucDev: number | null;
+    timeStdDev: string | null;
+    uaStdDev: number | null;
+    ubStdDev: number | null;
+    ucStdDev: number | null;
+  }[];
+}
+
+interface DeviceData {
+  stdDevName: string;
+  channelDataList: ChannelData[];
+}
+
+// 修改 testDataStructure 的类型声明
+const testDataStructure = ref<Record<string, DeviceData>>({});
+
+// 每个设备选中的通道
+const selectedChannels = ref<Record<string, string>>({});
+
+// 通道映射关系：标准设备通道 -> 被检设备通道
+const channelMapping = ref<Record<string, Record<string, string>>>({});
+
+// 每个设备的表格数据
+const tableDataMap = ref<Record<string, any[]>>({});
+
+// 每个tab的状态（true表示有不完整数据，false表示数据完整）
+const tabStatus = ref<Record<string, boolean>>({});
+
+// 检查设备数据是否有不完整的行（包含null的行）
+const hasIncompleteData = (deviceName: string) => {
+  const tableData = tableDataMap.value[deviceName];
+  if (!tableData || tableData.length === 0) return false;
+
+  // 检查每一行是否有缺失数据（包含null的字段）
+   return tableData.some(row => {
+   return row.uaDev === '/' || row.ubDev === '/' || row.ucDev === '/' || 
+          row.uaStdDev === '/' || row.ubStdDev === '/' || row.ucStdDev === '/';
+  });
+};
+
+// 获取映射的被检设备通道
+const getMappedDutChannel = (deviceName: string, stdChannel: string) => {
+
+  // 添加安全检查
+  if (!channelMapping.value[deviceName]) return '';
+  return channelMapping.value[deviceName][stdChannel] || '';
+};
+
+// 格式化被检设备通道标签，将设备名称和通道号用"-"连接
+const formatDutChannelLabel = (dutChannel: string) => {
+  // 如果是"被检设备X通道Y"格式，则转换为"被检设备X-通道Y"
+  if (!dutChannel) return '未映射';
+  return dutChannel.replace(/(.+)(通道\d+)/, '$1-$2');
+};
+
+// 处理标准设备通道切换
+const handleDutChannelChange = (deviceName: string) => {
+  // 更新指定设备的表格数据，但不改变tab图标状态
+  updateTableData(deviceName);
+};
+
+// 根据 testDataStructure 生成表格数据
+const generateTableData = (deviceName: string, stdChannel: string) => {
+  const deviceData = testDataStructure.value[deviceName];
+  if (!deviceData) return [];
+  
+  // 根据实际通道编号查找对应的数据
+  const channelData = deviceData.channelDataList.find(channel => 
+   `通道${channel.stdDevNum}` === stdChannel
+  );
+  
+  if (!channelData) return [];
+ 
+  // 生成表格数据
+  return channelData.dataList.map(dataItem => {
+    return {
+      timeDev: dataItem.timeDev !== null ? dataItem.timeDev : '/',
+      uaDev: dataItem.uaDev !== null ? dataItem.uaDev : '/',
+      ubDev: dataItem.ubDev !== null ? dataItem.ubDev : '/',
+      ucDev: dataItem.ucDev !== null ? dataItem.ucDev : '/',
+      timeStdDev: dataItem.timeStdDev !== null ? dataItem.timeStdDev : '/',
+      uaStdDev: dataItem.uaStdDev !== null ? dataItem.uaStdDev : '/',
+      ubStdDev: dataItem.ubStdDev !== null ? dataItem.ubStdDev : '/',
+      ucStdDev: dataItem.ucStdDev !== null ? dataItem.ucStdDev : '/'
+    };
+  });
+};
+
+// 更新指定设备的表格数据
+const updateTableData = (deviceName: string) => {
+  const selectedChannel = selectedChannels.value[deviceName];
+  if (selectedChannel) {
+    const tableData = generateTableData(deviceName, selectedChannel);
+    tableDataMap.value[deviceName] = tableData;
+   
+  }
+};
+
+// 初始化所有设备的数据和状态
+const initAllTableData = () => {
+  Object.keys(testDataStructure.value).forEach(deviceName => {
+    // 确保设备有数据
+    if (!testDataStructure.value[deviceName] || 
+        !testDataStructure.value[deviceName].channelDataList ||
+        testDataStructure.value[deviceName].channelDataList.length === 0) {
+      return;
+    }
+    
+    // 默认选择第一个可用通道
+    const firstChannel = testDataStructure.value[deviceName].channelDataList[0];
+    selectedChannels.value[deviceName] = `通道${firstChannel.stdDevNum}`;
+    
+    // 生成表格数据
+    updateTableData(deviceName);
+    
+    // 初始化tab状态（只在初始化时设置一次）
+    if (tabStatus.value[deviceName] === undefined) {
+      tabStatus.value[deviceName] = hasIncompleteData(deviceName);
+    }
+  });
+};
+
+const open = async (mapping : Record<string, Record<string, string>>,data : any) => {
+  let parsedData = data;
+
+  // 如果 data 是字符串，先解析为对象
+  if (typeof data === 'string') {
+    try {
+      parsedData = JSON.parse(data);
+    } catch (error) {
+      console.error('数据解析失败:', error);
+      ElMessage.error('数据格式错误');
+      return;
+    }
+  }
+  // 转换数据格式以匹配组件期望的格式
+  const convertedData: Record<string, DeviceData> = {};
+
+  // 假设传入的数据是一个数组，需要转换为以设备名为键的对象
+  if (Array.isArray(parsedData)) {
+
+    parsedData.forEach((deviceItem: any) => {
+      const deviceName = deviceItem.stdDevName;
+      convertedData[deviceName] = {
+        stdDevName: deviceName,
+        channelDataList: deviceItem.channelDataList?.map((channel: any) => ({
+          stdDevNum: channel.stdDevNum,
+          devInfo: channel.devInfo,
+          dataList: channel.dataList?.map((dataItem: any) => ({
+            timeDev: dataItem.timeDev,
+            uaDev: dataItem.uaDev,
+            ubDev: dataItem.ubDev,
+            ucDev: dataItem.ucDev,
+            timeStdDev: dataItem.timeStdDev,
+            uaStdDev: dataItem.uaStdDev,
+            ubStdDev: dataItem.ubStdDev,
+            ucStdDev: dataItem.ucStdDev
+          })) || []
+        })) || []
+      };
+    });
+  } else if (parsedData && typeof parsedData === 'object') {
+
+    // 如果已经是期望的格式，直接使用
+    Object.assign(convertedData, parsedData);
+  }
+
+  testDataStructure.value = convertedData;
+
+  channelMapping.value = mapping;
+  dialogVisible.value = true;
+  // 使用 nextTick 确保 DOM 更新后再初始化数据
+  await nextTick();
+  // 初始化数据和状态
+  initAllTableData();
+  
+  // 设置默认激活的 tab
+  activeTab.value = 'channel1';
+};
+
+// 导出数据
+const exportData =async () => {
+  useDownload(exportAlignData, '原始数据', null, false, '.xlsx')
+  ElMessage.success('数据导出成功');
+  // 这里可以添加实际的数据导出逻辑
+};
+
+// 关闭弹窗
+const handleClose = () => {
+  dialogVisible.value = false;
+  // 清空数据
+  testDataStructure.value = {};
+  tableDataMap.value = {};
+  selectedChannels.value = {};
+  tabStatus.value = {};
+};
+
+defineExpose({ open });
+</script>
+
+<style scoped lang="scss">
+.table-toolbar {
+  display: flex;
+  justify-content: space-between;
+}
+
+:deep(.el-dialog__body) {
+  padding: 10px 20px 20px 20px;
+}
+</style>

frontend/src/views/home/components/reportPopup.vue

@@ -1,154 +0,0 @@
-<template>
-    <el-dialog  title="报告生成" :model-value='visible' @close="handleCancel" width="832px" draggable>
-        <div class="report-dialog">
-            <div class="report-title form-two">
-
-                        <el-form-item label="检测脚本"  label-width="100px">
-                            <el-input v-model='testScriptName' :disabled="true"/>
-                        </el-form-item>              
-
-                        <el-form-item label="误差体系"  label-width="100px">
-                            <el-input v-model='errorSysName' :disabled="true"/>
-                        </el-form-item>              
-
-                        <el-form-item label="数据原则"  label-width="100px">
-                            <el-input v-model='dataRule' :disabled="true"/>
-                        </el-form-item>              
-
-                        <el-form-item label="报告模板"  label-width="100px">
-                            <el-input v-model='reportTemplate' :disabled="true"/>
-                        </el-form-item>           
-            </div>
-            <div class="report-content">
-                <div>
-                    <el-tabs type="border-card">
-                        <el-tab-pane label="报告生成进度">
-                            <div class="form-grid">
-                                <div class="tabs-title ">
-                                    <el-button type="primary" :icon="Download"  >报告下载</el-button>     
-                                    <span style="  font-size: 18px;font-weight: 600;">
-                                        已生成 <span style="color: #91cc75">2</span> 台/共 <span style="color: green">3</span> 台
-                                    </span>
-                                    
-                                    </div> 
-                                <div class="table-main">
-                                    <el-table :data="reportData" :header-cell-style="{ textAlign: 'center' } " :cell-style="{ textAlign: 'center' }" style="width: 100%" border class="custom-table">
-                                    <el-table-column type="selection" width="55" />
-                                    <el-table-column prop="id" width="70" label="序号" />
-                                    <el-table-column prop="deviceName" width="150" label="设备名称" />
-                                    <el-table-column label="生成进度">
-                                        <template #default="scope">
-                                            <el-progress :color="customColors" :percentage="scope.row.processValue" />
-                                         </template>
-                                    </el-table-column>
-                                    <el-table-column prop="action" label="操作" width="100">
-                                        <template #default="scope">
-                                            <el-button type='primary' link :icon='Download' :disabled="scope.row.processValue < 100">下载</el-button>
-                                         </template>
-                                    </el-table-column>
-                                </el-table>
-                                </div>
-                                
-                            </div>
-                        </el-tab-pane>
-                    </el-tabs>
-                </div>
-            </div>
-        </div>
-    </el-dialog>
-
-</template>
-<script setup lang='ts'>
-
-import IPAddress from '@/components/IpAddress/index.vue'
-import { dialogBig } from '@/utils/elementBind'
-import { type Device } from '@/api/device/interface/device'
-import { ElMessage, type FormItemRule } from 'element-plus'
-import { addPqDev, updatePqDev } from '@/api/device/device'
-import { computed, reactive, type Ref, ref } from 'vue'
-import { useDictStore } from '@/stores/modules/dict'
-import { CirclePlus, Delete, Download,View } from '@element-plus/icons-vue'
-
-
-
-  const reportTemplate = ref('国网检测模板V1.0');
-  const testScriptName = ref('Q/GDW 10650.4-2021 模拟式');
-  const errorSysName = ref('Q/GDW 10650.2-2021');
-  const dataRule = ref('所有值');
-  const scriptSwitch = ref(true);
-  const currentScriptDsc = ref('电压准确度检测：频率：42.5Hz Ua=46.192V 0° Ub=46.192V -120° Uc=46.192V 120° Ia=1A 0° Ib=1A -120° Ic=1A 120°');
-
-const reportData = ref([
-  { id: '1', deviceName: '240001', processValue: '100' , action:'查看' },
-  { id: '2', deviceName: '240002', processValue: '100' , action:'查看' },
-  { id: '3', deviceName: '240003', processValue: '10', action:'查看' },
-])
-const customColors = [
-  { color: "red", percentage: 0 },
-  { color: "red", percentage: 10 },
-  { color: "red", percentage: 20 },
-  { color: "red", percentage: 30 }, //红
-  { color: "red", percentage: 40 },
-  { color: "#e6a23c", percentage: 50 },
-  { color: "#e6a23c", percentage: 60 },
-  { color: "#e6a23c", percentage: 70 }, //黄
-  { color: "#e6a23c", percentage: 80 }, //1989fa
-  { color: "#e6a23c", percentage: 90 }, //1989fa
-  { color: "#5cb87a", percentage: 100 }, //绿
-];
-const handleNodeClick = (data) => {
-  console.log(data);
-};
-const MonIsShow = ref(false)
-const DevIsShow = ref(false)
-const IsPasswordShow = ref(false)
-const dictStore = useDictStore()
-// 定义弹出组件元信息
-const dialogFormRef = ref()
-const disabledDate = (time: Date) => {
-  return time.getTime() > Date.now()
-}
-
-const props = defineProps<{
-    visible: boolean;
-  }>();
-
-  const emit = defineEmits<{
-    (e: 'update:visible', value: boolean): void;
-    (e: 'submit', data: any): void;
-  }>();
-
-  const handleCancel = () => {
-    emit('update:visible', false); // 关闭对话框
-  };
-</script>
-<style scoped>
-
-.report-dialog{
-    display: flex;
-    flex-direction: column;
-}
-
-.report-title{
-    margin-left: 15px;
-
-    /* display: flex; */
-    /* flex-direction: row;
-
-    margin-top: 10px; */
-}
-
-.report-content{
-    display: flex;
-    flex-direction: column;
-}
-.tabs-title{
-    display: flex;
-    justify-content: space-between;
-    margin-bottom: 10px;
-}
-
-.el-tabs__content{
-    padding-top: 5px !important;
-}
-</style>

frontend/src/views/home/components/reportResultPopup.vue

@@ -0,0 +1,267 @@
+<template>
+    <el-dialog
+        v-model="dialogVisible"
+        title="报告生成"
+        destroy-on-close
+        width="750"
+        draggable
+        :close-on-click-modal="false"
+        @close="handleClose"
+    >
+        <el-tabs v-if="dialogVisible" v-model="activeName" @tab-click="handleTabClick">
+            <el-tab-pane
+                v-for="(result, index) in resultData"
+                :key="result.monitorId"
+                :label="`测量回路${result.monitorNum}`"
+                :name="index"
+            >
+                <el-row :gutter="20" style="margin-top: 10px">
+                    <el-col :span="8">
+                        <div
+                            style="
+                                background-color: #f9fafb;
+                                display: flex;
+                                align-items: center;
+                                justify-content: center;
+                                padding: 15px;
+                                border-radius: 5px;
+                            "
+                        >
+                            <el-text style="margin-right: 10px">总测试次数：</el-text>
+                            <el-text size="large" type="primary" tag="b">
+                                {{ result.totalNum }}
+                            </el-text>
+                        </div>
+                    </el-col>
+                    <el-col :span="8">
+                        <div
+                            style="
+                                background-color: #f9fafb;
+                                display: flex;
+                                align-items: center;
+                                justify-content: center;
+                                padding: 15px;
+                                border-radius: 5px;
+                            "
+                        >
+                            <el-text style="margin-right: 10px">符合次数：</el-text>
+                            <el-text size="large" type="success" tag="b">{{ result.qualifiedNum }}</el-text>
+                        </div>
+                    </el-col>
+                    <el-col :span="8">
+                        <div
+                            style="
+                                background-color: #f9fafb;
+                                display: flex;
+                                align-items: center;
+                                justify-content: center;
+                                padding: 15px;
+                                border-radius: 5px;
+                            "
+                        >
+                            <el-text style="margin-right: 10px">不符合次数：</el-text>
+                            <el-text size="large" type="danger" tag="b">{{ result.unQualifiedNum }}</el-text>
+                        </div>
+                    </el-col>
+                </el-row>
+                <el-descriptions :column="1" style="margin-top: 20px">
+                    <el-descriptions-item label-align="right">
+                        <template #label>
+                            <el-text type="info">测试标准：</el-text>
+                        </template>
+                        <el-text>{{ result.errorSysName }}</el-text>
+                    </el-descriptions-item>
+                    <el-descriptions-item label-align="right">
+                        <template #label>
+                            <el-text type="info">检测结论：</el-text>
+                        </template>
+                        <el-tag disable-transitions v-if="result.checkResult === 1" type="success">符合</el-tag>
+                        <el-tag disable-transitions v-else-if="result.checkResult === 2" type="danger">不符合</el-tag>
+                        <el-tag disable-transitions v-else-if="result.checkResult === 4" type="danger">无法比较</el-tag>
+                    </el-descriptions-item>
+                    <el-descriptions-item label-align="right">
+                        <template #label>
+                            <el-text type="info">结论来源：</el-text>
+                        </template>
+                        <el-text>第{{ result.whichTime }}次检测的{{ result.resultOrigin }}</el-text>
+                    </el-descriptions-item>
+                </el-descriptions>
+            </el-tab-pane>
+        </el-tabs>
+        <template #footer>
+            <el-button type="primary" size="small" @click="handleChooseClick">重新选择</el-button>
+            <el-button type="primary" @click="handleConfirmGenerate">确认生成</el-button>
+        </template>
+        <!--        选择检测数据源弹框-->
+        <el-dialog
+            v-model="dialogSourceVisible"
+            append-to-body
+            title="选择检测数据源"
+            destroy-on-close
+            width="400"
+            :close-on-click-modal="false"
+        >
+            <el-form ref="formRef" :rules="rules" :model="submitSourceData" label-width="120px" label-position="top">
+                <el-form-item label="选择次数:" prop="whichTime">
+                    <el-select v-model="submitSourceData.whichTime" placeholder="请选择次数" @change="handleTimeChange">
+                        <el-option
+                            v-for="time in whichTimeData"
+                            :key="time"
+                            :label="`第${time}次`"
+                            :value="time"
+                        ></el-option>
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="数据源和检测结论:" prop="resultType">
+                    <el-select
+                        v-model="submitSourceData.resultType"
+                        placeholder="请选择数据源和检测结论"
+                        clearable
+                        @change="handleSourceChange"
+                    >
+                        <template #label="{ label }">
+                            <div style="display: flex; align-items: center; justify-content: space-between">
+                                <el-text>{{ label }}</el-text>
+                                <el-tag disable-transitions v-if="submitSourceData.checkResult === 1" type="success">
+                                    符合
+                                </el-tag>
+                                <el-tag disable-transitions v-if="submitSourceData.checkResult === 2" type="danger">
+                                    不符合
+                                </el-tag>
+                                <el-tag disable-transitions v-if="submitSourceData.checkResult === 4" type="info">
+                                    无法比较
+                                </el-tag>
+                            </div>
+                        </template>
+                        <el-option
+                            v-for="item in sourceData"
+                            :key="item.dataSourceCode"
+                            :label="item.dataSourceName"
+                            :value="item.dataSourceCode"
+                        >
+                            <div style="display: flex; align-items: center; justify-content: space-between">
+                                <el-text>{{ item.dataSourceName }}</el-text>
+                                <el-tag v-if="item.checkResult === 1" type="success">符合</el-tag>
+                                <el-tag v-if="item.checkResult === 2" type="danger">不符合</el-tag>
+                            </div>
+                        </el-option>
+                    </el-select>
+                </el-form-item>
+            </el-form>
+            <template #footer>
+                <el-button @click="dialogSourceVisible = false">取消</el-button>
+                <el-button type="primary" @click="handleSureChoose">确认</el-button>
+            </template>
+        </el-dialog>
+    </el-dialog>
+</template>
+<script setup lang="ts" name="reportPopup">
+import { getMonitorDataSourceResult, getMonitorResult, updateMonitorResult } from '@/api/result/result'
+import { type MonitorResult } from '@/api/result/interface'
+import { generateDevReport } from '@/api/plan/plan'
+import { useCheckStore } from '@/stores/modules/check'
+import { ElMessage } from 'element-plus'
+
+const dialogVisible = ref(false)
+const dialogSourceVisible = ref(false)
+const devData = ref<any>()
+const activeName = ref<number>(0)
+const checkStore = useCheckStore()
+
+// 定义 emit 事件
+const emit = defineEmits<{
+    (e: 'reportGenerated'): void
+}>()
+const resultData = ref<MonitorResult[]>([])
+const resultSourceData = ref<any>({})
+const whichTimeData = ref<any>([])
+const sourceData = ref<any>([])
+const formRef = ref()
+const submitSourceData = reactive({
+    monitorId: '',
+    whichTime: '',
+    resultType: '',
+    checkResult: -1
+})
+
+const rules = {
+    whichTime: [{ required: true, message: '请选择次数', trigger: 'change' }],
+    resultType: [{ required: true, message: '请选择数据源和检测结论', trigger: 'change' }]
+}
+const handleClose = () => {
+    activeName.value = 0
+}
+const open = (data: any) => {
+    devData.value = data
+    getResultData()
+}
+const getResultData = async () => {
+    const res = await getMonitorResult(devData.value.id)
+    if (res.data && Array.isArray(res.data)) {
+        resultData.value = res.data
+    }
+    dialogVisible.value = true
+}
+
+const handleTabClick = (tab: any) => {
+    activeName.value = tab.name
+}
+const handleChooseClick = async () => {
+    const currentResult = resultData.value[activeName.value]
+    if (currentResult) {
+        submitSourceData.monitorId = currentResult.monitorId
+        submitSourceData.whichTime = currentResult.whichTime
+        submitSourceData.resultType = currentResult.resultType
+        submitSourceData.checkResult = currentResult.checkResult
+        const res = await getMonitorDataSourceResult(currentResult.monitorId)
+        if (res.data) {
+            resultSourceData.value = res.data
+            // 选择第几次
+            whichTimeData.value = Object.keys(resultSourceData.value)
+            sourceData.value = resultSourceData.value[currentResult.whichTime]
+        }
+    }
+    dialogSourceVisible.value = true
+}
+const handleTimeChange = (value: any) => {
+    sourceData.value = resultSourceData.value[value]
+    submitSourceData.resultType = ''
+    submitSourceData.checkResult = -1
+}
+const handleSourceChange = (value: any) => {
+    submitSourceData.checkResult = resultSourceData.value[submitSourceData.whichTime].find(
+        (item: any) => item.dataSourceCode === value
+    ).checkResult
+}
+const handleSureChoose = () => {
+    formRef.value.validate().then(async () => {
+        await updateMonitorResult(submitSourceData)
+        await getResultData()
+        dialogSourceVisible.value = false
+    })
+}
+
+// 处理确认生成报告
+const handleConfirmGenerate = async () => {
+    try {
+        await generateDevReport({
+            planId: checkStore.plan.id,
+            devIdList: [devData.value.id],
+            scriptId: checkStore.plan.scriptId,
+            planCode: checkStore.plan.code + '',
+            pageNum: 1,
+            pageSize: 999
+        })
+        ElMessage.success({ message: `报告生成成功！` })
+        dialogVisible.value = false
+        emit('reportGenerated') // 触发事件通知父组件
+    } catch (error) {
+        ElMessage.error('报告生成失败')
+        console.error('报告生成错误:', error)
+    }
+}
+defineExpose({
+    open
+})
+</script>
+<style scoped lang="scss"></style>

frontend/src/views/home/components/resultPopup.vue

@@ -43,7 +43,6 @@
   import { useDictStore } from '@/stores/modules/dict'
   import preTest from './preTest.vue'
   import timeTest from './timeTest.vue'
-  import channelsTest from './channelsTest.vue'
   import DataCheckPopup from './dataCheckPopup.vue';
 import { log } from 'console';
 

frontend/src/views/home/components/selectTestItemPopup.vue

@@ -8,7 +8,7 @@
         <el-form-item v-if="checkStore.plan.timeCheck===1" prop="timeTest" :label-width="100">
           <el-checkbox v-model="formContent.timeTest" label="守时检测"/>
         </el-form-item>
-        <el-form-item  v-if="AppSceneStore.currentScene === '1'" prop="channelsTest" :label-width="100">
+        <el-form-item  v-if="channelsTestShow" prop="channelsTest" :label-width="100">
           <el-checkbox v-model="formContent.channelsTest" label="系数校准"/>
         </el-form-item>
         <el-form-item prop="test" :label-width="100">
@@ -28,25 +28,36 @@
 
 <script setup lang='tsx' name='selectTestItemPopup'>
 import {dialogSmall} from "@/utils/elementBind";
-import {ref} from "vue";
+import {reactive, ref} from "vue";
 import {useCheckStore} from "@/stores/modules/check";
 import type {CheckData} from "@/api/check/interface";
 import {ElMessageBox} from "element-plus";
-import {useAppSceneStore} from "@/stores/modules/mode";
+import {useAppSceneStore,useModeStore} from "@/stores/modules/mode";
+
+
 const AppSceneStore = useAppSceneStore()
 const emit = defineEmits(['openTestDialog'])
 const checkStore = useCheckStore();
-
+const modeStore = useModeStore()
 const dialogFormRef = ref()
-
+const channelsTestShow = ref(false)
 
 const dialogVisible = ref(false)
 const formContent = reactive<CheckData.SelectTestItem>({preTest: true, timeTest: false, channelsTest: false, test: false})
-
 const open = async () => {
+
   resetFormContent()
   checkStore.setSelectTestItems(formContent)
   dialogVisible.value = true
+  if(modeStore.currentMode === '比对式'){
+    channelsTestShow.value = false
+  }else{
+    if(AppSceneStore.currentScene === '1'){
+      channelsTestShow.value = true
+    }else{
+      channelsTestShow.value = false
+    }
+  }
 }
 
 // 清空表单内容
@@ -55,7 +66,7 @@ const resetFormContent = () => {
   Object.assign(formContent, {preTest: !hasResult, channelsTest: false, timeTest: false, test: hasResult})
 }
 
-const handleStart = () => {
+const handleStart = async () => {
   let count = 0
   for (let key in formContent) {
     if (formContent[key]) {
@@ -89,6 +100,9 @@ const handleStart = () => {
     }
     checkStore.setCheckType(0)
     checkStore.setSelectTestItems({...formContent})
+
+  
+
     handleClose()
     
     emit('openTestDialog',checkStore.selectTestItems.test)

frontend/src/views/home/components/testPopup.vue

@@ -1,64 +1,105 @@
 <template>
-  <el-dialog :title="dialogTitle" width="1550px" :model-value="dialogVisible" :before-close="beforeClose" @close="handleClose" height="1000px" draggable>
+  <!-- 检测流程弹窗容器 -->
+  <el-dialog :title='dialogTitle' width='1550px' :model-value='dialogVisible' :before-close='beforeClose'
+             @close='handleClose' height='1000px' draggable>
 
-    <div class="steps-container">
-      <el-steps v-if="showSteps" class="test-head-steps" simple :active="stepsActiveIndex" process-status="finish" finish-status="success">
-        <el-step v-if="preTestSelected" title="预检测" :icon="stepsActive > 1 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Edit" @click="handleStepClick(1)"/>
-        <el-step v-if="timeTestSelected" title="守时检测" :icon="stepsActive > 2 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :UploadFilled"
-                 @click="handleStepClick(2)"/>
-        <el-step v-if="channelsTestSelected" title="系数校准" :icon="stepsActive > 3 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Odometer"
-                 @click="handleStepClick(3)"/>
-        <el-step v-if="testSelected" title="正式检测" :icon="stepsActive > 4 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Coin" @click="handleStepClick(4)"/>
-        <el-step title="检测完成" :icon="stepsActiveIndex > stepsTotalNum-1 ? SuccessFilled :Key"/>
+    <!-- 步骤指示器容器 -->
+    <div class='steps-container'>
+      <!-- 检测步骤进度条，根据选择的检测项动态显示步骤 -->
+      <!-- 注意：Element Plus的active属性从0开始，但业务逻辑从1开始，所以需要减1 -->
+      <el-steps v-if='showSteps' class='test-head-steps' simple :active='stepsActiveIndex - 1' process-status='finish'
+                finish-status='success'>
+        <!-- 预检测步骤 -->
+        <el-step v-if='preTestSelected' title='预检测'
+                 :icon='stepsActive > 1 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Edit'
+                 @click='handleStepClick(1)' />
+        <!-- 守时检测步骤 -->
+        <el-step v-if='timeTestSelected' title='守时检测'
+                 :icon='stepsActive > 2 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :UploadFilled'
+                 @click='handleStepClick(2)' />
+        <!-- 系数校准步骤 -->
+        <el-step v-if='channelsTestSelected' title='系数校准'
+                 :icon='stepsActive > 3 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Odometer'
+                 @click='handleStepClick(3)' />
+        <!-- 正式检测步骤 -->
+        <el-step v-if='testSelected' title='正式检测'
+                 :icon='stepsActive > 4 || stepsActiveIndex > stepsTotalNum-1? SuccessFilled :Coin'
+                 @click='handleStepClick(4)' />
+        <!-- 检测完成步骤 -->
+        <el-step title='检测完成' :icon='stepsActiveIndex > stepsTotalNum-1 ? SuccessFilled :Key' />
       </el-steps>
     </div>
 
-    <preTest v-if="showComponent&&preTestSelected" v-show="preTestSelected && stepsActiveView==1" ref="preTestRef" v-model:testStatus="preTestStatus"
-             :webMsgSend="webMsgSend"/>
-    <timeTest v-if="showComponent&&timeTestSelected" v-show="timeTestSelected && stepsActiveView==2" v-model:testStatus="timeTestStatus"/>
-    <!--     <channelsTest v-if="stepsActiveIndex === 3" v-model:testStatus="channelsTestStatus"></channelsTest>-->
-    <factorTest v-if="showComponent&&channelsTestSelected" v-show="channelsTestSelected && stepsActiveView==3" v-model:testStatus="channelsTestStatus"
-                :webMsgSend="webMsgSend"/>
-    <test v-if="showComponent&&testSelected" ref="testRef" v-show="testSelected && stepsActiveView==4" v-model:testStatus="TestStatus" :webMsgSend="webMsgSend"
-          @update:webMsgSend="webMsgSend=$event" @sendPause="sendPause" @sendResume="sendResume" @sendReCheck="sendReCheck" @closeWebSocket="closeWebSocket"
-          :stepsActive="stepsActive"/>
+    <!-- 检测组件容器 - 根据当前步骤显示对应的检测组件 -->
+    <!-- 预检测组件 -->
+    <preTest v-if='showComponent&&preTestSelected' v-show='preTestSelected && stepsActiveView==1' ref='preTestRef'
+             v-model:testStatus='preTestStatus'
+             :webMsgSend='webMsgSend' />
+    <!-- 守时检测组件 -->
+    <timeTest v-if='showComponent&&timeTestSelected' v-show='timeTestSelected && stepsActiveView==2'
+              v-model:testStatus='timeTestStatus' />
+    <!-- 系数校准检测组件 -->
+    <factorTest v-if='showComponent&&channelsTestSelected' v-show='channelsTestSelected && stepsActiveView==3'
+                v-model:testStatus='channelsTestStatus'
+                :webMsgSend='webMsgSend' />
+    <!-- 正式检测组件 -->
+    <test v-if='showComponent&&testSelected' ref='testRef' v-show='testSelected && stepsActiveView==4'
+          v-model:testStatus='TestStatus' :webMsgSend='webMsgSend'
+          @update:webMsgSend='webMsgSend=$event' @sendPause='sendPause' @sendResume='sendResume'
+          @closeWebSocket='closeWebSocket'
+          :stepsActive='stepsActive' />
 
+    <!-- 弹窗底部操作按钮区域 -->
     <template #footer>
       <div>
-        <!--        <el-button type="primary" :icon="DArrowRight" v-if="stepsActiveIndex < stepsTotalNum && ActiveStatue != 'success'" @click="nextStep">跳过</el-button>-->
-        <el-button type="primary" :icon="VideoPlay" v-if="ActiveStatue === 'waiting'" @click="handleSubmitFast">开始检测</el-button>
-        <el-button type="primary" v-if="TestStatus === 'test_init'" disabled>
-          <el-icon class="loading-box" style="color: #fff;margin-right: 8px;">
-            <component :is="Refresh"/>
+
+        <!-- 开始检测按钮 - 当前状态为等待时显示 -->
+        <el-button type='primary' :icon='VideoPlay' v-if="ActiveStatue === 'waiting'" @click='handleSubmitFast'>
+          开始检测
+        </el-button>
+
+        <!-- 初始化中按钮 - 禁用状态，显示加载动画 -->
+        <el-button type='primary' v-if="TestStatus === 'test_init'" disabled>
+          <el-icon class='loading-box' style='color: #fff;margin-right: 8px;'>
+            <component :is='Refresh' />
           </el-icon>
           初始化中
         </el-button>
+
+        <!-- 停止检测按钮 - 检测进行中时显示 -->
         <el-button
-            type="primary"
-            v-if="TestStatus=='process'"
-            :icon="VideoPause"
-            @click="handlePause()">停止检测
+          type='primary'
+          v-if="TestStatus=='process'"
+          :icon='VideoPause'
+          @click='handlePause()'>停止检测
         </el-button>
-        <el-button type="warning" v-if="TestStatus === 'paused_ing'" disabled>
-          <el-icon class="loading-box" style="color: #fff;margin-right: 8px;">
-            <component :is="Refresh"/>
+
+        <!-- 暂停中按钮 - 禁用状态，显示加载动画 -->
+        <el-button type='warning' v-if="TestStatus === 'paused_ing'" disabled>
+          <el-icon class='loading-box' style='color: #fff;margin-right: 8px;'>
+            <component :is='Refresh' />
           </el-icon>
           暂停中
         </el-button>
+
+        <!-- 继续检测按钮 - 检测已暂停时显示 -->
         <el-button
-            type="warning"
-            v-if="(TestStatus =='paused')"
-            :icon="VideoPlay"
-            @click="sendResume"
+          type='warning'
+          v-if="(TestStatus =='paused')"
+          :icon='VideoPlay'
+          @click='sendResume'
         >继续检测
         </el-button>
 
-        <el-button :type="ActiveStatue==='success'?'primary':'danger'" :icon="Right"
-                   v-if="nextStepText !== '下一步' && (ActiveStatue === 'success'||ActiveStatue==='error'||ActiveStatue==='test_init_fail'||ActiveStatue==='connect_timeout'||ActiveStatue==='pause_timeout')"
-                   @click="nextStep">
+        <!-- 下一步/完成/错误状态按钮 -->
+        <el-button :type="ActiveStatue==='success'?'primary':'danger'" :icon='Right'
+                   v-if="nextStepText !== '下一步' && (ActiveStatue === 'success'||ActiveStatue==='error'||ActiveStatue==='connect_timeout'||ActiveStatue==='pause_timeout')"
+                   @click='nextStep'>
           {{ nextStepText }}
         </el-button>
-        <el-button type="primary" @click="handleQuit" v-else>
+
+        <!-- 退出检测按钮 - 默认显示 -->
+        <el-button type='primary' @click='handleQuit' v-else>
           退出检测
         </el-button>
       </div>
@@ -68,67 +109,96 @@
 
 </template>
 
-<script lang="tsx" setup name="testPopup">
-import {reactive, ref, watch} from 'vue';
-import {ElMessage, ElMessageBox} from 'element-plus'
-import {Coin, Edit, Key, Odometer, Refresh, Right, SuccessFilled, UploadFilled, VideoPause, VideoPlay} from '@element-plus/icons-vue'
+<script lang='tsx' setup name='testPopup'>
+// ====================== 导入依赖 ======================
+import { reactive, ref, watch, onBeforeUnmount } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import {
+  Coin,
+  Edit,
+  Key,
+  Odometer,
+  Refresh,
+  Right,
+  SuccessFilled,
+  UploadFilled,
+  VideoPause,
+  VideoPlay,
+} from '@element-plus/icons-vue'
 import preTest from './preTest.vue'
 import timeTest from './timeTest.vue'
 import factorTest from './factorTest.vue'
 import test from './test.vue'
-import socketClient from '@/utils/webSocketClient';
-import {useCheckStore} from "@/stores/modules/check";
-import {pauseTest, resumeTest, startPreTest} from '@/api/socket/socket'
-import {useUserStore} from "@/stores/modules/user";
+import socketClient from '@/utils/webSocketClient'
+import { useCheckStore } from '@/stores/modules/check'
+import { pauseTest, resumeTest, startPreTest } from '@/api/socket/socket'
+import { useUserStore } from '@/stores/modules/user'
+import { JwtUtil } from '@/utils/jwtUtil'
 
+// ====================== 状态管理 ======================
 const userStore = useUserStore()
-const checkStore = useCheckStore();
-const nextStepText = ref('下一步');
-const dialogVisible = ref(false)
+const checkStore = useCheckStore()
 
-const showSteps = ref(false)
-const stepsTotalNum = ref(-1);//步骤总数
-const stepsActiveIndex = ref(1); //当前正在执行的步骤索引
-const stepsActiveView = ref(-1); //当前正在执行的步骤在（预处理、守时校验、系数校准、正式检测）中的排序，仅用于页面显示
-const stepsActive = ref(-1); //当前正在执行的步骤在（预处理、守时校验、系数校准、正式检测）中的排序，实际记录步骤的状态，用于切换步骤
-const ActiveStatue = ref('waiting');//当前步骤状态
-const preTestStatus = ref('waiting');//预检测执行状态
-const timeTestStatus = ref('waiting');//守时校验执行状态
-const channelsTestStatus = ref('waiting');//通道系数校准执行状态
-const TestStatus = ref('waiting');//正式检测执行状态
-const webMsgSend = ref();//webSocket推送的数据
+// ====================== 基础状态变量 ======================
+const nextStepText = ref('下一步') // 下一步按钮文本
+const dialogVisible = ref(false) // 弹窗显示状态
+const dialogTitle = ref('') // 弹窗标题
+const showComponent = ref(true) // 是否显示检测组件
+const preTestRef = ref<{ initializeParameters: () => void } | null>(null) // 预检测组件引用
+const testRef = ref<{ handlePause: () => void } | null>(null) // 正式检测组件引用
 
+// ====================== 步骤控制相关变量 ======================
+const showSteps = ref(false) // 是否显示步骤条
+const stepsTotalNum = ref(-1) // 步骤总数（选中的检测项数量 + 1个完成步骤）
+const stepsActiveIndex = ref(1) // 当前正在执行的步骤索引（用于UI显示高亮）
+const stepsActiveView = ref(-1) // 当前显示的检测组件步骤序号（控制v-show显示哪个组件）
+const stepsActive = ref(-1) // 当前实际执行的业务步骤序号（控制业务逻辑分支）
 
-const dialogTitle = ref('')
-const showComponent = ref(true)
-const preTestRef = ref(null)
-const testRef = ref(null)
+// ====================== 状态管理变量 ======================
+const ActiveStatue = ref('waiting') // 当前步骤的整体状态（waiting/start/process/success/error等）
+const preTestStatus = ref('waiting') // 预检测执行状态
+const timeTestStatus = ref('waiting') // 守时校验执行状态  
+const channelsTestStatus = ref('waiting') // 通道系数校准执行状态
+const TestStatus = ref('waiting') // 正式检测执行状态
+const webMsgSend = ref() // webSocket推送的数据，用于组件间通信
 
-const dataSocket = reactive({
-  socketServe: socketClient.Instance,
-});
+// ====================== WebSocket 相关 ======================
+const dataSocket = reactive<{
+  socketServe: typeof socketClient.Instance | null
+}>({
+  socketServe: socketClient.Instance, // WebSocket客户端实例
+})
 
-// 勾选的检测内容
-const preTestSelected = ref(false)
-const timeTestSelected = ref(false)
-const channelsTestSelected = ref(false)
-const testSelected = ref(false)
+// ====================== 检测项选择状态 ======================
+// 根据用户勾选的检测内容动态显示对应的检测步骤和组件
+const preTestSelected = ref(false) // 是否选择预检测
+const timeTestSelected = ref(false) // 是否选择守时检测
+const channelsTestSelected = ref(false) // 是否选择系数校准
+const testSelected = ref(false) // 是否选择正式检测
 
+// ====================== 初始化操作 ======================
+/**
+ * 初始化操作 - 重置所有状态并根据用户选择的检测项设置初始步骤
+ */
 const initOperate = () => {
+  // 重置所有状态为等待状态
   ActiveStatue.value = 'waiting'
   preTestStatus.value = 'waiting'
   timeTestStatus.value = 'waiting'
   channelsTestStatus.value = 'waiting'
   TestStatus.value = 'waiting'
 
+  // 重置步骤和组件显示状态
   stepsActiveIndex.value = 1
   showComponent.value = true
-  // 初始化勾选的检测内容
+
+  // 从store中获取用户勾选的检测内容
   preTestSelected.value = checkStore.selectTestItems.preTest
   timeTestSelected.value = checkStore.selectTestItems.timeTest
   channelsTestSelected.value = checkStore.selectTestItems.channelsTest
   testSelected.value = checkStore.selectTestItems.test
 
+  // 计算总步骤数（选中的检测项 + 1个完成步骤）
   let count = 0
   for (let key in checkStore.selectTestItems) {
     if (checkStore.selectTestItems[key]) {
@@ -137,79 +207,106 @@ const initOperate = () => {
   }
   stepsTotalNum.value = count + 1
 
+  // 根据选中的检测项，设置初始显示的步骤（按优先级：预检测 > 守时检测 > 系数校准 > 正式检测）
   if (preTestSelected.value) {
-    stepsActiveView.value = 1
-    stepsActive.value = 1
+    stepsActiveView.value = 1 // 显示预检测组件
+    stepsActive.value = 1 // 业务逻辑设为预检测
     return
   }
   if (timeTestSelected.value) {
-    stepsActiveView.value = 2
-    stepsActive.value = 2
+    stepsActiveView.value = 2 // 显示守时检测组件
+    stepsActive.value = 2 // 业务逻辑设为守时检测
     return
   }
   if (channelsTestSelected.value) {
-    stepsActiveView.value = 3
-    stepsActive.value = 3
+    stepsActiveView.value = 3 // 显示系数校准组件
+    stepsActive.value = 3 // 业务逻辑设为系数校准
     return
   }
   if (testSelected.value) {
-    stepsActiveView.value = 4
-    stepsActive.value = 4
+    stepsActiveView.value = 4 // 显示正式检测组件
+    stepsActive.value = 4 // 业务逻辑设为正式检测
     return
   }
 }
 
+// ====================== 弹窗开启方法 ======================
+/**
+ * 打开检测弹窗
+ * @param title 弹窗标题
+ */
 const open = (title: string) => {
-  showSteps.value = true
-  initOperate()
-  dialogTitle.value = title;
-  dialogVisible.value = true;
+  showSteps.value = true // 显示步骤条
+  initOperate() // 初始化所有状态和步骤
+  dialogTitle.value = title // 设置弹窗标题
+  dialogVisible.value = true // 显示弹窗
 
+  // 如果预检测组件存在，初始化其参数
   if (preTestRef.value) {
-    preTestRef.value.initializeParameters();
+    preTestRef.value?.initializeParameters()
   }
 
-  //开始创建webSocket客户端
-  socketClient.Instance.connect();
-  dataSocket.socketServe = socketClient.Instance;
-  dataSocket.socketServe.registerCallBack('aaa', (res) => {
-    // 处理来自服务器的消息
-    // console.log('Received message:', res);
-    // 根据需要在这里添加更多的处理逻辑
-    if (res.code === 20000) {
-      //ElMessage.error(message.message)
-      // loading.close()
-    } else {
-      webMsgSend.value = res
+  // 改进：无论什么状态，都先清理再重新建立连接
+  try {
+    // 先强制清理现有连接
+    if (dataSocket.socketServe) {
+      if (dataSocket.socketServe.connected) {
+        dataSocket.socketServe.closeWs()
+      }
+      // 清理回调
+      dataSocket.socketServe.unRegisterCallBack?.('aaa')
     }
-  });
+    
+    // 重新建立连接
+    socketClient.Instance.connect()
+    dataSocket.socketServe = socketClient.Instance
+    
+    // 注册新的回调
+    dataSocket.socketServe.registerCallBack('aaa', (res) => {
+      // 将接收到的数据传递给子组件
+      webMsgSend.value = res
+    })
+  } catch (error) {
+    console.error('WebSocket连接处理失败:', error)
+    ElMessage.error('连接建立失败，请重试')
+  }
 }
 
+// ====================== 开始检测处理 ======================
+/**
+ * 快速开始检测 - 根据当前步骤执行对应的检测逻辑
+ */
 const handleSubmitFast = () => {
+  // 获取设备ID列表和计划ID
   let deviceIds = checkStore.devices.map((item) => item.deviceId)
   let planId = checkStore.plan.id
 
+  // 检查WebSocket连接状态
   if (!dataSocket.socketServe.connected) {
     ElMessage.error('webSocket连接中断！')
     return
   }
-  console.log("handleSubmit", stepsActive.value, TestStatus.value)
+
+  console.log('handleSubmit', stepsActive.value, TestStatus.value)
+
+  // 根据当前激活的步骤执行对应的检测逻辑
   switch (stepsActive.value) {
-    case 1:
+    case 1: // 预检测步骤
       if (preTestStatus.value == 'waiting') {
         if (checkStore.selectTestItems.preTest) {
+          // 启动预检测
           startPreTest({
-            userPageId: "cdf",
+            userPageId: JwtUtil.getLoginName(),
             devIds: deviceIds,
             planId: planId,
-            operateType: checkStore.reCheckType == 1 ? '1' : '2',
+            reCheckType: checkStore.reCheckType == 1 ? '1' : '2', // 操作类型：1为预检测，2为正式检测
             userId: userStore.userInfo.id,
             temperature: checkStore.temperature,
             humidity: checkStore.humidity,
-            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test]
+            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test],
           }).then(res => {
-            if (res.code === 'A001014') {
-              ElMessageBox.alert('装置配置异常', '检测失败', {
+            if (res.code !== 'A0000') {
+              ElMessageBox.alert('预检测失败', '检测失败', {
                 confirmButtonText: '确定',
                 type: 'error',
               })
@@ -219,291 +316,340 @@ const handleSubmitFast = () => {
           preTestStatus.value = 'start'
         }
       }
-      break;
-    case 2:
+      break
+    case 2: // 守时检测步骤
       timeTestStatus.value = 'start'
-      break;
-    case 3:
+      break
+    case 3: // 系数校准步骤
       if (channelsTestStatus.value == 'waiting') {
+        // 如果没有预检测且有系数校准，需要先进行初始化
         if (!checkStore.selectTestItems.preTest && checkStore.selectTestItems.channelsTest) {
           startPreTest({
-            userPageId: "cdf",
+            userPageId: JwtUtil.getLoginName(),
             devIds: deviceIds,
             planId: planId,
-            operateType: checkStore.reCheckType == 1 ? '1' : '2',
+            reCheckType: checkStore.reCheckType == 1 ? '1' : '2',
             userId: userStore.userInfo.id,
             temperature: checkStore.temperature,
             humidity: checkStore.humidity,
-            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test]
+            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test],
           }).then(res => {
-            if (res.code === 'A001014') {
-              ElMessageBox.alert('装置配置异常', '初始化失败', {
+            if (res.code !== 'A0000') {
+              ElMessageBox.alert('系数校准失败', '检测失败', {
                 confirmButtonText: '确定',
                 type: 'error',
               })
-              channelsTestStatus.value = 'test_init_fail'
+              channelsTestStatus.value = 'error'
             }
           })
-          // 调用系数校准组件的handleSubmit方法
         }
         channelsTestStatus.value = 'start'
       }
-      break;
-    case 4:
-      if (TestStatus.value == "waiting") {
+      break
+    case 4: // 正式检测步骤
+      if (TestStatus.value == 'waiting') {
+        // 如果没有预检测和系数校准，直接进行正式检测需要先初始化
         if (!checkStore.selectTestItems.preTest && !checkStore.selectTestItems.channelsTest && checkStore.selectTestItems.test) {
           startPreTest({
-            userPageId: "cdf",
+            userPageId: JwtUtil.getLoginName(),
             devIds: deviceIds,
             planId: planId,
-            operateType: checkStore.reCheckType == 1 ? '1' : '2',
+            reCheckType: checkStore.reCheckType == 1 ? '1' : '2',
             userId: userStore.userInfo.id,
             temperature: checkStore.temperature,
             humidity: checkStore.humidity,
-            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test]
+            testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test],
           }).then(res => {
-            if (res.code === 'A001014') {
-              ElMessageBox.alert('装置配置异常', '初始化失败', {
+            if (res.code !== 'A0000') {
+              ElMessageBox.alert('正式检测失败', '检测失败', {
                 confirmButtonText: '确定',
                 type: 'error',
               })
-              TestStatus.value = 'test_init_fail'
+              TestStatus.value = 'error'
             }
           })
         }
         TestStatus.value = 'start'
       } else if (TestStatus.value == 'paused') {
-        // 发送继续指令
+        // 如果是暂停状态，发送继续指令
         sendResume()
       }
-      // else if (TestStatus.value == 'recheck') {
-      //   // 发送重新检测指令
-      //   sendReCheck()
-      // }
-      // else if (TestStatus.value == 'success') {
-      //   handleClose()
-      // }
-      break;
+      break
     default:
-      break;
+      break
   }
 }
 
 
+// ====================== 事件定义 ======================
 const emit = defineEmits<{
-  (e: 'quitClicked'): void;
-}>();
+  (e: 'quitClicked'): void; // 退出检测事件
+}>()
 
-watch(preTestStatus, function (newValue, oldValue) {
-  console.log(newValue, oldValue);
-
-  ActiveStatue.value = newValue
-})
-watch(timeTestStatus, function (newValue, oldValue) {
-  console.log(newValue, oldValue);
-
-  ActiveStatue.value = newValue
-})
-watch(channelsTestStatus, function (newValue, oldValue) {
-  console.log(newValue, oldValue);
-
-  ActiveStatue.value = newValue
-})
-watch(TestStatus, function (newValue, oldValue) {
-  console.log(newValue, oldValue);
-
-  ActiveStatue.value = newValue
+// ====================== 状态监听器 ======================
+// 监听各个检测步骤的状态变化，并同步到总体状态
+watch(preTestStatus, function(newValue, oldValue) {
+  console.log('预检测状态变化：', newValue, oldValue)
+  ActiveStatue.value = newValue // 同步到总体状态
 })
 
-watch(ActiveStatue, function (newValue, oldValue) {
+watch(timeTestStatus, function(newValue, oldValue) {
+  console.log('守时检测状态变化：', newValue, oldValue)
+  ActiveStatue.value = newValue // 同步到总体状态
+})
+
+watch(channelsTestStatus, function(newValue, oldValue) {
+  console.log('系数校准状态变化：', newValue, oldValue)
+  ActiveStatue.value = newValue // 同步到总体状态
+})
+
+watch(TestStatus, function(newValue, oldValue) {
+  console.log('正式检测状态变化：', newValue, oldValue)
+  ActiveStatue.value = newValue // 同步到总体状态
+})
+
+// 监听总体状态变化，处理步骤切换和错误状态
+watch(ActiveStatue, function(newValue, oldValue) {
+  console.log('总体状态变化：', newValue, oldValue)
+
+  // 处理错误状态
   if (newValue === 'error') {
-    stepsActiveIndex.value = stepsTotalNum.value + 1
+    stepsActiveIndex.value = stepsTotalNum.value + 1 // 跳到最后一步
     nextStepText.value = '检测失败'
   }
+
+  // 处理成功完成状态（已到达最后一个检测步骤）
   if (newValue === 'success' && stepsActiveIndex.value === stepsTotalNum.value - 1) {
-    stepsActiveIndex.value += 2
+    stepsActiveIndex.value += 2 // 跳到完成状态
+    console.log('success')
     nextStepText.value = '检测完成'
   }
-  if (newValue === 'test_init_fail') {
-    stepsActiveIndex.value += 2
-    nextStepText.value = '初始化失败'
-  }
+
+  // 处理连接超时状态
   if (newValue === 'connect_timeout') {
-    stepsActiveIndex.value += 2
+    stepsActiveIndex.value += 2 // 跳过当前步骤
+    console.log('connect_timeout')
     nextStepText.value = '连接超时'
   }
+
+  // 处理暂停超时状态
   if (newValue === 'pause_timeout') {
-    stepsActiveIndex.value += 2
-    // nextStepText.value = '结束测试'
+    stepsActiveIndex.value += 2 // 跳过当前步骤
+    console.log('pause_timeout')
     nextStepText.value = '暂停超时'
   }
-  if (newValue === 'success' && stepsActiveIndex.value < stepsTotalNum.value - 1) {
-    nextStep() // 实现自动点击，进入下一个测试内容
-    //handleSubmit()
-    handleSubmitFast()
-  }
 
+  // 处理成功状态的自动步骤切换（还有后续步骤时）
+  if (newValue === 'success' && stepsActiveIndex.value < stepsTotalNum.value - 1) {
+    nextStep() // 自动进入下一个测试步骤
+    handleSubmitFast() // 自动开始下一步检测
+  }
 })
 
+// ====================== 退出和暂停恢复处理 ======================
+/**
+ * 处理退出检测
+ */
 const handleQuit = () => {
   console.log('handleQuit', ActiveStatue.value)
-  if (ActiveStatue.value !== 'success' && ActiveStatue.value !== 'waiting' && ActiveStatue.value !== 'paused' && ActiveStatue.value !== 'test_init_fail' && ActiveStatue.value !== 'connect_timeout' && ActiveStatue.value !== 'pause_timeout') {
-    beforeClose(() => {
-    })
+  
+  // 可以直接关闭的安全状态：未检测、检测完成、检测失败或异常情况
+  const safeExitStates = [
+    'waiting',           // 未开始检测
+    'success',           // 检测完成
+    'error',             // 检测失败
+    'connect_timeout',   // 连接超时
+    'pause_timeout'      // 暂停超时
+  ]
+  
+  // 需要确认退出的状态：所有进行中、暂停中等状态
+  const needConfirmStates = [
+    'start',             // 开始检测
+    'process',           // 检测进行中
+    'test_init',         // 初始化中
+    'paused',            // 已暂停（用户可能想要继续）
+    'paused_ing'         // 暂停中
+  ]
+  
+  if (safeExitStates.includes(ActiveStatue.value)) {
+    handleClose() // 安全状态直接关闭
   } else {
-    handleClose()
+    beforeClose() // 需要确认的状态
   }
 }
 
-
+/**
+ * 处理暂停检测
+ */
 const handlePause = () => {
-  sendPause()
-  testRef.value?.handlePause()
+  sendPause() // 发送暂停指令
+  testRef.value?.handlePause() // 调用正式检测组件的暂停方法
 }
+
+/**
+ * 发送暂停指令
+ */
 const sendPause = () => {
   console.log('发起暂停请求')
 
-  TestStatus.value = 'paused_ing'
-  pauseTest()
-  // setTimeout(() => {
-  //   Object.assign(webMsgSend.value, {
-  //     requestId: 'preStopTest',
-  //     operateCode: 'stop'
-  //   })
-  // }, 5000)
+  TestStatus.value = 'paused_ing' // 设置为暂停中状态
+  pauseTest() // 调用暂停API
 }
+
+/**
+ * 发送继续检测指令
+ */
 const sendResume = () => {
   console.log('发起继续检测请求')
-
+  // 调用继续检测API
   resumeTest({
-    userPageId: "cdf",
+    userPageId: JwtUtil.getLoginName(),
     devIds: checkStore.devices.map((item) => item.deviceId),
     planId: checkStore.plan.id,
-    operateType: '2', //  0:'系数校验'，'1'为预检测、‘2‘为正式检测、'8'为不合格项复检
-    userId: userStore.userInfo.id,
-    temperature: checkStore.temperature,
-    humidity: checkStore.humidity
-  })
-  Object.assign(webMsgSend.value, {
-    requestId: 'Resume_Success'
-  })
-}
-
-const sendReCheck = () => {
-  console.log('发送重新检测指令')
-  startPreTest({
-    userPageId: "cdf",
-    devIds: checkStore.devices.map((item) => item.deviceId),
-    planId: checkStore.plan.id,
-    operateType: '2', // 0:'系数校验'，'1'为预检测、‘2‘为正式检测、'8'为不合格项复检
+    reCheckType: '2', // 操作类型：0-系数校验，1-预检测，2-正式检测，8-不合格项复检
     userId: userStore.userInfo.id,
     temperature: checkStore.temperature,
     humidity: checkStore.humidity,
-    testItemList: [checkStore.selectTestItems.preTest, checkStore.selectTestItems.channelsTest, checkStore.selectTestItems.test]
-  }).then(res => {
-    console.log(res)
-    if (res.code === 'A001014') {
-      ElMessageBox.alert('装置配置异常', '初始化失败', {
-        confirmButtonText: '确定',
-        type: 'error',
-      })
-      TestStatus.value = 'test_init_fail'
-    }
   })
-  TestStatus.value = 'start'
+
+  // 发送继续成功消息给子组件
+  Object.assign(webMsgSend.value, {
+    requestId: 'Resume_Success',
+  })
 }
 
+/**
+ * 关闭WebSocket连接
+ */
 const closeWebSocket = () => {
-  dataSocket.socketServe.closeWs()
+  try {
+    if (dataSocket.socketServe) {
+      // 先清理回调
+      dataSocket.socketServe.unRegisterCallBack?.('aaa')
+      
+      // 再关闭连接
+      if (dataSocket.socketServe.connected) {
+        dataSocket.socketServe.closeWs()
+      }
+      
+      // 清空引用
+      dataSocket.socketServe = null
+    }
+  } catch (error) {
+    console.error('WebSocket关闭失败:', error)
+    // 强制清空引用，确保下次能正常重新连接
+    dataSocket.socketServe = null
+  }
 }
 
+// ====================== 步骤切换处理 ======================
+/**
+ * 进入下一步检测 - 复杂的步骤切换逻辑
+ */
 const nextStep = () => {
-  if (stepsActiveIndex.value == stepsTotalNum.value + 1 || ActiveStatue.value === 'error' || ActiveStatue.value === 'test_init_fail' || ActiveStatue.value === 'connect_timeout' || ActiveStatue.value === 'pause_timeout') {
+  // 如果已到最后或遇到错误状态，直接关闭弹窗
+  if (stepsActiveIndex.value == stepsTotalNum.value + 1 || ActiveStatue.value === 'error' || ActiveStatue.value === 'connect_timeout' || ActiveStatue.value === 'pause_timeout') {
     handleClose()
     return
   }
+
+  // 如果不是错误状态，进行步骤切换
   if (ActiveStatue.value != 'error') {
-    ActiveStatue.value = 'waiting'
+    ActiveStatue.value = 'waiting' // 重置为等待状态
     let tempStep = stepsActiveIndex.value
     let idx = 1
-    stepsActiveIndex.value++
+    stepsActiveIndex.value++ // 步骤索引递增
+
+    // 遍历检测项，找到下一个需要执行的步骤
     for (let selectTestItemsKey in checkStore.selectTestItems) {
-      if (tempStep == 0 && checkStore.selectTestItems[selectTestItemsKey]) {
-        stepsActiveView.value = idx
-        stepsActive.value = idx
+      if (tempStep == 0 && checkStore.selectTestItems[selectTestItemsKey as keyof typeof checkStore.selectTestItems]) {
+        // 找到下一个要执行的检测项
+        stepsActiveView.value = idx // 设置显示的组件
+        stepsActive.value = idx // 设置业务逻辑步骤
         return
       }
-      if (checkStore.selectTestItems[selectTestItemsKey] && tempStep != 0) {
-        tempStep--
+      if (checkStore.selectTestItems[selectTestItemsKey as keyof typeof checkStore.selectTestItems] && tempStep != 0) {
+        tempStep-- // 跳过已选择的检测项
       }
       idx++
     }
   }
-
-  // if (stepsActiveIndex.value < stepsTotalNum.value && ActiveStatue.value != 'error') {
-  //   stepsActiveIndex.value++
-  //   if (!checkStore.selectTestItems.timeTest) { // 不具备守时检测
-  //     stepsActiveIndex.value++
-  //   }
-  //
-  //   ActiveStatue.value = 'waiting'
-  // } else if (stepsActiveIndex.value === stepsTotalNum.value || ActiveStatue.value === 'error') {
-  //   //emit('update:visible', false); // 关闭对话框
-  //   clearData()
-  //   dialogVisible.value = false;
-  // }
 }
 
+/**
+ * 处理步骤点击 - 允许点击回到之前已完成的步骤
+ * @param step 点击的步骤序号
+ */
 const handleStepClick = (step: number) => {
   if (step > stepsActive.value) {
-    return
+    return // 不能点击未完成的步骤
   } else {
-    stepsActiveView.value = step
+    stepsActiveView.value = step // 切换到点击的步骤显示
   }
 }
 
+// ====================== 数据清理和关闭处理 ======================
+/**
+ * 清理所有数据状态
+ */
 function clearData() {
   stepsTotalNum.value = -1
   stepsActiveIndex.value = 1
   stepsActiveView.value = -1
-  preTestStatus.value = "waiting"
-  timeTestStatus.value = "waiting"
-  channelsTestStatus.value = "waiting"
-  TestStatus.value = "waiting"
-  ActiveStatue.value = "waiting"
-  nextStepText.value = "下一步"
+  preTestStatus.value = 'waiting'
+  timeTestStatus.value = 'waiting'
+  channelsTestStatus.value = 'waiting'
+  TestStatus.value = 'waiting'
+  ActiveStatue.value = 'waiting'
+  nextStepText.value = '下一步'
 }
 
-const beforeClose = (done: () => void) => {
+/**
+ * 关闭前确认处理
+ */
+const beforeClose = () => {
+  // 如果检测未完成且不是错误状态，需要用户确认
   if (stepsActiveIndex.value < stepsTotalNum.value && ActiveStatue.value != 'error') {
     ElMessageBox.confirm('检测未完成，是否退出当前检测流程?', '提示', {
-          confirmButtonText: '确定',
-          cancelButtonText: '取消',
-          type: 'warning',
-        }
+        confirmButtonText: '确定',
+        cancelButtonText: '取消',
+        type: 'warning',
+      },
     ).then(() => {
-      handleClose()
+      handleClose() // 用户确认后关闭
     })
   } else {
-    handleClose()
+    handleClose() // 直接关闭
   }
 }
 
+/**
+ * 关闭弹窗并清理资源
+ */
 const handleClose = () => {
-  showSteps.value = false
-  dataSocket.socketServe.closeWs()
-  dialogVisible.value = false;
-  clearData()
-  showComponent.value = false;
+  showSteps.value = false // 隐藏步骤条
+  closeWebSocket() // 统一通过closeWebSocket函数关闭连接，避免重复关闭
+  dialogVisible.value = false // 隐藏弹窗
+  clearData() // 清理所有状态数据
+  showComponent.value = false // 隐藏检测组件
 
-  emit('quitClicked'); // 触发事件
+  emit('quitClicked') // 触发退出事件通知父组件
 }
 
-// 对外映射
-defineExpose({open})
+// ====================== 生命周期处理 ======================
+/**
+ * 组件卸载前的清理工作
+ * 确保路由切换或组件销毁时正确关闭WebSocket连接
+ */
+onBeforeUnmount(() => {
+  closeWebSocket() // 组件销毁前关闭WebSocket连接
+})
+
+// ====================== 对外暴露的方法 ======================
+defineExpose({ open }) // 只暴露open方法供父组件调用
 </script>
 
-<style scoped lang="scss">
+<style scoped lang='scss'>
 
 .test-head-steps {
   ::v-deep .el-step {
@@ -560,52 +706,5 @@ defineExpose({open})
   }
 }
 
-// :deep(.test-head-steps){
-//     height: 100px;
-//     margin-bottom: 20px;
-// } 
-
-// .el-step__icon.is-text {
-//   border-radius: 50%;
-//   border: 4px solid;
-//   width: 50px;
-//   height: 50px;
-//   border-color: inherit;
-// }
-// .el-step__icon.is-icon {
-//   border-radius: 50%;
-//   border: 4px solid;
-//   width: 50px;
-//   height: 50px;
-//   border-color: inherit;
-// }
-
-// .test-head-steps .el-step__line{
-//   height:50px !important;
-// }
-
-// .test-head-steps .el-step__icon-inner{
-//   width: 40px !important;
-//   height:40px !important;
-// }
-
-// .test-head-steps .el-step__icon{
-//   width: 48px !important;
-//   height:48px !important;
-//   font-size: 48px !important; /* 调整图标大小 */
-//   line-height: 80px !important; /* 使图标居中 */
-// }
-
-// :deep(.el-step__title)  {
-//   font-size: 24px !important; /* 设置标题字体大小 */
-//   margin-top: 10px !important; /* 调整标题与图标的间距 */
-// }
-
-// :deep(.el-step__icon-inner) {
-//   font-size: 24px !important;
-// }
-// .test-head-steps .el-step__description {
-//   font-size: 20px !important; /* 设置描述字体大小 */
-// }
 
 </style>

frontend/src/views/home/components/tree.vue

@@ -1,233 +1,319 @@
 <template>
-  <div class='plan_tree'>
-    <div class='search_view'>
-      <el-input
-        placeholder='请输入计划名称'
-        clearable
-        v-model='searchForm.planName'
-        show-word-limit
-        maxlength="32"
-      ></el-input>
-      <el-tooltip content="检测计划列表" placement="top">
-      <Menu style='width: 26px;height: 26px; margin-left: 8px;cursor: pointer;color:var(--el-color-primary)'
-            @click.stop='detail()' />
-      </el-tooltip>
+    <div class="plan_tree">
+        <div class="search_view">
+            <el-input
+                placeholder="请输入计划名称"
+                clearable
+                v-model="searchForm.planName"
+                show-word-limit
+                maxlength="32"
+            ></el-input>
+            <el-tooltip content="检测计划列表" placement="top">
+                <Menu
+                    style="width: 26px; height: 26px; margin-left: 8px; cursor: pointer; color: var(--el-color-primary)"
+                    @click.stop="detail()"
+                />
+            </el-tooltip>
+        </div>
+        <div class="tree_container">
+            <el-tree
+                :data="data"
+                ref="treeRef"
+                :filter-node-method="filterNode"
+                :props="defaultProps"
+                node-key="id"
+                class="filter-tree"
+                :highlight-current="true"
+                default-expand-all
+                :default-checked-keys="defaultChecked"
+                @node-click="handleNodeClick"
+            >
+                <template #default="{ node, data }">
+                    <span class="custom-tree-node" style="display: flex; align-items: center">
+                        <!-- 父节点图标 -->
+                        <Platform
+                            v-if="!data.pid"
+                            style="width: 18px; height: 18px; margin-right: 8px"
+                            :style="{
+                                color: node.label == '未检' ? '#fac858' : node.label == '检测中' ? '#ee6666' : '#91cc75'
+                            }"
+                        />
+                        <!-- 节点名称 -->
+                        <span>{{ node.label }}</span>
+                        <!-- 子节点右侧图标 + tooltip -->
+                        <el-tooltip
+                            v-if="
+                                node.label != '未检' &&
+                                node.label != '检测中' &&
+                                node.label != '检测完成' &&
+                                hasChildrenInPlanTable(node.data)
+                            "
+                            placement="top"
+                            :manual="true"
+                            content="子计划信息"
+                        >
+                            <List
+                                @click.stop="childDetail(node.data)"
+                                style="
+                                    width: 16px;
+                                    height: 16px;
+                                    margin-left: 8px;
+                                    cursor: pointer;
+                                    color: var(--el-color-primary);
+                                "
+                            />
+                        </el-tooltip>
+                    </span>
+                </template>
+            </el-tree>
+        </div>
     </div>
-    <div class='tree_container'>
-      <el-tree
-        :data='data'
-        ref='treeRef'
-        :filter-node-method='filterNode'
-        :props='defaultProps'
-        node-key='id'
-        class="filter-tree"
-        :highlight-current="true"
-        default-expand-all
-        :default-checked-keys='defaultChecked'
-        @node-click='handleNodeClick'
-      >
-        <template #default='{ node, data }'>
-          <span class='custom-tree-node' style='display: flex;align-items: center;'>
-            <Platform v-if='!data.pid' style='width:18px;height: 18px;margin-right:8px;'
-                      :style="{color:node.label=='未检'?'#fac858':node.label=='检测中'?'#ee6666':'#91cc75'}" />
-            <span>{{ node.label }}</span>
-            <!-- <Menu v-if="data.pid" @click.stop="detail(data)" style="width: 12px;margin-left: 8px;"/> -->
-          </span>
-        </template>
-      </el-tree>
-    </div>
-  </div>
+    <SourceOpen ref="openSourceView" :width="width" :height="height + 175"></SourceOpen>
 </template>
-<script lang='ts' setup>
-import { type Plan } from '@/api/plan/interface';
-import { Menu, Platform, CircleCheck,Loading } from '@element-plus/icons-vue'
-import { nextTick, onMounted, ref, watch } from 'vue';
+<script lang="ts" setup>
+import { type Plan } from '@/api/plan/interface'
+import { List, Menu, Platform } from '@element-plus/icons-vue'
+import { nextTick, onMounted, ref, watch } from 'vue'
 import { useRouter } from 'vue-router'
-import {useCheckStore} from "@/stores/modules/check";
-import { ElTooltip } from 'element-plus';
+import { useCheckStore } from '@/stores/modules/check'
+import { ElTooltip } from 'element-plus'
+import SourceOpen from '@/views/plan/planList/components/childrenPlan.vue'
+import { getPlanList } from '@/api/plan/plan.ts'
+import { useModeStore } from '@/stores/modules/mode' // 引入模式 store
+import { useDictStore } from '@/stores/modules/dict'
 
+const openSourceView = ref()
 const router = useRouter()
 const checkStore = useCheckStore()
 const filterText = ref('')
 const treeRef = ref()
 const data: any = ref([])
+const modeStore = useModeStore()
+const dictStore = useDictStore()
+
 const defaultProps = {
-  children: 'children',
-  label: 'name',
-  pid: 'pid',
+    children: 'children',
+    label: 'name',
+    pid: 'pid'
 }
 const searchForm = ref({
-  planName: '',
+    planName: ''
 })
-const defaultChecked = ref<string[]>([])  // 明确类型为 number[]
-const tree = ref(false)//确保左侧树高凉只执行一次
+const defaultChecked = ref<string[]>([]) // 明确类型为 number[]
+const tree = ref(false) //确保左侧树高凉只执行一次
 const getTreeData = (val: any) => {
-  defaultChecked.value = [];
-  data.value = val;
-
-  for (let item of data.value) {
-    if (item.children.length > 0) {
-      let node = item.children[0];
-      defaultChecked.value.push(node.id);
-      checkStore.setPlan(node);
-      // 高亮显示第一个节点
-      // 使用 nextTick 确保在 DOM 更新后调用 setCurrentKey
-      nextTick(() => {
-        treeRef.value?.setCurrentKey(node.id);
-        idd.value = node.id;
-      });
-      // 找到第一个符合条件的 children 后跳出循环
-      break;
+    defaultChecked.value = []
+    // 遍历 val 的每个 children，过滤掉 pid !== '0'
+    data.value = val
+    for (let item of data.value) {
+        if (item.children.length > 0) {
+            let node = item.children[0]
+            defaultChecked.value.push(node.id)
+            checkStore.setPlan(node)
+            // 高亮显示第一个节点
+            // 使用 nextTick 确保在 DOM 更新后调用 setCurrentKey
+            nextTick(() => {
+                treeRef.value?.setCurrentKey(node.id)
+                idd.value = node.id
+            })
+            // 找到第一个符合条件的 children 后跳出循环
+            break
+        }
     }
-  }
 }
 
 //点击表格后左侧树刷新，高亮显示对应节点
-const  clickTableToTree = (val: any,id:any) => {
-
-  defaultChecked.value = []
-  data.value = val
-  let node = ref('')
-  if (data.value.length > 0) {
-    for (let i = 0; i < data.value.length; i++){
-        for (let j = 0; j < data.value[i].children.length; j++) {
-            if (data.value[i].children[j].id == id) {
-              node.value = data.value[i].children[j].id
-              break;
+const clickTableToTree = (val: any, id: any) => {
+    defaultChecked.value = []
+    data.value = val
+    let node = ref('')
+    if (data.value.length > 0) {
+        for (let i = 0; i < data.value.length; i++) {
+            for (let j = 0; j < data.value[i].children.length; j++) {
+                if (data.value[i].children[j].id == id) {
+                    node.value = data.value[i].children[j].id
+                    break
+                }
             }
         }
+
+        // 使用 nextTick 确保在 DOM 更新后调用 setCurrentKey
+        nextTick(() => {
+            treeRef.value?.setCurrentKey(node.value)
+            idd.value = node.value
+        })
     }
-    
-    // 使用 nextTick 确保在 DOM 更新后调用 setCurrentKey
-    nextTick(() => {
-      treeRef.value?.setCurrentKey(node.value);
-      idd.value = node.value
-    });
-   
-  }
 }
 
-const {updateSelectedTreeNode}  = defineProps<{
-    updateSelectedTreeNode:Function;
-  }>();
+const { updateSelectedTreeNode, width, height, planTable } = defineProps<{
+    updateSelectedTreeNode: Function
+    width: number
+    height: number
+    planTable?: Array<[]>
+}>()
+
 watch(
-  () => searchForm.value.planName,
-  (val) => {
-    treeRef.value!.filter(val)
-  },
-  {
-    deep: true,
-  },
+    () => searchForm.value.planName,
+    val => {
+        treeRef.value!.filter(val)
+    },
+    {
+        deep: true
+    }
 )
 
+const hasChildrenInPlanTable = (nodeData: Plan.ResPlan) => {
+    try {
+        // 在 planTable 中查找对应的节点数据
+        const foundItem = tableData.value.find((item: any) => item.id === nodeData.id)
+
+        // 检查是否有 children 且 children 数组不为空
+        return foundItem && Array.isArray(foundItem.children) && foundItem.children.length > 0
+    } catch (error) {
+        console.error('检查子节点时出错:', error)
+        return false
+    }
+}
+
 const idd = ref('')
 const handleNodeClick = (data: Plan.ResPlan) => {
-
     if (data.name === '未检' || data.name === '检测中' || data.name === '检测完成') {
-      // 如果是父节点，不执行任何操作
-      //console.log('父节点不执行任何操作');
-      // 设置当前高亮节点
-    nextTick(() => {
-      treeRef.value?.setCurrentKey(idd.value);
-    });
-    return;
-  }
- 
-  idd.value = data.id
+        // 如果是父节点，不执行任何操作
+        //console.log('父节点不执行任何操作');
+        // 设置当前高亮节点
+        nextTick(() => {
+            treeRef.value?.setCurrentKey(idd.value)
+        })
+        return
+    }
 
-  checkStore.setPlan(data);
-  updateSelectedTreeNode(data.id)
+    idd.value = data.id
+
+    checkStore.setPlan(data)
+    updateSelectedTreeNode(data.id)
 }
 const filterNode = (value: string, data: any) => {
-  if (!value) return true
-   return data.name.includes(value)
+    if (!value) return true
+    return data.name.includes(value)
 }
 
-
 // 点击详情
 const detail = () => {
-  router.push('/plan/planList')
+    router.push('/plan/planList')
 }
-onMounted(() => {
- // console.log()
+
+const childDetail = (data: Plan.ResPlan) => {
+    const filteredPlans = tableData.value.filter(item => item.id === data.id)
+
+    // 确保有匹配项再访问 [0]
+    if (filteredPlans.length > 0 && openSourceView.value) {
+        openSourceView.value.open('检测计划详情', filteredPlans[0])
+    }
+}
+
+function buildTree(flatList: any[]): any[] {
+    const map = new Map()
+    const tree: any[] = []
+
+    // First, create a map of all items by id for fast lookup
+    flatList.forEach(item => {
+        map.set(item.id, { ...item, children: [] })
+    })
+
+    // Then, assign each item to its parent's children array
+    flatList.forEach(item => {
+        if (item.fatherPlanId && map.has(item.fatherPlanId)) {
+            map.get(item.fatherPlanId).children.push(map.get(item.id))
+        } else if (item.fatherPlanId === '0') {
+            // Items with fatherPlanId '0' are root nodes
+            tree.push(map.get(item.id))
+        }
+    })
+
+    return tree
+}
+
+const tableData = ref<any[]>([])
+onMounted(async () => {
+    if (modeStore.currentMode != '比对式') return
+    const patternId = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id
+    const result = await getPlanList({ patternId: patternId })
+    tableData.value = buildTree(result.data as any[])
 })
-defineExpose({ getTreeData ,clickTableToTree})
-
 
+defineExpose({ getTreeData, clickTableToTree })
 </script>
-<style lang='scss' scoped>
+<style lang="scss" scoped>
 .plan_tree {
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-  background-color: #fff;
-
-  .search_view {
-    width: 100%;
-    height: auto;
+    height: 100%;
     display: flex;
-    justify-content: space-between;
-    padding: 0 5px;
-    box-sizing: border-box;
-    align-items: center;
+    flex-direction: column;
+    background-color: #fff;
+
+    .search_view {
+        width: 100%;
+        height: auto;
+        display: flex;
+        justify-content: space-between;
+        padding: 0 5px;
+        box-sizing: border-box;
+        align-items: center;
+
+        .el-input {
+            margin-top: 6px;
+        }
+    }
 
     .el-input {
-      margin-top: 6px;
+        width: 100%;
+        margin: 0 10px 10px 0;
     }
-  }
 
-  .el-input {
-    width: 100%;
-    margin: 0 10px 10px 0;
-  }
+    .tree_container {
+        height: 100%;
+        width: 100%;
+        flex: 1;
+        overflow-y: auto;
+        overflow-x: auto;
 
-  .tree_container {
-    height: 100%;
-    width: 100%;
-    flex: 1;
-    overflow-y: auto;
-    overflow-x: auto;
-
-    .el-tree {
-      // height: 100%;
-      width: auto;
+        .el-tree {
+            // height: 100%;
+            width: auto;
+        }
     }
-  }
 }
 
-
 .filter-tree {
-//  border: 1px solid #dcdfe6;
-  min-width: 100%;
-  height: 97%;
-  display: inline-block;
-  overflow: auto;
-  margin-top: 12px;
-
+    //  border: 1px solid #dcdfe6;
+    min-width: 100%;
+    height: 97%;
+    display: inline-block;
+    overflow: auto;
+    margin-top: 12px;
 }
 
 //.filter-tree span {
 //  font-size: 16px;
 //  display:block;
 //  overflow:hidden;
-  // word-break:keep-all;
-  // white-space:nowrap;
-  //  text-overflow:ellipsis;
+// word-break:keep-all;
+// white-space:nowrap;
+//  text-overflow:ellipsis;
 //   padding-right: 12px;
 //}
 .leftBox {
-  // float: left;
-  // width: 20%;
-  height: 100%;
-  width: 100%;
+    // float: left;
+    // width: 20%;
+    height: 100%;
+    width: 100%;
 }
 .left {
-  height: calc(100% - 45px);
-  overflow: auto;
+    height: calc(100% - 45px);
+    overflow: auto;
 }
 /* 设置滚动条宽度 */
 :deep(.bodyTwo ::-webkit-scrollbar) {
-    width: 3px !important; 
-    height: 6px !important;   
-  } 
+    width: 3px !important;
+    height: 6px !important;
+}
 </style>

frontend/src/views/home/components/writeTHPopup.vue

@@ -1,39 +1,39 @@
 <template>
-  <el-dialog title="填写实验室环境" v-model='dialogVisible' @close="handleClose" v-bind="dialogSmall" >
+  <el-dialog title='填写实验室环境' v-model='dialogVisible' @close='handleClose' v-bind='dialogSmall'>
     <div>
-      <el-form ref="dialogFormRef" :model="formContent"  :rules='rules' >
-       <el-form-item label="温度(℃)" prop="temperature" :label-width="110">
-            <el-input v-model="formContent.temperature" placeholder="请输入温度" maxlength="32" show-word-limit/>
-        </el-form-item>            
-        <el-form-item label="相对湿度(%)" prop="humidity" :label-width="110">
-            <el-input v-model="formContent.humidity" placeholder="请输入湿度" maxlength="32" show-word-limit/>
-        </el-form-item> 
+      <el-form ref='dialogFormRef' :model='formContent' :rules='rules'>
+        <el-form-item label='温度(℃)' prop='temperature' :label-width='110'>
+          <el-input v-model='formContent.temperature' placeholder='请输入温度' maxlength='32' show-word-limit />
+        </el-form-item>
+        <el-form-item label='相对湿度(%)' prop='humidity' :label-width='110'>
+          <el-input v-model='formContent.humidity' placeholder='请输入湿度' maxlength='32' show-word-limit />
+        </el-form-item>
       </el-form>
     </div>
 
     <template #footer>
-        <span class="dialog-footer">
-          <el-button @click="handleClose">取消</el-button>
-          <el-button type="primary" @click="handleStart">确定</el-button>
+        <span class='dialog-footer'>
+          <el-button @click='handleClose'>取消</el-button>
+          <el-button type='primary' @click='handleStart'>确定</el-button>
         </span>
     </template>
   </el-dialog>
 </template>
 
 <script setup lang='tsx' name='selectTestItemPopup'>
-import {dialogSmall} from "@/utils/elementBind";
-import {reactive, Ref, ref} from "vue";
-import type {Device} from "@/api/device/interface/device.ts";
-import {ElMessageBox, FormItemRule} from "element-plus";
-import {useCheckStore} from "@/stores/modules/check";
+import { dialogSmall } from '@/utils/elementBind'
+import { reactive, Ref, ref } from 'vue'
+import type { Device } from '@/api/device/interface/device.ts'
+import { ElMessageBox, FormItemRule } from 'element-plus'
+import { useCheckStore } from '@/stores/modules/check'
 
 const emit = defineEmits(['openTestDialog2'])
 const dialogFormRef = ref()
 
 
 const dialogVisible = ref(false)
-const formContent = reactive<Device.ResTH>({temperature:0,humidity:0})
-const checkStore = useCheckStore();
+const formContent = reactive<Device.ResTH>({ temperature: 0, humidity: 0 })
+const checkStore = useCheckStore()
 const open = async () => {
   resetFormContent()
   dialogVisible.value = true
@@ -41,35 +41,39 @@ const open = async () => {
 
 // 清空表单内容
 const resetFormContent = () => {
-  Object.assign(formContent,{temperature:'',humidity:''})
+  Object.assign(formContent, { temperature: '22', humidity: '50' })
 }
 
 
-  //定义校验规则
-  const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
-    temperature: [{ required: true, message: '温度必填！', trigger: 'blur' },
-       // 指定正则，此处是数字正则
-       { pattern: /^(?:(?:-50)|-?[1-4][0-9]|-?[0-9]|[1-4][0-9]|50)(\.[0-9]+)?$/,
+//定义校验规则
+const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
+  temperature: [{ required: true, message: '温度必填！', trigger: 'blur' },
+    // 指定正则，此处是数字正则
+    {
+      pattern: /^(?:(?:-50)|-?[1-4][0-9]|-?[0-9]|[1-4][0-9]|50)(\.[0-9]+)?$/,
       message: '温度必须为 -50 到 50 之间的合法数字',
-       trigger: 'blur' 
+      trigger: 'blur',
     }],
-    humidity: [{ required: true, message: '湿度必填！', trigger: 'blur' },
-      { pattern: /^(?:100(?:\.0+)?|\d{1,2}(?:\.\d+)?|0?\.\d+)$/  , message: '湿度必须为 0 到 100 之间的合法数字', trigger: 'blur' },
-    ],
-    
-  })
+  humidity: [{ required: true, message: '湿度必填！', trigger: 'blur' },
+    {
+      pattern: /^(?:100(?:\.0+)?|\d{1,2}(?:\.\d+)?|0?\.\d+)$/,
+      message: '湿度必须为 0 到 100 之间的合法数字',
+      trigger: 'blur',
+    },
+  ],
+
+})
 
 
 const handleStart = () => {
-    try {      
-        dialogFormRef.value?.validate(async (valid: boolean) => {
-        if (valid) {
-           
-            checkStore.setTemperature(formContent.temperature)
-            checkStore.setHumidity(formContent.humidity)
-            emit('openTestDialog2')
-            handleClose()
-        }
+  try {
+    dialogFormRef.value?.validate(async (valid: boolean) => {
+      if (valid) {
+        checkStore.setTemperature(formContent.temperature)
+        checkStore.setHumidity(formContent.humidity)
+        emit('openTestDialog2')
+        handleClose()
+      }
     })
   } catch (err) {
     console.error('验证过程中出现错误', err)
@@ -85,11 +89,11 @@ const handleClose = () => {
   dialogFormRef.value?.resetFields()
 }
 
-defineExpose({open})
+defineExpose({ open })
 
 </script>
 
 
-<style scoped lang="scss">
+<style scoped lang='scss'>
 
 </style>

frontend/src/views/home/index.vue

@@ -70,14 +70,14 @@ const modeList = [
 const handelOpen = async (isActive: any) => {
   await authStore.setShowMenu();
   return;
-  if (isActive) {
-    router.push({ path: "/static" });
-  } else {
-    ElMessage({
-      message: "当前模式未配置",
-      type: "warning",
-    });
-  }
+  // if (isActive) {
+  //   router.push({ path: "/static" });
+  // } else {
+  //   ElMessage({
+  //     message: "当前模式未配置",
+  //     type: "warning",
+  //   });
+  // }
 };
 const handleSelect = (key: string, keyPath: string[]) => {
   //console.log(key, keyPath);

frontend/src/views/home/tabs/dashboard.vue

@@ -1,13 +1,18 @@
-<!-- 真正的首页 -->
+<!-- 
+  首页Dashboard组件 - 主要功能页面
+  布局：左侧计划树 + 右侧功能区域（功能选择、饼图统计、表格数据）
+-->
 <template>
-  <div class='static'>
+  <div class='static' ref='popupBaseView'>
     <el-row :gutter='10'>
+      <!-- 左侧计划树区域 (20%) -->
       <el-col :lg='4' :xl='4' :md='4' :sm='4'>
         <div class='left_tree'>
-          <!-- <tree ref='treeRef' :updateSelectedTreeNode='getPieData || (() => {})' /> -->
-            <tree ref='treeRef' :updateSelectedTreeNode='updateData|| (() => {})' />
+          <tree ref='treeRef' :updateSelectedTreeNode='updateData|| (() => {})' :width='viewWidth' :height='viewHeight'
+                :planTable='planTable' />
         </div>
       </el-col>
+      <!-- 右侧主要内容区域 (80%) -->
       <el-col :lg='20' :xl='20' :md='20' :sm='20'>
         <div class='right_container'>
           <!-- 功能选择 -->
@@ -90,12 +95,13 @@
           </div>
 
           <!--下方表格数据-->
-          <el-tabs class='tabs-menu' type='border-card' @tab-change='handleTabsChange' v-model='editableTabsValue'
+          <el-tabs class='tabs-menu' type='border-card' v-model='editableTabsValue'
                    :style='{ height: tabsHeight }'>
             <el-tab-pane :label='tabLabel1' :style='{ height: tabPaneHeight}'>
-              <!-- 列表数据 -->
+              <!-- 设备数据表格 -->
               <div class='container_table' :style='{ height: tableHeight }'>
-                <Table ref='tableRef1' :id='currentId' :plan = 'select_Plan' @batchGenerateClicked="handleBatchGenerate"></Table>
+                <Table ref='tableRef1' :id='currentId' :plan='select_Plan' :planArray='planList2'
+                       :planTable='planTable' @batchGenerateClicked='handleBatchGenerate'></Table>
               </div>
             </el-tab-pane>
           </el-tabs>
@@ -105,30 +111,28 @@
   </div>
 </template>
 <script lang='ts' setup>
-import pie from '@/components/echarts/pie/default.vue'
 import { useRouter } from 'vue-router'
+import { type Plan } from '@/api/plan/interface'
+import { type CollapseModelValue } from 'element-plus/es/components/collapse/src/collapse.mjs'
+import { type Device } from '@/api/device/interface/device'
+import { type ResultData } from '@/api/interface'
+import pie from '@/components/echarts/pie/default.vue'
 import tree from '../components/tree.vue'
 import Table from '../components/table.vue'
-import deviceDataList from '@/api/device/device/deviceData'
-import { getBoundPqDevList, getPlanListByPattern } from '@/api/plan/plan.ts'
-import { onBeforeMount, onUnmounted, ref, watch } from 'vue'
+import { getBoundPqDevList, getPlanListByPattern, getPlanList } from '@/api/plan/plan'
+import { onBeforeMount, onUnmounted, ref, watch, nextTick } from 'vue'
 import { useModeStore } from '@/stores/modules/mode' // 引入模式 store
 import { useDictStore } from '@/stores/modules/dict'
-import { type Plan } from '@/api/plan/interface'
-import type { CollapseModelValue } from 'element-plus/es/components/collapse/src/collapse.mjs'
-import { type Device } from '@/api/device/interface/device'
-import { ResultData } from '@/api/interface'
+import { useViewSize } from '@/hooks/useViewSize'
 
 const planName = ref('')
 const dictStore = useDictStore()
 const modeStore = useModeStore()
 const chartsInfoRef = ref<HTMLElement | null>(null)
 const chartsWidth = ref<number>(0)
-const deviceData = deviceDataList.plan_devicedata
 const treeRef = ref()
 const form: any = ref({
   activeTabs: 0, //功能选择,例如报告生成
-  activeChildTabs: 0,//子功能选择,例如未检设备报告生成，或已检设备更换误差体系生成
   checkStatus: 0, //检测状态
   checkReportStatus: 0, //检测报告状态
   checkResult: 0, //检测结果
@@ -145,118 +149,127 @@ const tabsHeight = ref('calc(100vh - 522px)') // 初始高度
 const tabPaneHeight = ref('calc(100% - 5px)') // 初始高度
 const tableHeight = ref('calc(100% - 50px)') // 初始高度
 
-const planList = ref<ResultData<Plan.ReqPlan[]>>()
-const select_Plan = ref<Plan.ReqPlan>()
-const isLabelLineShow = ref(true)
-const handleCollapseChange = (val: CollapseModelValue) => {
+// ============================ 计划数据状态 ============================
+const planList = ref<Plan.ReqPlan[]>([]) // 计划列表（过滤后）
+const planList2 = ref<Plan.ReqPlan[]>([]) // 计划列表原始数据（包含子计划）
+const select_Plan = ref<Plan.ReqPlan>() // 当前选中的计划
+const planTable = ref<any[]>([]) // 比对模式下的计划表格数据
 
-  // 计算新的高度
+// ============================ 视图状态 ============================
+const isLabelLineShow = ref(true) // 饼图是否显示引导线
+const { popupBaseView, viewWidth, viewHeight } = useViewSize() // 视口尺寸hook
+
+/**
+ * 处理折叠面板展开/收起事件
+ * 根据面板状态动态调整表格高度，优化空间利用
+ * @param val - 当前展开的面板值
+ */
+const handleCollapseChange = (val: CollapseModelValue) => {
+  // 计算新的高度值
   let newHeight
   if (Array.isArray(val)) {
+    // 数组情况：有展开项时高度更小，无展开项时高度更大
     newHeight = val.length > 0 ? 'calc(100vh - 522px)' : 'calc(100vh - 333px)'
   } else {
+    // 单个值情况：展开时高度更小，收起时高度更大
     newHeight = val ? 'calc(100vh - 538px)' : 'calc(100vh - 333px)'
   }
+  // 更新各个容器的高度
   tabsHeight.value = newHeight
   tabPaneHeight.value = `calc(100% - 5px)`
   tableHeight.value = `calc(100% - 5px)`
 }
 
-const handleTabsChange = (val: any) => {
-  form.value.activeTabs = 0
-  form.value.activeTabs = 3
-  form.value.activeChildTabs = Number(val)
 
-}
+// 设置默认主题颜色
 localStorage.setItem('color', '#91cc75')
-//功能选择数据
+// ============================ 功能按钮配置 ============================
+/**
+ * 主功能选项卡配置
+ * 包含4个主要功能：设备检测、报告生成、设备归档、数据操作
+ */
 const tabsList = ref([
   {
-    label: '设备检测',
+    label: '设备检测', // 设备检测功能
     value: 0,
     img: new URL('/src/assets/images/plan/static/1.svg', import.meta.url).href,
-    checked: true,
+    checked: true, // 默认选中
   },
   {
-    label: '报告生成',
+    label: '报告生成', // 检测报告生成功能
     value: 3,
     img: new URL('/src/assets/images/plan/static/3.svg', import.meta.url).href,
     checked: false,
   },
   {
-    label: '设备归档',
+    label: '设备归档', // 设备归档管理功能
     value: 4,
     img: new URL('/src/assets/images/plan/static/4.svg', import.meta.url).href,
     checked: false,
   },
   {
-    label: '数据操作',
+    label: '数据操作', // 数据查询和操作功能
     value: 5,
     img: new URL('/src/assets/images/plan/static/5.svg', import.meta.url).href,
     checked: false,
   },
 ])
 
+// 初始化默认选中第一个功能选项卡
 form.value.activeTabs = tabsList.value[0].value
-const tableRef1 = ref()
-const tableRef2 = ref()
-const currentId = ref('')
 
+// ============================ 组件引用和状态 ============================
+const tableRef1 = ref() // 主表格组件引用
+const currentId = ref('') // 当前选中的计划ID
 
+// ============================ 监听器 ============================
+let isUpdatingTabs = false // 防止重复调用的标志
+
+/**
+ * 监听功能切换并通知表格组件更新配置
+ * 不再传递静态数据，让表格组件通过API获取真实数据
+ */
 watch(
-  () => form.value,
-  (val, oldVal) => {
-    if (val) {
-
-      if (form.value.activeTabs === 0)//设备检测
-      {
-        const tabledata = deviceData.filter((item) => item.document_State === '未归档')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      } else if (form.value.activeTabs === 4)//设备归档
-      {
-        const tabledata = deviceData.filter((item) => item.check_State === '检测完成' && item.document_State === '未归档')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      } else if (form.value.activeTabs === 3 || form.value.activeTabs === 5)//报告生成、数据查询
-      {
-        const tabledata = deviceData.filter((item) => item.check_State === '检测完成')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      }
-    }
-  },
-  {
-    immediate: true,
-    deep: true,
-  },
-)
-watch(
-  () => form.value,
-  (val, oldVal) => {
-    if (val) {
-      tableRef2.value && tableRef2.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs)
-    }
-  },
-  {
-    immediate: true,
-    deep: true,
-  },
+  () => form.value.activeTabs,
+  async (newTabs) => {
+    if (isUpdatingTabs) return // 如果正在更新中，跳过
+    
+    isUpdatingTabs = true
+    // 只传递功能模式，不传递静态假数据
+    // 表格组件会根据功能模式通过API获取对应的真实数据
+    tableRef1.value && tableRef1.value.changeActiveTabs(newTabs)
+    
+    // 等待一个微任务队列后重置标志
+    await nextTick()
+    isUpdatingTabs = false
+  }
+  // 去掉 immediate: true，避免初始化时重复调用
 )
 
+// ============================ 饼图组件引用和数据 ============================
+const pieRef1 = ref(), // 设备检测状态饼图引用
+  pieRef2 = ref(), // 设备检测结果饼图引用
+  pieRef3 = ref() // 设备报告状态饼图引用
 
+const chartsData1: any = ref([]), // 设备检测状态统计数据
+  chartsData2: any = ref([]), // 设备检测结果统计数据
+  chartsData3: any = ref([]) // 设备报告状态统计数据
 
-const pieRef1 = ref(),
-  pieRef2 = ref(),
-  pieRef3 = ref()
-
-const chartsData1: any = ref([]),
-  chartsData2: any = ref([]),
-  chartsData3: any = ref([])
-
-const findPlanById = (plans: Plan.ReqPlan[], id: string): Plan.ReqPlan | undefined => {
+// ============================ 工具函数 ============================
+/**
+ * 递归查找指定 ID 的计划
+ * @param plans - 计划数组
+ * @param id - 计划 ID
+ * @returns 找到的计划对象或 undefined
+ */
+const findPlanById = (plans: any, id: string): Plan.ReqPlan | undefined => {
+  if (!plans) return undefined
   for (const plan of plans) {
-    if (plan.id === id) {
+    if (plan?.id === id) {
       return plan
     }
-    if (plan.children) {
+    // 递归搜索子计划
+    if (plan?.children) {
       const foundPlan = findPlanById(plan.children, id)
       if (foundPlan) {
         return foundPlan
@@ -267,42 +280,57 @@ const findPlanById = (plans: Plan.ReqPlan[], id: string): Plan.ReqPlan | undefin
 }
 
 
+/**
+ * 处理树节点选中事件的回调函数
+ * 根据选中的计划节点更新饼图数据并切换相应的功能模式
+ * @param id - 选中的计划 ID
+ */
 const updateData = (id: string) => {
-    getPieData(id);//刷新饼图
+  // 刷新饼图数据
+  getPieData(id)
 
-    //获取点击树的父节点名字
-    const parentNodeName = ref('')
-    for (let i = 0; i < planList.value.data.length; i++) {
-    if (Array.isArray(planList.value.data[i].children) && planList.value.data[i].children.length > 0) {
-        for (let j = 0; j < planList.value.data[i].children.length; j++) {
-            if (planList.value.data[i].children[j].id === id) {
-                parentNodeName.value = planList.value.data[i].name
-                break;
-            }
+  // 查找当前计划的父节点名称
+  const parentNodeName = ref('')
+  if (planList.value?.length) {
+    for (let i = 0; i < planList.value.length; i++) {
+      const children = planList.value[i]?.children
+      if (Array.isArray(children) && children.length > 0) {
+        for (let j = 0; j < children.length; j++) {
+          if (children[j]?.id === id) {
+            parentNodeName.value = planList.value[i]?.name || ''
+            break
+          }
         }
       }
     }
-    if(parentNodeName.value === '检测完成'){
-      handleCheckFunction(5)
-    }else{
-      handleCheckFunction(0)
-    }
+  }
+  
+  // 根据父节点名称自动切换功能模式
+  if (parentNodeName.value === '检测完成') {
+    handleCheckFunction(5) // 切换到数据操作模式
+  } else {
+    handleCheckFunction(0) // 切换到设备检测模式
+  }
 }
 
+/**
+ * 获取指定计划的设备统计数据并更新饼图
+ * 分别统计设备的检测状态、检测结果、报告状态分布情况
+ * @param id - 计划 ID
+ */
 const getPieData = async (id: string) => {
-  currentId.value = id // 设置当前ID
-  // 初始化计数对象
-  const checkStateCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0, 3: 0 }
-  const checkResultCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0 }
-  const reportStateCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0 }
+  currentId.value = id // 设置当前选中的计划ID
+  
+  // 初始化各类统计计数器
+  const checkStateCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0, 3: 0 } // 检测状态计数：未检(0)、检测中(1)、检测完成(2)、归档(3)
+  const checkResultCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0 } // 检测结果计数：不符合(0)、符合(1)、未检(2)
+  const reportStateCount: { [key: number]: number } = { 0: 0, 1: 0, 2: 0 } // 报告状态计数：未生成(0)、已生成(1)、未检(2)
   if (id) {
     const boundPqDevList = ref<Device.ResPqDev[]>([])//根据检测计划id查询出所有已绑定的设备
-    const plan = findPlanById(planList.value?.data || [], id)
-    planName.value = '所选计划:' + plan.name
-    
+    const plan = findPlanById(planList.value, id)
+    planName.value = '所选计划:' + (plan?.name || '')
     select_Plan.value = plan
-
-    const pqDevList_Result2 = await getBoundPqDevList({ 'planId': id, 'checkStateList': [0, 1, 2, 3] })
+    const pqDevList_Result2 = await getBoundPqDevList({ 'planIdList': [id], 'checkStateList': [0, 1, 2, 3] })
     boundPqDevList.value = pqDevList_Result2.data as Device.ResPqDev[]
     // 遍历 boundPqDevList 并更新计数对象
     boundPqDevList.value.forEach(t => {
@@ -321,85 +349,129 @@ const getPieData = async (id: string) => {
       }
     })
 
-
     // 检查 checkStateCount 是否全为 0
-    if(boundPqDevList.value.length != 0){
+    if (boundPqDevList.value.length != 0) {
 
-      isLabelLineShow.value = true;
-      const allZero = Object.values(checkStateCount).every(count => count === 0);
+      isLabelLineShow.value = true
+      const allZero = Object.values(checkStateCount).every(count => count === 0)
       chartsData1.value = [
-      { value: allZero ? 0 : checkStateCount[0] === 0 ? null : checkStateCount[0], name: '未检', itemStyle: { color: '#fac858' } },
-      { value: allZero ? 0 : checkStateCount[1] === 0 ? null : checkStateCount[1], name: '检测中', itemStyle: { color: '#ee6666' } },
-      { value: allZero ? 0 : checkStateCount[2] === 0 ? null : checkStateCount[2], name: '检测完成', itemStyle: { color: '#91cc75' } },
-      { value: allZero ? 0 : checkStateCount[3] === 0 ? null : checkStateCount[3], name: '归档', itemStyle: { color: '#5470c6' } },
-      ];
-         // 同样处理 chartsData2 和 chartsData3
-      const allZeroResult = Object.values(checkResultCount).every(count => count === 0);
+        {
+          value: allZero ? 0 : checkStateCount[0] === 0 ? null : checkStateCount[0],
+          name: '未检',
+          itemStyle: { color: '#fac858' },
+        },
+        {
+          value: allZero ? 0 : checkStateCount[1] === 0 ? null : checkStateCount[1],
+          name: '检测中',
+          itemStyle: { color: '#ee6666' },
+        },
+        {
+          value: allZero ? 0 : checkStateCount[2] === 0 ? null : checkStateCount[2],
+          name: '检测完成',
+          itemStyle: { color: '#91cc75' },
+        },
+        {
+          value: allZero ? 0 : checkStateCount[3] === 0 ? null : checkStateCount[3],
+          name: '归档',
+          itemStyle: { color: '#5470c6' },
+        },
+      ]
+      // 同样处理 chartsData2 和 chartsData3
+      const allZeroResult = Object.values(checkResultCount).every(count => count === 0)
       chartsData2.value = [
-        { value: allZeroResult ? 0 : checkResultCount[2] === 0 ? null : checkResultCount[2], name: '未检', itemStyle: { color: '#fac858' } },
-        { value: allZeroResult ? 0 : checkResultCount[0] === 0 ? null : checkResultCount[0], name: '不符合', itemStyle: { color: '#ee6666' } },
-        { value: allZeroResult ? 0 : checkResultCount[1] === 0 ? null : checkResultCount[1], name: '符合', itemStyle: { color: '#91cc75' } },
-      ];
+        {
+          value: allZeroResult ? 0 : checkResultCount[2] === 0 ? null : checkResultCount[2],
+          name: '未检',
+          itemStyle: { color: '#fac858' },
+        },
+        {
+          value: allZeroResult ? 0 : checkResultCount[0] === 0 ? null : checkResultCount[0],
+          name: '不符合',
+          itemStyle: { color: '#ee6666' },
+        },
+        {
+          value: allZeroResult ? 0 : checkResultCount[1] === 0 ? null : checkResultCount[1],
+          name: '符合',
+          itemStyle: { color: '#91cc75' },
+        },
+      ]
 
 
       // 检查 reportStateCount 是否全为 0
-      const allZeroReport = Object.values(reportStateCount).every(count => count === 0);
+      const allZeroReport = Object.values(reportStateCount).every(count => count === 0)
       chartsData3.value = [
-        { value: allZeroReport ? 0 : reportStateCount[2] === 0 ? null : reportStateCount[2], name: '未检', itemStyle: { color: '#fac858' } },
-        { value: allZeroReport ? 0 : reportStateCount[0] === 0 ? null : reportStateCount[0], name: '未生成', itemStyle: { color: '#ee6666' } },
-        { value: allZeroReport ? 0 : reportStateCount[1] === 0 ? null : reportStateCount[1], name: '已生成', itemStyle: { color: '#91cc75' } },
-      ];
+        {
+          value: allZeroReport ? 0 : reportStateCount[2] === 0 ? null : reportStateCount[2],
+          name: '未检',
+          itemStyle: { color: '#fac858' },
+        },
+        {
+          value: allZeroReport ? 0 : reportStateCount[0] === 0 ? null : reportStateCount[0],
+          name: '未生成',
+          itemStyle: { color: '#ee6666' },
+        },
+        {
+          value: allZeroReport ? 0 : reportStateCount[1] === 0 ? null : reportStateCount[1],
+          name: '已生成',
+          itemStyle: { color: '#91cc75' },
+        },
+      ]
 
-    }else{
+    } else {
 
-      isLabelLineShow.value = false;//不展示引导线
+      isLabelLineShow.value = false//不展示引导线
       chartsData1.value = [
-      { value: null , name: '未检', itemStyle: { color: '#fac858' } },
-      { value:  null , name: '检测中', itemStyle: { color: '#ee6666' } },
-      { value: null , name: '检测完成', itemStyle: { color: '#91cc75' } },
-      { value:  null , name: '归档', itemStyle: { color: '#5470c6' } },
-      { value:  0 , itemStyle: { color: '#eeeeee' } },
-    ];
+        { value: null, name: '未检', itemStyle: { color: '#fac858' } },
+        { value: null, name: '检测中', itemStyle: { color: '#ee6666' } },
+        { value: null, name: '检测完成', itemStyle: { color: '#91cc75' } },
+        { value: null, name: '归档', itemStyle: { color: '#5470c6' } },
+        { value: 0, itemStyle: { color: '#eeeeee' } },
+      ]
 
-    chartsData2.value = [
+      chartsData2.value = [
         { value: null, name: '未检', itemStyle: { color: '#fac858' } },
         { value: null, name: '不符合', itemStyle: { color: '#ee6666' } },
         { value: null, name: '符合', itemStyle: { color: '#91cc75' } },
-        { value:  0 , itemStyle: { color: '#eeeeee' } },
-      ];
+        { value: 0, itemStyle: { color: '#eeeeee' } },
+      ]
 
       chartsData3.value = [
         { value: null, name: '未检', itemStyle: { color: '#fac858' } },
         { value: null, name: '未生成', itemStyle: { color: '#ee6666' } },
         { value: null, name: '已生成', itemStyle: { color: '#91cc75' } },
-        { value:  0 , itemStyle: { color: '#eeeeee' } },
-      ];
+        { value: 0, itemStyle: { color: '#eeeeee' } },
+      ]
     }
-    
-
-
- 
-  }else{
-    
-    planName.value = '所选计划:' 
+  } else {
+    planName.value = '所选计划:'
   }
 
 
-
   pieRef1.value.init()
   pieRef2.value.init()
   pieRef3.value.init()
 }
+/**
+ * 初始化树组件数据
+ * @param data - 计划数据
+ */
 const getTree = (data?: any) => {
   treeRef.value.getTreeData(data)
 }
-//前往检测
+
+// ============================ 路由跳转函数 ============================
+/**
+ * 跳转到检测页面
+ */
 const handleDetection = () => {
   router.push({
     path: '/detection',
   })
 }
-//前往计划详情
+
+/**
+ * 跳转到计划详情页面
+ */
 const planDetail = () => {
   router.push({
     path: '/plan/planList',
@@ -407,55 +479,69 @@ const planDetail = () => {
 }
 
 
-//功能选择css切换
+// ============================ 主要业务逻辑函数 ============================
+/**
+ * 处理功能选项卡切换
+ * 根据选中的功能更新UI状态和表格显示内容
+ * @param val - 功能选项卡值 (0:设备检测, 3:报告生成, 4:设备归档, 5:数据操作)
+ */
 const handleCheckFunction = (val: any) => {
-
+  // 重置tab状态
   editableTabsValue.value = '0'
-  form.value.activeChildTabs = 0
+  
+  // 更新功能按钮的选中状态
   tabsList.value.map((item: any, index: any) => {
-    if (val == item.value) {
-      item.checked = true
-    } else {
-      item.checked = false
-    }
+    item.checked = (val == item.value)
   })
 
   tabShow.value = false
 
+  // 根据选中的功能设置不同的过滤条件和标签
   switch (val) {
-    case 0://自动检测
-      checkStateTable.value = [0, 1, 2]
+    case 0: // 设备检测模式
+      checkStateTable.value = [0, 1, 2] // 显示未检、检测中、检测完成的设备
       tabLabel1.value = '设备检测'
       break
-    case 1://手动检测
+    case 1: // 手动检测模式（预留）
       tabLabel1.value = '手动检测'
       break
-    case 2://设备复检
+    case 2: // 设备复检模式（预留）
       tabLabel1.value = '设备复检'
       break
-    case 3://报告生成
-      checkStateTable.value = [2, 3]
+    case 3: // 报告生成模式
+      checkStateTable.value = [2, 3] // 显示检测完成和已归档的设备
       tabLabel1.value = '报告生成'
-      //tabShow.value = true;
       break
-    case 4://设备归档
-      checkStateTable.value = [2]
+    case 4: // 设备归档模式
+      checkStateTable.value = [2] // 只显示检测完成的设备
       tabLabel1.value = '设备归档'
       break
-    case 5://数据查询
-      checkStateTable.value = [2, 3]
+    case 5: // 数据查询模式
+      checkStateTable.value = [2, 3] // 显示检测完成和已归档的设备
       tabLabel1.value = '数据查询'
       break
   }
+  // 更新当前激活的功能选项卡
   form.value.activeTabs = val
+  
+  // 刷新饼图数据以确保统计信息同步
+  if (currentId.value) {
+    getPieData(currentId.value)
+  }
 }
 
 
+// ============================ 监听器和事件处理 ============================
+/**
+ * 饼图容器尺寸变化监听器
+ * 当容器大小变化时自动调整饼图尺寸，保持响应式设计
+ */
 const resizeObserver = new ResizeObserver(entries => {
   for (let entry of entries) {
+    // 更新容器宽度
     chartsWidth.value = entry.contentRect.width
-    //console.log('Charts Info Width:', chartsWidth.value);
 
+    // 同步调整三个饼图的尺寸（宽度为容器的95%，高度固定180px）
     pieRef1.value?.reSize(chartsWidth.value * 0.95, 180, true)
     pieRef2.value?.reSize(chartsWidth.value * 0.95, 180, true)
     pieRef3.value?.reSize(chartsWidth.value * 0.95, 180, true)
@@ -463,10 +549,18 @@ const resizeObserver = new ResizeObserver(entries => {
 })
 
 
+// ============================ 初始化函数 ============================
+/**
+ * 初始化计划数据
+ * 根据当前模式获取相应的计划列表数据
+ */
 const initPlan = async () => {
-  const patternId = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? ''//获取数据字典中对应的id
+  // 获取当前模式对应的数据字典ID
+  const patternId = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id ?? ''
+  
+  // 构建计划查询请求对象
   const reqPlan: Plan.ReqPlan = {
-    pattern: patternId,
+    pattern: patternId, // 模式ID
     datasourceIds: '',
     sourceIds: '',
     planId: '',
@@ -485,60 +579,101 @@ const initPlan = async () => {
     result: 0,
     code: 0,
     state: 0,
-  }
-  planList.value = (await getPlanListByPattern(reqPlan)) as ResultData<Plan.ReqPlan[]>
-}
-
-onBeforeMount(async () => {
-  await initPlan()
-  for (let i = 0; i < planList.value.data.length; i++) {
-    if (Array.isArray(planList.value.data[i].children) && planList.value.data[i].children.length > 0) {
-      currentId.value = planList.value.data[i].children[0].id; // 直接赋值第一个 children 的 id
-      break; // 确保只执行一次
-    }
+    standardDevNameStr: '',
+    associateReport: 0,
+    reportTemplateName: '',
+    reportTemplateVersion: '',
+    dataRule: '',
+    testItemNameStr: '',
+    testItems: [],
+    standardDevIds: [],
+    standardDevMap: new Map<string, number>(),
   }
   
-  // if (planList.value.data[0].children[0]) {
-  //   currentId.value = planList.value.data[0].children[0].id
-  //   console.log('currentId.value',planList.value.data[0])
-  // }
+  // 获取计划数据
+  const result = await getPlanListByPattern(reqPlan) as ResultData<Plan.ReqPlan[]>
+  planList2.value = result.data || []
+  
+  // 创建计划数据的副本用于过滤处理
+  planList.value = JSON.parse(JSON.stringify(planList2.value))
+  
+  // 过滤子计划，只保留 pid 为 '0' 的项目
+  planList.value = planList.value.map((item: any) => {
+    if (item?.children) {
+      item.children = item.children.filter((child: any) => child?.pid === '0')
+    }
+    return item
+  })
+}
 
+// ============================ 生命周期函数 ============================
+/**
+ * 组件挂载前的初始化操作
+ * 1. 初始化计划数据
+ * 2. 设置默认选中的计划
+ * 3. 初始化图表和树组件
+ * 4. 根据模式加载额外数据
+ */
+onBeforeMount(async () => {
+  // 初始化计划数据
+  await initPlan()
+  
+  // 找到第一个有子计划的项目，并设置为默认选中
+  if (planList.value?.length) {
+    for (let i = 0; i < planList.value.length; i++) {
+      const children = planList.value[i]?.children
+      if (Array.isArray(children) && children.length > 0) {
+        currentId.value = children[0]?.id // 选中第一个子计划
+        break // 确保只选中一个
+      }
+    }
+  }
+
+  // 初始化图表尺寸监听器
   if (chartsInfoRef.value) {
     resizeObserver.observe(chartsInfoRef.value)
   }
-  getTree(planList.value.data)
-
+  
+  // 初始化树组件和饼图数据
+  getTree(planList.value || [])
   getPieData(currentId.value)
+
+  // 如果不是比对模式，直接返回
+  if (modeStore.currentMode != '比对式')
+    return
+    
+  // 比对模式下加载额外的计划表格数据
+  const patternId2 = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id
+  if (patternId2 !== undefined) {
+    planTable.value = await getPlanList({ 'patternId': patternId2 } )
+  }
 })
 
-onUnmounted(() => {
+/**
+ * 组件卸载时的清理操作
+ * 移除尺寸监听器，防止内存泄漏
+ */
+onUnmounted(async () => {
   if (chartsInfoRef.value) {
     resizeObserver.unobserve(chartsInfoRef.value)
   }
 })
 
+/**
+ * 处理批量操作完成后的数据更新
+ * 更新计划数据、树状态和饼图，表格会通过watch自动更新
+ */
 const handleBatchGenerate = async () => {
- // console.log('批量生成按钮被点击了');
-  // 在这里添加其他逻辑，比如显示对话框、更新状态等
+  // 重新获取计划数据
   await initPlan()
-  treeRef.value.clickTableToTree(planList.value.data,currentId.value)
+  // 更新树的选中状态
+  treeRef.value.clickTableToTree(planList.value || [], currentId.value)
+  // 重新获取饼图数据，deviceData更新后watch会自动触发表格更新
   getPieData(currentId.value)
- 
-  if (form.value.activeTabs === 0)//设备检测
-      {
-        const tabledata = deviceData.filter((item) => item.document_State === '未归档')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      } else if (form.value.activeTabs === 4)//设备归档
-      {
-        const tabledata = deviceData.filter((item) => item.check_State === '检测完成' && item.document_State === '未归档')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      } else if (form.value.activeTabs === 3 || form.value.activeTabs === 5)//报告生成、数据查询
-      {
-        const tabledata = deviceData.filter((item) => item.check_State === '检测完成')
-        tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs, form.value.activeChildTabs, tabledata)
-      }
 
-};
+  // 批量操作后的表格刷新 - 这个调用与watch监听器无关，是通过emit触发的
+  tableRef1.value && tableRef1.value.changeActiveTabs(form.value.activeTabs)
+}
 </script>
 <style lang='scss' scoped>
 
@@ -646,7 +781,7 @@ const handleBatchGenerate = async () => {
         justify-content: space-between;
         padding: 0 15px;
         font-weight: bold;
-        width: 100%;
+        width: 99%;
         font-size: 14px;
       }
 
@@ -686,7 +821,6 @@ const handleBatchGenerate = async () => {
     }
 
 
-
     .tabs-menu {
       height: 100%;
       border: 0;
@@ -727,6 +861,4 @@ const handleBatchGenerate = async () => {
 }
 
 
-
-
 </style>

frontend/src/views/home/tabs/model.vue

@@ -53,6 +53,7 @@ import { useAuthStore } from "@/stores/modules/auth";
 import { useModeStore, useAppSceneStore } from "@/stores/modules/mode"; // 引入模式 store
 import { ref } from "vue";
 import {getCurrentScene} from "@/api/user/login";
+
 const authStore = useAuthStore();
 const modeStore = useModeStore(); // 使用模式 store
 const AppSceneStore = useAppSceneStore();
@@ -78,7 +79,7 @@ const modeList = [
     code: "比对式",
     subName: "启用比对式检测计划",
     img: new URL('/src/assets/images/dashboard/3.svg', import.meta.url).href,
-    isActive: false,
+    isActive: true,
   },
 ];
 const handelOpen = async (item: any) => {
@@ -87,6 +88,7 @@ const handelOpen = async (item: any) => {
   // AppSceneStore.setCurrentMode(scene+'');//0：省级平台，1：设备出厂，2：研发自测
   AppSceneStore.setCurrentMode(scene+'');//0：省级平台，1：设备出厂，2：研发自测
   await authStore.setShowMenu();
+  await authStore.getAuthMenuList();
   return;
   // if (isActive) {
   //   router.push({ path: "/static" });

frontend/src/views/log/index.vue

@@ -1,33 +1,23 @@
 <template>
-  <div class='table-box'>
-    <ProTable
-        ref='proTable'
-        :columns='columns'
-        :request-api='getTableList'
-    >
-      <!-- 表格 header 按钮 -->
-      <template #tableHeader>
-        <el-button type='primary' :icon='DataAnalysis'>分析</el-button>
-        <el-button type='primary' :icon='Upload' @click='handleExport'>导出csv</el-button>
-      </template>
-    </ProTable>
-
-
-  </div>
-
+    <div class="table-box">
+        <ProTable ref="proTable" :columns="columns" :request-api="getTableList">
+            <!-- 表格 header 按钮 -->
+            <template #tableHeader>
+                <el-button type="primary" :icon="DataAnalysis">分析</el-button>
+                <el-button type="primary" :icon="Upload" @click="handleExport">导出csv</el-button>
+            </template>
+        </ProTable>
+    </div>
 </template>
-<script setup lang='tsx' name='useProTable'>
+<script setup lang="tsx" name="useProTable">
 // 根据实际路径调整
 import TimeControl from '@/components/TimeControl/index.vue'
-import {type  AuditLog} from '@/api/system/log/interface/log.ts'
 import ProTable from '@/components/ProTable/index.vue'
-import {DataAnalysis, Upload} from '@element-plus/icons-vue'
-import type {ColumnProps, ProTableInstance} from '@/components/ProTable/interface'
-import {reactive, ref} from 'vue'
-import {getAuditLog, exportCsv} from '@/api/system/log/index.ts'
-import {useDownload} from "@/hooks/useDownload";
-import {exportPqDev} from "@/api/device/device";
-
+import { DataAnalysis, Upload } from '@element-plus/icons-vue'
+import type { ColumnProps, ProTableInstance } from '@/components/ProTable/interface'
+import { reactive, ref } from 'vue'
+import { exportCsv, getAuditLog } from '@/api/system/log'
+import { useDownload } from '@/hooks/useDownload'
 
 // defineOptions({
 // name: 'log'
@@ -39,94 +29,92 @@ const endDate = ref('')
 const proTable = ref<ProTableInstance>()
 
 const getTableList = async (params: any) => {
-  let newParams = JSON.parse(JSON.stringify(params))
-  newParams.searchEndTime = endDate.value
-  newParams.searchBeginTime = startDate.value
-  return getAuditLog(newParams)
+    let newParams = JSON.parse(JSON.stringify(params))
+    newParams.searchEndTime = endDate.value
+    newParams.searchBeginTime = startDate.value
+    return getAuditLog(newParams)
 }
 
-
 // 表格配置项
-const columns = reactive<ColumnProps<AuditLog.ReqAuditLogParams>[]>([
-  {type: 'selection', fixed: 'left', width: 70},
-  {type: 'index', fixed: 'left', width: 70, label: '序号'},
-  {
-    prop: 'userName',
-    label: '操作用户',
-    search: {el: 'input'},
-    minWidth: 100,
-  },
-  {
-    prop: 'ip',
-    label: 'IP',
-    minWidth: 120,
-  },
-  {
-    prop: 'logTime',
-    label: '记录时间',
-    minWidth: 180,
-    search: {
-      render: () => {
-        return (
-            <div class='flx-flex-start'>
-              <TimeControl
-                  include={['日', '周', '月', '自定义']}
-                  default={'月'}
-                  onUpdate-dates={handleDateChange}
-              />
-            </div>
-        )
-      },
+const columns = reactive<ColumnProps[]>([
+    { type: 'selection', fixed: 'left', width: 70 },
+    { type: 'index', fixed: 'left', width: 70, label: '序号' },
+    {
+        prop: 'userName',
+        label: '操作用户',
+        search: { el: 'input' },
+        minWidth: 100
     },
-  },
-  {
-    label: '事件描述',
-    minWidth: 450,
-    render: (scope) => {
-      return (scope.row.userName + '在' + scope.row.logTime + '执行了' + scope.row.operateType + scope.row.operate + '操作，结果为' + scope.row.result + '。')
+    {
+        prop: 'ip',
+        label: 'IP',
+        minWidth: 120
+    },
+    {
+        prop: 'logTime',
+        label: '记录时间',
+        minWidth: 180,
+        search: {
+            render: () => {
+                return (
+                    <div class="flx-flex-start">
+                        <TimeControl
+                            include={['日', '周', '月', '自定义']}
+                            default={'月'}
+                            onUpdate-dates={handleDateChange}
+                        />
+                    </div>
+                )
+            }
+        }
+    },
+    {
+        label: '事件描述',
+        minWidth: 450,
+        render(scope) {
+            return `${scope.row.userName}在${scope.row.logTime}执行了【${scope.row.operateType}】${scope.row.operate}操作，结果为${scope.row.result}。`
+        }
+    },
+    {
+        prop: 'result',
+        label: '事件结果',
+        minWidth: 120
+    },
+    {
+        prop: 'warn',
+        label: '告警标志',
+        minWidth: 100,
+        render: scope => {
+            return (
+                <el-tag type={scope.row.warn == 1 ? 'danger' : 'success'}>
+                    {scope.row.warn == 1 ? '已告警' : '未告警'}
+                </el-tag>
+            )
+        }
+    },
+    {
+        prop: 'operateType',
+        label: '日志类型',
+        width: 100
     }
-  },
-  {
-    prop: 'result',
-    label: '事件结果',
-    minWidth: 120,
-  },
-  {
-    prop: 'warn',
-    label: '告警标志',
-    minWidth: 100,
-    render: scope => {
-      return (
-          <el-tag type={scope.row.warn == 1 ? 'danger' : 'success'}>{scope.row.warn == 1 ? '已告警' : '未告警'}</el-tag>
-      )
-    },
-  },
-  {
-    prop: 'operateType',
-    label: '日志类型',
-    width: 100,
-  },
 ])
 
 // 处理日期变化的回调函数
 const handleDateChange = (startDateTemp: string, endDateTemp: string) => {
-  startDate.value = startDateTemp
-  endDate.value = endDateTemp
+    startDate.value = startDateTemp
+    endDate.value = endDateTemp
 }
 
 const handleExport = () => {
-  // 获取当前的搜索参数
-  let searchParam = proTable.value?.searchParam || {}
+    // 获取当前的搜索参数
+    let searchParam = proTable.value?.searchParam || {}
 
-  // 将开始时间和结束时间添加到搜索参数中
-  searchParam.searchBeginTime = startDate.value
-  searchParam.searchEndTime = endDate.value
+    // 将开始时间和结束时间添加到搜索参数中
+    searchParam.searchBeginTime = startDate.value
+    searchParam.searchEndTime = endDate.value
 
-  useDownload(exportCsv, '日志列表', searchParam, false, '.csv')
+    useDownload(exportCsv, '日志列表', searchParam, false, '.csv')
 }
-
 </script>
 
-<style scoped>
-
-</style>
+<style scoped></style>

frontend/src/views/machine/controlSource/components/controlSourceDetail.vue

@@ -230,6 +230,7 @@ import { scriptDtlsCheckDataList } from '@/api/device/testScript/index'
 import ViewRow from '@/views/machine/testScript/components/viewRow.vue'
 import { startSimulateTest, closeSimulateTest } from '@/api/device/controlSource/index.ts'
 import { controlSource } from '@/api/device/interface/controlSource'
+import {JwtUtil} from "@/utils/jwtUtil";
 interface TabOption {
     label?: string
     name?: string
@@ -464,7 +465,7 @@ const startLoading = async () => {
     emit('update:pauseDisabled', true)
     ElMessage.success({ message: '启动中...', duration: 6000 })
     // 启动加载逻辑
-    controlContent.value.userPageId = 'cdf'
+    controlContent.value.userPageId = JwtUtil.getLoginName()
     controlContent.value.scriptId = props.formControl.scriptId
     controlContent.value.scriptIndex = childActiveIndex.value
     controlContent.value.sourceId = props.formControl.sourceId
@@ -476,7 +477,7 @@ const startLoading = async () => {
 // 定义 startLoading 方法
 const stopLoading = async () => {
     // 启动加载逻辑
-    controlContent.value.userPageId = 'cdf'
+    controlContent.value.userPageId = JwtUtil.getLoginName()
     controlContent.value.scriptId = props.formControl.scriptId
     controlContent.value.scriptIndex = childActiveIndex.value
     controlContent.value.sourceId = props.formControl.sourceId

frontend/src/views/machine/controlSource/components/tree.vue

@@ -1,166 +1,165 @@
-<template>
-    <el-tree
-        node-key="id"
-        default-expand-all
-        :data="props.treeData"
-        :props="defaultProps"
-        style="width: 100%"
-        :expand-on-click-node="false"
-        :highlight-current="true"
-        @node-click="handleNodeClick"
-        show-checkbox
-        :check-strictly="true"
-        @check-change="handleCheckChange"
-        ref="treeRef"
-    >
-        <template #default="{ node, data }">
-            <el-tooltip effect="dark" :content="data.sourceDesc || data.scriptTypeName" placement="top" :hide-after="0">
-                <div class="custom-tree-node">
-                    {{ data.scriptTypeName || data.sourceDesc }}
-                </div>
-            </el-tooltip>
-        </template>
-    </el-tree>
-</template>
-<script setup lang="ts">
-import { ref, reactive, onMounted, watch, nextTick } from 'vue'
-
-import { CheckData } from '@/api/check/interface'
-import { da } from 'element-plus/es/locale'
-import { on } from 'events'
-const props = defineProps({
-    treeData: {
-        type: Array,
-        required: true
-    }
-
-})
-const emit = defineEmits(['setTab'])
-const dataTree = ref<CheckData.TreeItem[]>([])
-const defaultProps = {
-    children: 'children',
-    label: 'scriptTypeName',
-    pid: 'pid'
-}
-const activeName = ref('')
-const childActiveName = ref('')
-const activeIndex = ref()
-const treeRef = ref()
-const handleNodeClick = (data, node) => {
-  if(data.index!= null){
-    let code = ['Base', 'VOL', 'Freq', 'Harm', 'Base_0_10', 'Base_20_85', 'Base_110_200']
-    const parents = getParentNodes(node, [])
-    parents.pop()
-    parents.unshift(node.data)
-    parents.reverse()
-    let active = parents[0].scriptTypeCode
-    let childActive = findTargetCodes(parents, code)[0] || ''
-    // 获取当前节点的直接父节点
-    if (activeName.value != active || childActiveName.value != childActive || activeIndex.value != data.index) {
-      activeName.value = active
-      childActiveName.value = childActive
-      emit('setTab', {
-        activeName: active,
-        childActiveName: childActive,
-        activeIndex:data.index
-      })
-    }
-
-      
-  }
-}
-
-// 返回父级
-const getParentNodes = (node, parents) => {
-    if (node.parent) {
-        // 将父节点添加到数组中
-        parents.push(node.parent.data)
-        // 递归获取更高层级的父节点
-        getParentNodes(node.parent, parents)
-    }
-    return parents
-}
-// 判断childActiveName值
-function findTargetCodes(data: any[], targetCodes: string[]) {
-    let result: string[] = []
-    data.forEach(item => {
-        if (item.scriptTypeCode != null) {
-            if (targetCodes.includes(item.scriptTypeCode)) {
-                result.push(item.scriptTypeCode)
-            }
-        }
-    })
-    return result
-    // for (let item of data) {
-    //     // 判断当前项的 scriptTypeCode 是否包含目标值
-    //     if (item.scriptTypeCode !=null && targetCodes.includes(item.scriptTypeCode)) {
-    //         console.log("🚀 ~ findTargetCodes ~ targetCodes.includes(item.scriptTypeCode):",item.scriptTypeCode, targetCodes.includes(item.scriptTypeCode))
-    //         result.push(item.scriptTypeCode)
-    //         return result
-    //     }
-    //     // 如果存在 children，递归检查
-    //     if (item.children && item.children.length > 0) {
-    //         result = result.concat(findTargetCodes(item.children, targetCodes))
-    //     }
-    // }
-    // return result
-}
-
-function handleCheckChange(data,isChecked) {
-    if (isChecked) 
-    {
-        // 如果没有子节点，允许勾选
-        const checked = [data.id]; // id为tree的node-key属性
-        treeRef.value?.setCheckedKeys(checked);
-        emit('setTab', {
-            activeName: data.scriptType,
-            childActiveName: data.scriptTypeCode,
-            activeIndex:data.index
-        })
-    }
-} 
-
-
-// 递归查找第一个节点的最后一层子节点
-function findFirstLeafNode(node: any): any {
-    if (node.children && node.children.length > 0) {
-        return findFirstLeafNode(node.children[0]);
-    }
-    return node;
-}
-
-const checkTree = () => {
-    console.log('checkTree11')
-    console.log('checkTree22',props.treeData.length)
-    console.log('checkTree33',treeRef.value)
-    if (props.treeData.length > 0 && treeRef.value) {
-        console.log('checkTree44')
-        const firstNode = props.treeData[0];
-        const firstLeafNode = findFirstLeafNode(firstNode);
-        const firstLeafNodeId = firstLeafNode.id;
-        treeRef.value.setCheckedKeys([firstLeafNodeId]);
-    }
-}
-
-// 确保在组件挂载后也执行一次
-onMounted(() => {
-    console.log('onMounted',props.treeData);
-    nextTick(() => {
-        checkTree()
-    });
-});
-
-
-
-
-// // 对外映射
- defineExpose({ checkTree })
-</script>
-<style lang="scss" scoped>
-.custom-tree-node {
-    max-width: 230px;
-    overflow-x: hidden !important;
-    white-space: nowrap !important;
-    text-overflow: ellipsis !important;
-}
-</style>
+<template>
+    <el-tree
+        node-key="id"
+        default-expand-all
+        :data="props.treeData"
+        :props="defaultProps"
+        style="width: 100%"
+        :expand-on-click-node="false"
+        :highlight-current="true"
+        @node-click="handleNodeClick"
+        show-checkbox
+        :check-strictly="true"
+        @check-change="handleCheckChange"
+        ref="treeRef"
+    >
+        <template #default="{ node, data }">
+            <el-tooltip effect="dark" :content="data.sourceDesc || data.scriptTypeName" placement="top" :hide-after="0">
+                <div class="custom-tree-node">
+                    {{ data.scriptTypeName || data.sourceDesc }}
+                </div>
+            </el-tooltip>
+        </template>
+    </el-tree>
+</template>
+<script setup lang="ts">
+import { ref, reactive, onMounted, watch, nextTick } from 'vue'
+
+import { CheckData } from '@/api/check/interface'
+import { da } from 'element-plus/es/locale'
+import { on } from 'events'
+const props = defineProps({
+    treeData: {
+        type: Array,
+        required: true
+    }
+
+})
+const emit = defineEmits(['setTab'])
+const dataTree = ref<CheckData.TreeItem[]>([])
+const defaultProps = {
+    children: 'children',
+    label: 'scriptTypeName',
+    pid: 'pid'
+}
+const activeName = ref('')
+const childActiveName = ref('')
+const activeIndex = ref()
+const treeRef = ref()
+const handleNodeClick = (data, node) => {
+  if(data.index!= null){
+    let code = ['Base', 'VOL', 'Freq', 'Harm', 'Base_0_10', 'Base_20_85', 'Base_110_200']
+    const parents = getParentNodes(node, [])
+    parents.pop()
+    parents.unshift(node.data)
+    parents.reverse()
+    let active = parents[0].scriptTypeCode
+    let childActive = findTargetCodes(parents, code)[0] || ''
+    // 获取当前节点的直接父节点
+    if (activeName.value != active || childActiveName.value != childActive || activeIndex.value != data.index) {
+      activeName.value = active
+      childActiveName.value = childActive
+      emit('setTab', {
+        activeName: active,
+        childActiveName: childActive,
+        activeIndex:data.index
+      })
+    }
+
+      
+  }
+}
+
+// 返回父级
+const getParentNodes = (node, parents) => {
+    if (node.parent) {
+        // 将父节点添加到数组中
+        parents.push(node.parent.data)
+        // 递归获取更高层级的父节点
+        getParentNodes(node.parent, parents)
+    }
+    return parents
+}
+// 判断childActiveName值
+function findTargetCodes(data: any[], targetCodes: string[]) {
+    let result: string[] = []
+    data.forEach(item => {
+        if (item.scriptTypeCode != null) {
+            if (targetCodes.includes(item.scriptTypeCode)) {
+                result.push(item.scriptTypeCode)
+            }
+        }
+    })
+    return result
+    // for (let item of data) {
+    //     // 判断当前项的 scriptTypeCode 是否包含目标值
+    //     if (item.scriptTypeCode !=null && targetCodes.includes(item.scriptTypeCode)) {
+    //         result.push(item.scriptTypeCode)
+    //         return result
+    //     }
+    //     // 如果存在 children，递归检查
+    //     if (item.children && item.children.length > 0) {
+    //         result = result.concat(findTargetCodes(item.children, targetCodes))
+    //     }
+    // }
+    // return result
+}
+
+function handleCheckChange(data,isChecked) {
+    if (isChecked) 
+    {
+        // 如果没有子节点，允许勾选
+        const checked = [data.id]; // id为tree的node-key属性
+        treeRef.value?.setCheckedKeys(checked);
+        emit('setTab', {
+            activeName: data.scriptType,
+            childActiveName: data.scriptTypeCode,
+            activeIndex:data.index
+        })
+    }
+} 
+
+
+// 递归查找第一个节点的最后一层子节点
+function findFirstLeafNode(node: any): any {
+    if (node.children && node.children.length > 0) {
+        return findFirstLeafNode(node.children[0]);
+    }
+    return node;
+}
+
+const checkTree = () => {
+    console.log('checkTree11')
+    console.log('checkTree22',props.treeData.length)
+    console.log('checkTree33',treeRef.value)
+    if (props.treeData.length > 0 && treeRef.value) {
+        console.log('checkTree44')
+        const firstNode = props.treeData[0];
+        const firstLeafNode = findFirstLeafNode(firstNode);
+        const firstLeafNodeId = firstLeafNode.id;
+        treeRef.value.setCheckedKeys([firstLeafNodeId]);
+    }
+}
+
+// 确保在组件挂载后也执行一次
+onMounted(() => {
+    console.log('onMounted',props.treeData);
+    nextTick(() => {
+        checkTree()
+    });
+});
+
+
+
+
+// // 对外映射
+ defineExpose({ checkTree })
+</script>
+<style lang="scss" scoped>
+.custom-tree-node {
+    max-width: 230px;
+    overflow-x: hidden !important;
+    white-space: nowrap !important;
+    text-overflow: ellipsis !important;
+}
+</style>

frontend/src/views/machine/controlSource/index.vue

@@ -67,6 +67,7 @@ import socketClient from '@/utils/webSocketClient'
 import { checkSimulate } from '@/api/device/controlSource/index.ts'
 import { controlSource } from '@/api/device/interface/controlSource'
 import {getPqScriptList} from '@/api/plan/plan.ts'
+import {JwtUtil} from "@/utils/jwtUtil";
 
 const show = ref(false)
 const router = useRouter()
@@ -322,7 +323,7 @@ const handleScriptChange = (value: string) => {
 }
 const start = async () => {
  
-  controlContent.value.userPageId = 'cdf'
+  controlContent.value.userPageId = JwtUtil.getLoginName()
   controlContent.value.scriptIndex = scriptIndex.value
   await checkSimulate(controlContent.value)
 }

frontend/src/views/machine/devType/components/devTypePopup.vue

@@ -1,6 +1,6 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogMiddle" @close="close" >
+  <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogMiddle" @close="close" align-center>
     <div>
         <el-form :model="formContent"  ref='dialogFormRef' :rules='rules' class="form-two">
             <el-form-item label="名称" prop="name" >
@@ -66,6 +66,9 @@
                     />
                 </el-select>
             </el-form-item>
+             <el-form-item label="录波指令" prop="waveCmd" v-if="modeStore.currentMode == '比对式'">
+                <el-input v-model='formContent.waveCmd' placeholder="请输入录波指令" maxlength="32" show-word-limit/>
+            </el-form-item>
       </el-form>
       </div>
     <template #footer>
@@ -90,7 +93,9 @@
   import { useDictStore } from '@/stores/modules/dict'
   import {addDevType,updateDevType} from '@/api/device/devType'
   import {getICDAllList} from '@/api/device/icd'
+  import { useModeStore } from '@/stores/modules/mode'
   const dictStore = useDictStore()
+  const modeStore = useModeStore()
   // 定义弹出组件元信息
   const dialogFormRef = ref()
   const scene = ref('')
@@ -108,6 +113,7 @@
         devChns: 1,  //设备通道数
         reportName: '',//报告模版名称
         state: 1,
+        waveCmd: 'RDRE1$CO$RcdTrg$Oper',
     })
     return { dialogVisible, titleType, formContent }
   }
@@ -127,6 +133,7 @@ const resetFormContent = () => {
         devChns: 1,  //设备通道数
         reportName: '',//报告模版名称
         state: 1,
+        waveCmd: 'RDRE1$CO$RcdTrg$Oper',
     }
   }
   

frontend/src/views/machine/device/components/monitorPopup.vue

@@ -0,0 +1,264 @@
+<template>
+    <!-- 基础信息弹出框 -->
+    <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogMiddle" @close="close" align-center>
+        <div>
+            <el-form :model="formContent" ref="dialogFormRef" :rules="rules" class="form-two">
+                <el-form-item label="名称" prop="name">
+                    <el-input v-model="formContent.name" placeholder="请输入监测点名称" />
+                </el-form-item>
+                <el-form-item label="线路号" prop="num">
+                    <el-select
+                        v-model="formContent.num"
+                        clearable
+                        placeholder="请选择线路号"
+                        @change="handleMonNumChange"
+                    >
+                        <el-option v-for="item in lineNum" :key="item.id" :label="item.name" :value="item.id" />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="所属母线" prop="busbar">
+                    <el-select
+                        v-model="formContent.busbar"
+                        clearable
+                        placeholder="请选择所属母线"
+                        filterable
+                        allow-create
+                    >
+                        <el-option
+                            v-for="item in selectOptions['busbar']"
+                            :key="item.value"
+                            :label="item.label"
+                            :value="item.value"
+                        />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="PT变比" prop="pt">
+                    <el-select v-model="formContent.pt" clearable placeholder="请选择PT变比" filterable allow-create>
+                        <el-option
+                            v-for="item in selectOptions['pt']"
+                            :key="item.value"
+                            :label="item.label"
+                            :value="item.value"
+                        />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="CT变比" prop="ct">
+                    <el-select v-model="formContent.ct" clearable placeholder="请选择CT变比" filterable allow-create>
+                        <el-option
+                            v-for="item in selectOptions['ct']"
+                            :key="item.value"
+                            :label="item.label"
+                            :value="item.value"
+                        />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="接线方式" prop="connection">
+                    <el-select v-model="formContent.connection" clearable placeholder="请选择接线方式">
+                        <el-option
+                            v-for="item in dictStore.getDictData('Dev_Connect')"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.id"
+                        />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="统计间隔" prop="statInterval">
+                    <el-select v-model="formContent.statInterval" clearable placeholder="请选择统计间隔">
+                        <el-option
+                            v-for="item in dictStore.getDictData('Dev_Chns')"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.code"
+                        />
+                    </el-select>
+                </el-form-item>
+                <el-form-item label="谐波系统检测点id" prop="harmSysId" placeholder="请输入谐波系统检测点id">
+                    <el-input v-model="formContent.harmSysId" />
+                </el-form-item>
+                <el-form-item label="是否参与检测" prop="checkFlag" placeholder="请输入CT编号">
+                    <el-select v-model="formContent.checkFlag" clearable placeholder="请选择是否加密">
+                        <el-option label="是" :value="1"></el-option>
+                        <el-option label="否" :value="0"></el-option>
+                    </el-select>
+                </el-form-item>
+            </el-form>
+        </div>
+        <template #footer>
+            <div class="dialog-footer">
+                <el-button @click="close()">取消</el-button>
+                <el-button type="primary" @click="save()">保存</el-button>
+            </div>
+        </template>
+    </el-dialog>
+</template>
+
+<script lang="ts" setup>
+import { ElMessage, type FormItemRule } from 'element-plus'
+import { computed, ref, Ref } from 'vue'
+import { type Monitor } from '@/api/device/interface/monitor'
+import { dialogMiddle } from '@/utils/elementBind'
+import { useDictStore } from '@/stores/modules/dict'
+import { generateUUID } from '@/utils'
+import { Device } from '@/api/device/interface/device'
+
+const dictStore = useDictStore()
+const lineNum = ref<{ id: number; name: string }[]>([])
+const originalNum = ref<number | null>(null) // 存储编辑前的 num 值
+const monitorTable = ref<any[]>()
+const selectOptions = ref<Record<string, Device.SelectOption[]>>({})
+// 定义弹出组件元信息
+const dialogFormRef = ref()
+function useMetaInfo() {
+    const dialogVisible = ref(false)
+    const titleType = ref('add')
+    const formContent = ref<Monitor.ResPqMon>({
+        id: '',
+        devId: '',
+        busbar: '',
+        name: '',
+        num: 1,
+        pt: '',
+        ct: '',
+        connection: '',
+        statInterval: 1,
+        harmSysId: '',
+        checkFlag: 1
+    })
+    return { dialogVisible, titleType, formContent }
+}
+
+const { dialogVisible, titleType, formContent } = useMetaInfo()
+
+const emit = defineEmits(['get-parameter'])
+// 清空formContent
+const resetFormContent = () => {
+    formContent.value = {
+        id: '',
+        devId: '',
+        busbar: '',
+        name: '',
+        num: 1,
+        pt: '',
+        ct: '',
+        connection: '',
+        statInterval: 1,
+        harmSysId: '',
+        checkFlag: 1
+    }
+}
+
+let dialogTitle = computed(() => {
+    return titleType.value === 'add' ? '新增监测点台账' : '编辑监测点台账'
+})
+
+// 关闭弹窗
+const close = () => {
+    dialogVisible.value = false
+}
+
+//定义校验规则
+const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
+    name: [{ required: true, message: '监测点名称必填！', trigger: 'blur' }],
+    num: [{ required: true, message: '线路号必选', trigger: 'change' }],
+    pt: [
+        { required: true, message: 'PT变比必选！', trigger: 'blur' },
+        { pattern: /^[1-9]\d*:[1-9]\d*$/, message: 'PT变比格式应为 n:n 形式，例如 1:1', trigger: 'change' }
+    ],
+    ct: [
+        { required: true, message: 'CT变比必选！', trigger: 'blur' },
+        { pattern: /^[1-9]\d*:[1-9]\d*$/, message: 'CT变比格式应为 n:n 形式，例如 1:1', trigger: 'change' }
+    ],
+    connection: [{ required: true, message: '接线方式必选！', trigger: 'change' }],
+    busbar: [{ required: true, message: '所属母线必选！', trigger: 'change' }],
+    // harmSysId : [{ required: true, message: '谐波系统检测点id必填！', trigger: 'blur' }],
+    checkFlag: [{ required: true, message: '是否参与检测必选！', trigger: 'change' }]
+})
+
+// 保存数据
+const save = () => {
+    try {
+        dialogFormRef.value?.validate(async (valid: boolean) => {
+            if (valid) {
+                // 校验名称是否重复
+                const isNameDuplicate = monitorTable.value.some(
+                    item => item.name === formContent.value.name && item.id !== formContent.value.id
+                )
+                if (isNameDuplicate) {
+                    ElMessage.error({ message: '监测点名称已存在，请重新输入！' })
+                    return
+                }
+
+                if (titleType.value != 'edit') {
+                    formContent.value.id = generateUUID().replaceAll('-', '')
+                }
+                emit('get-parameter', formContent.value)
+                //ElMessage.success({ message: `${dialogTitle.value}成功！` })
+                close()
+            }
+        })
+    } catch (err) {
+        console.error('验证过程中出现错误', err)
+    }
+}
+
+// 打开弹窗，可能是新增，也可能是编辑
+const open = async (sign: string, data: Monitor.ResPqMon, device: Device.ResPqDev, table: any[], options: any) => {
+    // 重置表单
+    //dialogFormRef.value?.resetFields()
+    selectOptions.value = options
+    titleType.value = sign
+    dialogVisible.value = true
+    monitorTable.value = table || []
+    // 提取 table 中已使用的 num（安全处理）
+    const usedNums = new Set<number>()
+    if (table && table.length > 0) {
+        table.forEach(item => {
+            if (item.num != null) {
+                usedNums.add(Number(item.num))
+            }
+        })
+    }
+
+    lineNum.value = Array.from({ length: device.devChns }, (_, i) => {
+        const id = i + 1
+        return {
+            id,
+            name: id.toString()
+        }
+    }).filter(item => !usedNums.has(item.id)) // 过滤掉已被使用的线路号
+
+    if (sign == 'edit') {
+        formContent.value = { ...data }
+        originalNum.value = data.num // 记录原始线路号
+    } else {
+        resetFormContent()
+        originalNum.value = null
+        // 设置默认选中第一个线路号
+        if (lineNum.value.length > 0) {
+            formContent.value.num = lineNum.value[0].id
+        }
+    }
+    formContent.value.devId = device.id
+}
+
+const handleMonNumChange = (value: string) => {
+    const newValue = parseInt(value)
+    if (originalNum.value && originalNum.value !== newValue) {
+        // 将原来的 num 添加回 lineNum（表示释放）
+        lineNum.value.push({
+            id: originalNum.value,
+            name: originalNum.value.toString()
+        })
+        //移除新选择的 num（因为已被占用）
+        lineNum.value = lineNum.value.filter(item => item.id !== newValue).sort((a, b) => a.id - b.id)
+
+        // 更新 originalNum 为最新值，以便下次修改
+        originalNum.value = newValue
+    }
+}
+
+// 对外映射
+defineExpose({ open })
+</script>
+
+<style scoped></style>

frontend/src/views/machine/device/components/monitorTab.vue

@@ -1,78 +1,199 @@
 <!-- components/MonitorPointTable.vue -->
 <template>
-    <el-tab-pane label="监测点台账信息" v-if="MonIsShow">
-      <div class='table-box' ref='popupBaseView'>
+      <div class='table-box'>
         <ProTable
           ref='proTable'
+          :pagination="false"
+          :toolButton="false"
           :columns='columns'
-          :style="{ height: '326px',maxHeight: '400px',overflow:'hidden'}"
+          :data="tableData"
+          :style="{ height: tableHeight + 'px',overflow:'hidden'}"
         >
           <!-- 表格 header 按钮 -->
           <template #tableHeader='scope'>
-            <el-button type='primary' :icon='CirclePlus'>新增</el-button>
-            <el-button type='danger' :icon='Delete' plain :disabled='!scope.isSelected'>删除</el-button>
+            <el-button type='primary' :icon='CirclePlus' @click="openDialog('add')" :disabled="props.DevFormContent.importFlag == 1">新增</el-button>
+            <el-button v-auth.device="'delete'" type='danger' :icon='Delete' plain :disabled='!scope.isSelected'
+                     @click='batchDelete(scope.selectedListIds)'>
+            删除
+          </el-button>
           </template>
           <!-- 表格操作 -->
-          <template #operation>
-            <el-button type='primary' link :icon='EditPen'>复制</el-button>
-            <el-button type='primary' link :icon='EditPen'>编辑</el-button>
-            <el-button type='primary' link :icon='Delete'>删除</el-button>
+          <template #operation="scope">
+            <el-button v-auth.device="'edit'" type='primary' link :icon='EditPen' :model-value='false' :disabled="props.DevFormContent.importFlag == 1"
+                     @click="openDialog('edit', scope.row)">编辑
+            </el-button>
+            <el-button v-auth.device="'delete'" type='primary' link :icon='Delete' @click='handleDelete(scope.row.id)' >删除
+            </el-button>
           </template>
         </ProTable>
       </div>
-    </el-tab-pane>
+       <MonitorPopup @getParameter="getParameter" ref='monitorPopup'/>
   </template>
   
   <script setup lang="ts">
-    import { ref, defineProps, reactive } from 'vue';
+    import { ref, defineProps, reactive, watch } from 'vue';
     import ProTable from '@/components/ProTable/index.vue'; // 假设 ProTable 是自定义组件
-    import { CirclePlus, Delete, EditPen } from '@element-plus/icons-vue';
-    import { getPqMonList } from '@/api/device/monitor'
-    import { type ColumnProps } from '@/components/ProTable/interface'
+    import { CirclePlus, Delete, EditPen, MessageBox } from '@element-plus/icons-vue';
+    import MonitorPopup from '@/views/machine/device/components/monitorPopup.vue'
+    import { ProTableInstance, type ColumnProps } from '@/components/ProTable/interface'
     import { type Monitor } from '@/api/device/interface/monitor'
+    import { useDictStore } from '@/stores/modules/dict';
+    import { useHandleData } from '@/hooks/useHandleData';
+    import { Device } from '@/api/device/interface/device';
+    import { ElMessage, ElMessageBox } from 'element-plus';
 
   // 定义 props
-const props = defineProps<{
-  MonIsShow: boolean;
-}>();
+  const props = defineProps<{
+    DevFormContent:Device.ResPqDev,
+    tableHeight?: number, // 接收外部传入的高度
+    selectOptions: Record<string, Device.SelectOption[]>,
+  }>();
 
+ // ProTable 实例
+  const proTable = ref<ProTableInstance>()
+  const dictStore = useDictStore()
+  const monitorPopup = ref()
+  const tableData = ref<any[]>([])
+  const title_Type = ref('add')
 
   // 表格配置项
 const columns = reactive<ColumnProps<Monitor.ResPqMon>[]>([
   { type: 'selection', fixed: 'left', width: 70 },
   { type: 'index', fixed: 'left', width: 70, label: '序号' },
+   {
+    prop: 'name',
+    label: '名称',
+    width: 200,
+  },
   {
-    prop: '',
+    prop: 'busbar',
     label: '所属母线',
     width: 200,
   },
   {
-    prop: '',
-    label: '被检通道',
+    prop: 'num',
+    label: '线路号',
     width: 200,
   },
   {
-    prop: '',
+    prop: 'pt',
     label: 'PT变比',
     width: 110,
   },
   {
-    prop: '',
+    prop: 'ct',
     label: 'CT变比',
     width: 130,
   },
   {
-    prop: '',
+    prop: 'connection',
     label: '接线方式',
+    enum: dictStore.getDictData('Dev_Connect'),
+    fieldNames: {label: 'name', value: 'id'},
     width: 130,
-
   },
   {
-    prop: '',
-    label: '谐波系统监测点ID',
-    minWidth: 250,
+    prop: 'statInterval',
+    label: '统计间隔',
+    width: 130,
+  },
+  {
+    prop: 'checkFlag',
+    label: '是否参与检测',
+    render: (scope: any) => {
+      return scope.row.checkFlag === 1 ? '是' : '否'
+    },
+    width: 130,
   },
   { prop: 'operation', label: '操作', fixed: 'right', width: 200 },
 ])
+
+
+const emit = defineEmits(['get-parameter'])
+
+const getParameter = (data: Monitor.ResPqMon) => {
+  console.log('data', data)
+  if (title_Type.value === 'edit') {
+    // 编辑：替换已有的数据
+    const index = tableData.value.findIndex(item => item.id === data.id)
+    if (index > -1) {
+      tableData.value = [
+        ...tableData.value.slice(0, index),
+        data,
+        ...tableData.value.slice(index + 1)
+      ]
+    }
+  } else {
+    // 新增：追加数据
+    tableData.value = [...tableData.value, data]
+    
+  }
+  emit('get-parameter', tableData.value)
+}
+
+
+ // 打开 drawer(新增、编辑)
+  const openDialog =  (titleType: string, row: Partial<Monitor.ResPqMon> = {}) => {
+      if(props.DevFormContent.devType == '' || props.DevFormContent.devType == undefined){
+            ElMessageBox.confirm(
+                  '请先选择被检设备类型',
+                  '提示',
+                  {
+                    confirmButtonText: '确定',
+                    cancelButtonText: '取消',
+                    type: 'warning',
+                  },
+            )
+            return
+      }
+       title_Type.value = titleType
+       monitorPopup.value?.open(titleType, row,props.DevFormContent,tableData.value,props.selectOptions)
+  }
+  
+  
+  // 批量删除监测点台账
+  const batchDelete =  (ids: string[]) => {
+      ElMessageBox.confirm(`是否批量删除监测点?`, "温馨提示", {
+        confirmButtonText: "确定",
+        cancelButtonText: "取消",
+        draggable: true
+      }).then(async () => {
+        tableData.value = tableData.value.filter(item => !ids.includes(item.id));
+        proTable.value?.clearSelection()
+      emit('get-parameter', tableData.value)
+      ElMessage({
+        type: "success",
+        message: `批量删除监测点成功!`
+      });
+  });
+    
+  }
+  
+  // 删除监测点台账
+const handleDelete =  (id: string) => {
+    ElMessageBox.confirm(`是否删除监测点?`, "温馨提示", {
+        confirmButtonText: "确定",
+        cancelButtonText: "取消",
+        draggable: true
+      }).then(async () => {
+         tableData.value = tableData.value.filter(item => item.id !== id)
+         proTable.value?.clearSelection()
+         emit('get-parameter', tableData.value)
+      ElMessage({
+        type: "success",
+        message: `删除监测点成功!`
+      });
+  });
+}
+
+
+watch(
+  () => props.DevFormContent.monitorList,
+  (newVal) => {
+    tableData.value = newVal|| []
+  },
+  { immediate: true }
+)
+
   </script>
   

frontend/src/views/machine/device/index.vue

@@ -50,7 +50,7 @@ import {type ColumnProps, type ProTableInstance} from '@/components/ProTable/int
 import DevicePopup from '@/views/machine/device/components/devicePopup.vue'
 import {CirclePlus, Delete, Download, EditPen, Upload} from '@element-plus/icons-vue'
 import {useDictStore} from '@/stores/modules/dict'
-import {deletePqDev, downloadTemplate, exportPqDev, getPqDev, getPqDevList, importPqDev} from '@/api/device/device/index'
+import {deletePqDev, downloadTemplate, exportPqDev, getPqDev, getPqDevList, importPqDev,getPqDevById} from '@/api/device/device/index'
 import {uploadReportToCloud} from '@/api/device/report/index'
 import {ElMessage, ElMessageBox} from 'element-plus'
 import {onBeforeMount, reactive, ref} from 'vue'
@@ -69,11 +69,10 @@ const boundPqDevList = ref<Device.ReqPqDevParams[]>([])//根据检测计划id查
 // 存储设备类型选项
 const devTypeOptions = ref<Device.ResDev[]>([])
 
-
 const getTableList = async (params: any) => {
   let newParams = JSON.parse(JSON.stringify(params))
-  newParams.searchEndTime = endDate.value
-  newParams.searchBeginTime = startDate.value
+  // newParams.searchEndTime = endDate.value
+  // newParams.searchBeginTime = startDate.value
   const patternId = dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id//获取数据字典中对应的id
   newParams.pattern = patternId
   return getPqDevList(newParams)
@@ -98,62 +97,45 @@ const columns = reactive<ColumnProps<Device.ResPqDev>[]>([
     prop: 'devType',
     label: '设备类型',
     minWidth: 200,
-    render: (scope) => {
-      // 查找设备类型名称
-      const name = devTypeOptions.value.find(option => option.id === scope.row.devType)
-      return <span>{name?.name}</span>
-    },
+
   },
   {
     prop: 'createDate',
-    label: '出厂日期',
+    label: modeStore.currentMode === '比对式' ? '投运日期' : '出厂日期',
     minWidth: 200,
     isShow: appSceneStore.currentScene === '0',
-    ...(appSceneStore.currentScene === '0' ? {
-      search: {
-        render: () => {
-          return (
-              <div class='flx-flex-start'>
-                <TimeControl
-                    default={'月'}
-                    onUpdate-dates={handleDateChange}
-                />
-              </div>
-          )
-        },
-      },
-    } : {}),
-    // search: {
-    //   span: 2,
-    //   render: () => {
-    //     return (
-    //       <div class='flx-flex-start'>
-    //         <TimeControl
-    //           default={'月'}
-    //           onUpdate-dates={handleDateChange}
-    //         />
-    //       </div>
-    //     )
+    // ...(appSceneStore.currentScene === '0' ? {
+    //   search: {
+    //     render: () => {
+    //       return (
+    //           <div class='flx-flex-start'>
+    //             <TimeControl
+    //                 default={'月'}
+    //                 onUpdate-dates={handleDateChange}
+    //             />
+    //           </div>
+    //       )
+    //     },
     //   },
-    // },
+    // } : {}),
   },
   {
     prop: 'devChns',
     label: '通道数',
     minWidth: 110,
-
+    isShow: modeStore.currentMode != '比对式',
   },
   {
     prop: 'devVolt',
     label: '额定电压（V）',
     minWidth: 130,
-
+    isShow: modeStore.currentMode != '比对式',
   },
   {
     prop: 'devCurr',
     label: '额定电流（A）',
     minWidth: 130,
-
+    isShow: modeStore.currentMode != '比对式',
   },
   {
     prop: 'ip',
@@ -171,6 +153,20 @@ const columns = reactive<ColumnProps<Device.ResPqDev>[]>([
     } : {}),
     minWidth: 200,
   },
+  {
+    prop: 'gdName',
+    label: '供电公司',
+    isShow: modeStore.currentMode === '比对式',
+    search: {el: 'input'},
+    minWidth: 200,
+  },
+  {
+    prop: 'subName',
+    label: '变电站',
+    isShow: modeStore.currentMode === '比对式',
+    search: {el: 'input'},
+    minWidth: 200,
+  },
   {
     prop: 'createTime',
     label: '创建时间',
@@ -201,8 +197,14 @@ const handleDateChange = (startDateTemp: string, endDateTemp: string) => {
   endDate.value = endDateTemp
 }
 // 打开 drawer(新增、编辑)
-const openDialog = (titleType: string, row: Partial<Device.ResPqDev> = {}) => {
-  devicePopup.value?.open(titleType, row, modeStore.currentMode, appSceneStore.currentScene, devTypeOptions.value)
+const openDialog = async (titleType: string, row: Partial<Device.ResPqDev> = {}) => {
+    if(titleType === 'add'){
+        devicePopup.value?.open(titleType, row, modeStore.currentMode, appSceneStore.currentScene, devTypeOptions.value)
+    }else{
+      row = await getPqDevById(row)
+       devicePopup.value?.open(titleType, row.data, modeStore.currentMode, appSceneStore.currentScene, devTypeOptions.value)
+    }
+
 }
 
 
@@ -242,35 +244,25 @@ const downloadFile = async () => {
 const deviceImportExcel = ref<InstanceType<typeof ImportExcel> | null>(null)
 
 const importFile = async (pattern: string) => {
-
-  if (pattern === '比对式') {
-    // const params = {
-    //     title: '被检设备',
-    //     showCover: false,
-    //     tempApi: downloadTemplate,
-    //     importApi: importPqDev,
-    //     getTableList: proTable.value?.getTableList,
-    // }
-    // deviceImportExcel.value?.acceptParams(params)
-  } else {
     const params = {
       title: '被检设备',
       showCover: false,
       patternId: dictStore.getDictData('Pattern').find(item => item.name === modeStore.currentMode)?.id,
+      planId: null,
       tempApi: downloadTemplate,
       importApi: importPqDev,
       // importApi: modeStore.currentMode === "比对式"? importContrastPqDev: importCNDev,
       getTableList: proTable.value?.getTableList,
     }
     deviceImportExcel.value?.acceptParams(params)
-  }
+
 
 }
 
 // 报告上传
 const uploadFile = async () => {
   const selectedRows = proTable.value?.selectedList || []
-  
+
   if (selectedRows.length === 0) {
     // 没有选择设备，弹出确认框询问是否处理全部
     ElMessageBox.confirm('未选择被检设备，是否对全部设备进行报告上传？', '提示', {

frontend/src/views/machine/errorSystem/components/errorStandardPopup.vue

@@ -1,6 +1,6 @@
 <template>
 
-  <el-dialog :title="dialogTitle" v-model='dialogVisible' @close="close" v-bind="dialogBig">
+  <el-dialog :title="dialogTitle" v-model='dialogVisible' @close="close" v-bind="dialogBig" align-center>
     <div class="table-container">
       <el-table :data="errorData.value"
                 height="500"

frontend/src/views/machine/errorSystem/components/errorSystemPopup.vue

@@ -1,5 +1,5 @@
 <template>
-    <el-dialog  :title="dialogTitle" v-model='dialogVisible' @close="close" v-bind="dialogBig" width="1660px">
+    <el-dialog  :title="dialogTitle" v-model='dialogVisible' @close="close" v-bind="dialogBig" width="1660px" align-center>
         <el-tabs type="border-card">
             <el-tab-pane label="基础信息">
                 <div>

frontend/src/views/machine/errorSystem/index.vue

@@ -15,10 +15,10 @@
       </template>
        <!-- 表格操作 -->
        <template #operation='scope'>
-          <el-button v-auth.device="'view'" type='primary' link :icon='View' @click="openDialog('view', scope.row)">查看</el-button>
-          <el-button v-auth.device="'view'" type='primary' link :icon='View' @click="copy(scope.row)">复制</el-button>
-          <el-button v-auth.device="'edit'" type='primary' link :icon='EditPen' @click="openDialog('edit', scope.row)">编辑</el-button>
-          <el-button v-auth.device="'delete'" type='primary' link :icon='Delete' @click='handleDelete(scope.row)'>删除</el-button>
+          <el-button v-auth.errorSystem="'view'" type='primary' link :icon='View' @click="openDialog('view', scope.row)">查看</el-button>
+          <el-button v-auth.errorSystem="'view'" type='primary' link :icon='View' @click="copy(scope.row)">复制</el-button>
+          <el-button v-auth.errorSystem="'edit'" type='primary' link :icon='EditPen' @click="openDialog('edit', scope.row)">编辑</el-button>
+          <el-button v-auth.errorSystem="'delete'" type='primary' link :icon='Delete' @click='handleDelete(scope.row)'>删除</el-button>
         </template>
     </ProTable>
   </div>

frontend/src/views/machine/icd/components/icdPopup.vue

@@ -1,79 +1,101 @@
 <template>
     <!-- 基础信息弹出框 -->
-  <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogSmall" @close="close" >
-    <div>
-        <el-form :model="formContent"  ref='dialogFormRef' :rules='rules'>
-            <el-form-item label="名称" prop="name" >
-                <el-input v-model='formContent.name' placeholder="请输入icd名称" maxlength="32" show-word-limit/>
-            </el-form-item>
-            <el-form-item label="存储地址" prop="path" >
-                <el-input v-model='formContent.path' placeholder="请输入icd存储地址" maxlength="32" show-word-limit/>
-            </el-form-item>
-      </el-form>
-      </div>
-    <template #footer>
-      <div class="dialog-footer">
-        <el-button @click="close()">取消</el-button>
-        <el-button type="primary" @click="save()" >
-          保存
-        </el-button>
-      </div>
-    </template>
-  </el-dialog>
+    <el-dialog :model-value="dialogVisible" :title="dialogTitle" v-bind="dialogSmall" @close="close" align-center>
+        <div>
+            <el-form :model="formContent" label-position="right" label-width="80" ref="dialogFormRef" :rules="rules">
+                <el-form-item label="名称" prop="name">
+                    <el-input v-model="formContent.name" placeholder="请输入icd名称" maxlength="32" show-word-limit />
+                </el-form-item>
+                <el-form-item label="存储地址" prop="path">
+                    <el-input
+                        v-model="formContent.path"
+                        placeholder="请输入icd存储地址"
+                        maxlength="32"
+                        show-word-limit
+                    />
+                </el-form-item>
+                <el-form-item label="是否支持电压相角、电流相角指标" prop="angle" label-width="auto">
+                    <el-switch
+                        v-model="formContent.angle"
+                        :active-value="1"
+                        :inactive-value="0"
+                        inline-prompt
+                        active-text="是"
+                        inactive-text="否"
+                    />
+                </el-form-item>
+                <el-form-item label="角型接线时是否使用相别的指标来进行检测" prop="usePhaseIndex" label-width="auto">
+                    <el-switch
+                        v-model="formContent.usePhaseIndex"
+                        :active-value="1"
+                        :inactive-value="0"
+                        inline-prompt
+                        active-text="是"
+                        inactive-text="否"
+                    />
+                </el-form-item>
+            </el-form>
+        </div>
+        <template #footer>
+            <div class="dialog-footer">
+                <el-button @click="close()">取消</el-button>
+                <el-button type="primary" @click="save()">保存</el-button>
+            </div>
+        </template>
+    </el-dialog>
+</template>
 
-  </template>
-  
-  <script lang="ts" setup>
-  import{  ElMessage, type FormInstance,type FormItemRule } from 'element-plus'
-  import type { ProTableInstance } from '@/components/ProTable/interface'
-  import { ref,computed, Ref} from 'vue'
-  import { type ICD } from '@/api/device/interface/icd'
-  import {dialogSmall} from '@/utils/elementBind'
-  import { useDictStore } from '@/stores/modules/dict'
-  import {addICD,updateICD} from '@/api/device/icd'
-  const dictStore = useDictStore()
-  // 定义弹出组件元信息
-  const dialogFormRef = ref()
- function useMetaInfo() {
+<script lang="ts" setup>
+import { ElMessage, type FormInstance, type FormItemRule } from 'element-plus'
+import { computed, ref, Ref } from 'vue'
+import { type ICD } from '@/api/device/interface/icd'
+import { dialogSmall } from '@/utils/elementBind'
+import { useDictStore } from '@/stores/modules/dict'
+import { addICD, updateICD } from '@/api/device/icd'
+
+const dictStore = useDictStore()
+// 定义弹出组件元信息
+const dialogFormRef = ref()
+function useMetaInfo() {
     const dialogVisible = ref(false)
     const titleType = ref('add')
     const formContent = ref<ICD.ResICD>({
-        id: '',    
+        id: '',
         name: '',
         path: '',
         state: 1,
+        angle: 0,
+        usePhaseIndex: 0
     })
     return { dialogVisible, titleType, formContent }
-  }
-  
-  const { dialogVisible, titleType, formContent } = useMetaInfo()
+}
 
+const { dialogVisible, titleType, formContent } = useMetaInfo()
 
 // 清空formContent
 const resetFormContent = () => {
     formContent.value = {
-        id: '',    
+        id: '',
         name: '',
         path: '',
         state: 1,
+        angle: 0,
+        usePhaseIndex: 0
     }
-  }
-  
-  let dialogTitle = computed(() => {
+}
+
+let dialogTitle = computed(() => {
     return titleType.value === 'add' ? '新增ICD' : '编辑ICD'
-  })
+})
 
-
-
-  //定义规则
-  const formRuleRef = ref<FormInstance>()
-  //定义校验规则
-  const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
+//定义规则
+const formRuleRef = ref<FormInstance>()
+//定义校验规则
+const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
     name: [{ required: true, message: 'icd名称必填！', trigger: 'blur' }],
-    path: [{ required: true, message: 'icd存储地址必填！', trigger: 'blur' }],
-  })
+    path: [{ required: true, message: 'icd存储地址必填！', trigger: 'blur' }]
+})
 
-  
 // 关闭弹窗
 const close = () => {
     dialogVisible.value = false
@@ -81,47 +103,46 @@ const close = () => {
     resetFormContent()
     // 重置表单
     dialogFormRef.value?.resetFields()
-  }
-  
-  // 保存数据
-  const save = () => {
+}
+
+// 保存数据
+const save = () => {
     try {
         dialogFormRef.value?.validate(async (valid: boolean) => {
-        if (valid) {
-          if (formContent.value.id) {
-              await updateICD(formContent.value);
-            } else {
-               await addICD(formContent.value);
-          }
-          ElMessage.success({ message: `${dialogTitle.value}成功！` })
-          close()
-          // 刷新表格
-          await props.refreshTable!()
-        }
-      })
+            if (valid) {
+                if (formContent.value.id) {
+                    await updateICD(formContent.value)
+                } else {
+                    await addICD(formContent.value)
+                }
+                ElMessage.success({ message: `${dialogTitle.value}成功！` })
+                close()
+                // 刷新表格
+                await props.refreshTable!()
+            }
+        })
     } catch (err) {
-      //error('验证过程中出现错误', err)
+        //error('验证过程中出现错误', err)
     }
-  }
-  
-  // 打开弹窗，可能是新增，也可能是编辑
-  const open = async (sign: string, data: ICD.ResICD) => {
+}
+
+// 打开弹窗，可能是新增，也可能是编辑
+const open = async (sign: string, data: ICD.ResICD) => {
     // 重置表单
     dialogFormRef.value?.resetFields()
     titleType.value = sign
     dialogVisible.value = true
 
     if (data.id) {
-      formContent.value = { ...data }
+        formContent.value = { ...data }
     } else {
-      resetFormContent()
+        resetFormContent()
     }
-  }
-  
-  // 对外映射
-  defineExpose({ open })
-  const props = defineProps<{
-    refreshTable: (() => Promise<void>) | undefined;
-  }>()
-  
-  </script>
+}
+
+// 对外映射
+defineExpose({ open })
+const props = defineProps<{
+    refreshTable: (() => Promise<void>) | undefined
+}>()
+</script>

frontend/src/views/machine/standardDevice/components/standardDevicePopup.vue

@@ -0,0 +1,319 @@
+<template>
+    <el-dialog  :title="dialogTitle" v-model='dialogVisible' @close="close" v-bind="dialogBig" align-center>
+        <el-tabs type="border-card">
+            <el-tab-pane label="设备台账信息">
+                <div >
+                    <el-form :model='formContent' ref='dialogFormRef' :rules='rules' :disabled="false" label-width="auto" class="form-three">
+                        <el-divider >设备信息</el-divider>
+                             
+                                <el-form-item label="设备名称" prop="name" >
+                                    <el-input v-model='formContent.name' placeholder="请输入设备名称" maxlength="32" show-word-limit/>
+                                </el-form-item>           
+                                <el-form-item label='设备类型'  prop='devType' >
+                                    <el-select v-model="formContent.devType" filterable  clearable placeholder="请选择设备类型" @change="handleDevTypeChange">
+                                    <el-option
+                                    v-for="item in devTypeOptions"
+                                    :key="item.id"
+                                    :label="item.name"
+                                    :value="item.id"
+                                    />
+                                </el-select>
+                                </el-form-item>  
+                                <el-form-item label='设备厂家'  prop='manufacturer'>
+                                    <el-select v-model="formContent.manufacturer"  clearable placeholder="请选择设备厂家">
+                                    <el-option
+                                    v-for="item in dictStore.getDictData('Dev_Manufacturers')"
+                                    :key="item.id"
+                                    :label="item.name"
+                                    :value="item.id"
+                                    />
+                                </el-select>
+                                </el-form-item>              
+                                        
+                        <el-divider >参数信息</el-divider>
+                                  <el-form-item label='通讯协议' prop='protocol'>
+                                    <el-select v-model="formContent.protocol" clearable placeholder="请选择通讯协议">
+                                      <el-option
+                                          v-for="item in dictStore.getDictData('Protocol')"
+                                          :key="item.id"
+                                          :label="item.name"
+                                          :value="item.id"
+                                      />
+                                    </el-select>
+                                  </el-form-item>     
+                                <el-form-item label="IP地址" prop="ip" placeholder="请输入IP地址">
+                                    <el-input v-model="formContent.ip"/>
+                                </el-form-item>     
+                                <el-form-item label="端口号" prop="port" placeholder="请输入端口号" >
+                                    <el-input v-model="formContent.port" />
+                                </el-form-item>    
+                                  <el-form-item label='可检通道数' prop='inspectChannel' >
+                                  <el-select v-model="formContent.inspectChannel"  multiple collapse-tags    :max-collapse-tags="4" placeholder="请选择可检通道数" clearable>
+                                    <el-option
+                                      v-for="(option, index) in pqChannelArray"
+                                      :key="index"
+                                      :label="option.label"
+                                      :value="option.value"
+                                    />
+                                  </el-select>
+                                </el-form-item>   
+                                <el-form-item label='是否加密'  prop='encryptionFlag' >
+                                    <el-select v-model="formContent.encryptionFlag"  clearable placeholder="请选择是否加密">
+                                        <el-option label="是" :value="1"></el-option>
+                                        <el-option label="否" :value="0"></el-option>
+                                    </el-select>
+                                </el-form-item>           
+                                <el-form-item label='识别码'  prop='series' clearable  v-if="formContent.encryptionFlag">
+                                    <el-input v-model='formContent.series' placeholder="请输入识别码" show-password/>
+                                </el-form-item>           
+                                <el-form-item label='密钥'  prop='devKey' clearable  v-if="formContent.encryptionFlag">
+                                    <el-input v-model='formContent.devKey' placeholder="请输入密钥" show-password/>
+                                </el-form-item>           
+                    </el-form>            
+                </div>  
+            </el-tab-pane>
+        </el-tabs>
+        <template #footer>
+            <div >
+                <el-button @click='close()'>取 消</el-button>
+                <el-button type="primary" @click='save()'>保存</el-button>
+            </div>
+        </template>
+    </el-dialog>
+
+</template>
+<script setup lang='ts'>
+
+import IPAddress from '@/components/IpAddress/index.vue'
+import { dialogBig } from '@/utils/elementBind'
+import {type StandardDevice} from '@/api/device/interface/standardDevice.ts'
+import { ElMessage, type FormItemRule } from 'element-plus'
+import { addPqStandardDev, updatePqStandardDev} from '@/api/device/standardDevice/index.ts'
+import { computed, reactive, type Ref, ref } from 'vue'
+import { useDictStore } from '@/stores/modules/dict'
+import { CirclePlus, Delete, EditPen } from '@element-plus/icons-vue'
+import {type Device} from '@/api/device/interface/device.ts'
+// 使用 dayjs 库格式化
+import dayjs from 'dayjs'
+
+// 存储设备类型选项
+const devTypeOptions = ref<Device.ResDev[]>([])
+const dictStore = useDictStore()
+// 定义弹出组件元信息
+const dialogFormRef = ref()
+
+const pqChannelArray = ref([
+  {
+    value: '1',
+    label: '1',
+  },
+  {
+    value: '2',
+    label: '2',
+  },
+  {
+    value: '3',
+    label: '3',
+  },
+  {
+    value: '4',
+    label: '4',
+  },
+])
+
+  function useMetaInfo() {
+    const dialogVisible = ref(false)
+    const titleType = ref('add')
+    const formContent = reactive<StandardDevice.ResPqStandardDevice>({
+      id: '',
+      name: '',
+      devType:'',
+      manufacturer:'',
+      protocol: 'MMS',
+      ip: '',
+      port: 102,
+      inspectChannel:'',
+      encryptionFlag: 0,
+      state: 1,
+    })
+    return { dialogVisible, titleType, formContent }
+  }
+  
+  const { dialogVisible, titleType, formContent } = useMetaInfo()
+  // 清空formContent
+  const resetFormContent = () => { 
+      Object.assign(
+      formContent,{
+        id: '',
+        name: '',
+        devType:'',
+        manufacturer:'',
+        protocol: 'MMS',
+        ip: '',
+        port: 102,
+        inspectChannel:'',
+        encryptionFlag: 0,
+        state: 1,
+        }
+    )
+  }
+  
+
+  let dialogTitle = computed(() => {
+    return titleType.value === 'add' ? '新增标准设备' : '编辑标准设备'
+  })
+
+
+    //定义校验规则
+  const rules: Ref<Record<string, Array<FormItemRule>>> = ref({
+        name : [{ required: true, message: '设备名称必填！', trigger: 'blur' }],
+        devType: [{ required: true, message: '设备类型必选！', trigger: 'change' }],
+        manufacturer:[{ required: true, message: '生产厂家必选！', trigger: 'change' }],
+        ip: [
+            { required: true, message: 'IP地址必填！', trigger: 'blur' },
+            { pattern: /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/, message: 'IP地址格式错误', trigger: 'blur' }
+        ],
+        port: [
+            { required: true, message: '端口号必填！', trigger: 'blur' },
+            { pattern: /^(6553[0-5]|655[0-2][0-9]|64[0-9]{3}|[1-5]?[0-9]{1,4})$/, message: '端口号范围0到65535的整数', trigger: 'blur' }
+        ],
+        inspectChannel:[ { required: true, message: '可检通道数必选', trigger: 'change' }],
+        encryptionFlag: [{ required: true, message: '是否加密必选！', trigger: 'change' }],
+        series: [{ required: true, message: '请输入识别码', trigger: 'blur' }],
+        devKey: [{ required: true, message: '请输入密钥', trigger: 'blur' }],
+        protocol: [{required: true, message: '通讯协议必选！', trigger: 'change'}],
+  })
+
+  // 关闭弹窗
+  const close = () => {
+    dialogVisible.value = false
+    // 清空dialogForm中的值
+    resetFormContent()
+    // 重置表单
+    dialogFormRef.value?.resetFields()
+    
+  }
+  
+  // 保存数据
+  const save = () => {
+    try {      
+        dialogFormRef.value?.validate(async (valid: boolean) => {
+            if (formContent.encryptionFlag === 0) {
+              formContent.series = ''
+              formContent.devKey = ''
+            }
+        if (valid) {
+          //保存时判是否加密，把识别码密钥字段清空
+          if(formContent.encryptionFlag === 0){
+              formContent.series = null
+              formContent.devKey = null
+          }
+
+        // 可检通道转为字符串逗号分隔（保存前临时转换）
+        let originalInspectChannel = formContent.inspectChannel; // 保存原始值
+          //可检通道转为字符串逗号分隔
+          // 确保 inspectChannel 是数组再执行 join
+         if (Array.isArray(formContent.inspectChannel)) {
+            formContent.inspectChannel = formContent.inspectChannel
+              .map(Number)  // 将值转为数字以保证正确排序
+              .sort((a, b) => a - b)  // 数字升序排序
+              .map(String) // 恢复为字符串用于保存
+              .join(',');
+          }
+
+          try {
+          if (formContent.id) {
+            await updatePqStandardDev(formContent);
+            ElMessage.success({ message: `${dialogTitle.value}成功！` })
+          } else {  
+            // 新增需要把通讯协议转成字典ID
+            const protocolItem = dictStore.getDictData('Protocol').find(item => item.name === formContent.protocol);
+            if (protocolItem) {
+              formContent.protocol = protocolItem.id;
+            }
+
+            await addPqStandardDev(formContent);
+            ElMessage.success({ message: `${dialogTitle.value}成功！` })
+          }
+          close()
+          // 刷新表格
+          await props.refreshTable!()
+        } catch (error) {
+          // 如果保存失败，恢复原始的 inspectChannel 值
+          formContent.inspectChannel = originalInspectChannel;
+          throw error;
+        }
+      } else {
+        // 验证失败也需要恢复原始 inspectChannel 格式（如果之前被转换过）
+        if (typeof formContent.inspectChannel === 'string' && formContent.inspectChannel.includes(',')) {
+          formContent.inspectChannel = formContent.inspectChannel.split(',').filter(Boolean);
+        }
+
+        }
+    })
+  } catch (err) {
+    console.error('验证过程中出现错误', err)
+  }
+}
+
+
+// 打开弹窗，可能是新增，也可能是编辑
+const open = async (sign: string, data: StandardDevice.ResPqStandardDevice,devType:Device.ResDev[]) => {
+    // 重置表单
+    dialogFormRef.value?.resetFields()
+    devTypeOptions.value = devType
+    titleType.value = sign
+    if (data.id) {
+     Object.assign(formContent,{ ...data })
+      if (typeof formContent.inspectChannel === 'string') {
+          formContent.inspectChannel = formContent.inspectChannel.split(',').filter(Boolean)
+      }
+      //handleDevTypeChange(data.devType)
+    } else {
+      resetFormContent()
+    }
+
+
+  dialogVisible.value = true
+}
+
+
+const handleDevTypeChange = (value: string) => {
+  console.log('handleDevTypeChange', value)
+  // 在这里处理选中事件的逻辑
+  const dev = devTypeOptions.value.find(t =>t.id === value)
+  if (dev) {
+      const maxChannel = dev.devChns
+    // 动态设置 pqChannelArray 从 1 到 dev.devChns.length
+    pqChannelArray.value = Array.from({ length: dev.devChns }, (_, i) => ({
+      value: String(i + 1),
+      label: String(i + 1),
+    }))
+
+    //if(titleType.value == 'add')    // 默认全选所有通道
+      formContent.inspectChannel = pqChannelArray.value.map(channel => channel.value)
+    // 过滤掉超出新通道数范围的选项
+    if (Array.isArray(formContent.inspectChannel)) {
+      formContent.inspectChannel = formContent.inspectChannel.filter(
+        (channel) => parseInt(channel, 10) <= maxChannel
+      )
+    }
+  } else {
+    // 可选：恢复默认值
+    pqChannelArray.value = [
+      { value: '1', label: '1' },
+      { value: '2', label: '2' },
+      { value: '3', label: '3' },
+      { value: '4', label: '4' },
+    ]
+
+     
+  }
+}
+
+// 对外映射
+defineExpose({ open })
+const props = defineProps<{
+  refreshTable: (() => Promise<void>) | undefined;
+}>()
+</script>

frontend/src/views/machine/standardDevice/index.vue

@@ -0,0 +1,228 @@
+<template>
+    <div class='table-box' ref='popupBaseView'>
+      <ProTable
+          ref='proTable'
+          :columns='columns'
+          :request-api='getTableList'
+      >
+        <!-- :requestApi="getRoleList" -->
+        <!-- 表格 header 按钮 -->
+        <template #tableHeader='scope'>
+          <el-button v-auth.device="'add'" type='primary' :icon='CirclePlus' @click="openDialog('add')">新增</el-button>
+          <el-button v-auth.device="'delete'" type='danger' :icon='Delete' plain :disabled='!scope.isSelected'
+                     @click='batchDelete(scope.selectedListIds)'>
+            删除
+          </el-button>
+          <el-button v-auth.device="'export'" type='primary' :icon='Upload' plain @click='downloadFile()'>导出</el-button>
+          <el-button v-auth.device="'import'" type='primary' :icon='Download' plain @click="importFile()">导入
+           </el-button>
+        </template>
+        <!-- 表格操作 -->
+        <template #operation='scope'>
+          <el-button v-auth.device="'edit'" type='primary' link :icon='EditPen' :model-value='false'
+                     @click="openDialog('edit', scope.row)">编辑
+          </el-button>
+          <el-button v-auth.device="'delete'" type='primary' link :icon='Delete' @click='handleDelete(scope.row)'>删除
+          </el-button>
+        </template>
+  
+      </ProTable>
+    </div>
+    <StandardDevicePopup :refresh-table='proTable?.getTableList' ref='standardDevicePopup'/>
+     <ImportExcel ref='deviceImportExcel'/>
+  </template>
+  
+  <script setup lang='tsx' name='useRole'>
+  import {type StandardDevice} from '@/api/device/interface/standardDevice.ts'
+  import {useHandleData} from '@/hooks/useHandleData'
+  import {useDownload} from '@/hooks/useDownload'
+  import ProTable from '@/components/ProTable/index.vue'
+  import {type ColumnProps, type ProTableInstance} from '@/components/ProTable/interface'
+  import StandardDevicePopup from '@/views/machine/standardDevice/components/standardDevicePopup.vue'
+  import {CirclePlus, Delete, Download, EditPen, Upload} from '@element-plus/icons-vue'
+  import {deletePqStandardDev, getPqStandardDevList,getPqStandardDevById,exportPqStandardDev,downloadTemplate,importPqStandardDev} from '@/api/device/standardDevice/index.ts'
+  import {computed, onBeforeMount, reactive, ref} from 'vue'
+  import { getPqDev} from '@/api/device/device/index.ts'
+  import {type Device} from '@/api/device/interface/device.ts'
+  import {useDictStore} from '@/stores/modules/dict'
+  import { ElMessageBox } from 'element-plus'
+  import ImportExcel from '@/components/ImportExcel/index.vue'
+  // ProTable 实例
+  const proTable = ref<ProTableInstance>()
+  const standardDevicePopup = ref()
+  // 存储设备类型选项
+  const devTypeOptions = ref<Device.ResDev[]>([])
+  const dictStore = useDictStore()
+
+
+  const getTableList = async (params: any) => {
+    let newParams = JSON.parse(JSON.stringify(params))
+
+    return getPqStandardDevList(newParams)
+  }
+  
+  // 表格配置项
+  const columns = reactive<ColumnProps<StandardDevice.ResPqStandardDevice>[]>([
+    {type: 'selection', fixed: 'left', width: 70},
+    {type: 'index', fixed: 'left', width: 70, label: '序号'},
+    {
+      prop: 'name',
+      label: '名称',
+      search: {el: 'input'},
+      minWidth: 200,
+    },
+    {
+      prop: 'devType',
+      label: '设备类型',
+      enum:computed(() => {
+            return devTypeOptions.value.map(item => ({
+              id: item.id,
+              name: item.name,
+              icd: item.icd,
+              power: item.power,
+              devVolt: item.devVolt,
+              devCurr: item.devCurr,
+              devChns: item.devChns,
+            }))
+      }),
+      search: {el: 'select', props: {filterable: true}, order: 1},
+      fieldNames: {label: 'name', value: 'id'},
+      render: (scope) => {
+      // 查找设备类型名称
+      const name = devTypeOptions.value.find(option => option.id === scope.row.devType)
+      return <span>{name?.name}</span>
+    },
+      minWidth: 200,
+    },
+    {
+      prop: 'inspectChannel',
+      label: '可检通道',
+      minWidth: 150,
+      render: (scope) => {
+        const codes = scope.row.inspectChannel // 获取当前行的 datasourceIds 字段
+        if (!codes) {
+          return '/'
+        }
+        // 确保 codes 是一个字符串
+        const codeString = Array.isArray(codes) ? codes.join(',') : codes
+        const codeArray = codeString.split(',')
+        return codeArray.length > 1 ? codeArray.join(', ') : codeArray[0]
+      },
+    },
+    {
+      prop: 'ip',
+      label: 'IP地址',
+      minWidth: 110,
+    },
+    {
+      prop: 'manufacturer',
+      label: '设备厂家',
+      enum: dictStore.getDictData('Dev_Manufacturers'),
+      search: {el: 'select', props: {filterable: true}, order: 1},
+      fieldNames: {label: 'name', value: 'id'},
+      minWidth: 200,
+    },
+    {
+      prop: 'createTime',
+      label: '创建时间',
+      minWidth: 200,
+      render: scope => {
+        if (scope.row.createTime) {
+          const date = new Date(scope.row.createTime);
+          const year = date.getFullYear();
+          const month = String(date.getMonth() + 1).padStart(2, '0');
+          const day = String(date.getDate()).padStart(2, '0');
+          const hours = String(date.getHours()).padStart(2, '0');
+          const minutes = String(date.getMinutes()).padStart(2, '0');
+          const seconds = String(date.getSeconds()).padStart(2, '0');
+          return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+        }
+        return '';
+      }
+    },
+    {prop: 'operation', label: '操作', fixed: 'right', width: 200},
+  ])
+  
+  
+
+
+  const formContent = reactive<StandardDevice.ResPqStandardDevice>({
+      id: '',
+      name: '',
+      devType:'',
+      manufacturer:'',
+      hardwareVersion: '',
+      softwareVersion: '',
+      ip: '172.17.102.200',
+      port: 102,
+      inspectChannel:'',
+      encryptionFlag: 0,
+      state: 1,
+    })
+
+  // 打开 drawer(新增、编辑)
+  const openDialog = async (titleType: string, row: Partial<StandardDevice.ResPqStandardDevice> = {}) => {
+    if(titleType === 'add'){
+       row = formContent
+       standardDevicePopup.value?.open(titleType, row,devTypeOptions.value)
+    }else{
+      row = await getPqStandardDevById(row)
+      standardDevicePopup.value?.open(titleType, row.data,devTypeOptions.value)
+    }
+    
+  }
+  
+  
+  // 批量删除设备
+  const batchDelete = async (id: string[]) => {
+    await useHandleData(deletePqStandardDev, id, '删除所选设备')
+    proTable.value?.clearSelection()
+    proTable.value?.getTableList()
+  }
+  
+  // 删除设备
+  const handleDelete = async (params: StandardDevice.ResPqStandardDevice) => {
+    await useHandleData(deletePqStandardDev,  [params.id] , `删除【${params.name}】设备`)
+    proTable.value?.getTableList()
+  }
+
+
+
+  // 导出设备
+const downloadFile = async () => {
+  ElMessageBox.confirm('确认导出标准设备?', '温馨提示', {type: 'warning'}).then(() => {
+    useDownload(exportPqStandardDev, '标准设备导出数据', {...proTable.value?.searchParam}, false, '.xlsx')
+  })
+}
+
+//导入设备
+const deviceImportExcel = ref<InstanceType<typeof ImportExcel> | null>(null)
+
+const importFile = async () => {
+    const params = {
+      title: '标准设备',
+      showCover: false,
+      tempApi: downloadTemplate,
+      importApi: importPqStandardDev,
+      getTableList: proTable.value?.getTableList,
+    }
+    deviceImportExcel.value?.acceptParams(params)
+}
+  
+
+  onBeforeMount(async () => {
+   const response = await getPqDev()
+    devTypeOptions.value = (response.data as Device.ResDev[]).map(item => ({
+    id: item.id,
+    name: item.name,
+    icd: item.icd,
+    power: item.power,
+    devVolt: item.devVolt,
+    devCurr: item.devCurr,
+    devChns: item.devChns,
+  }))
+
+})
+
+  </script>
+    

frontend/src/views/machine/testScript/components/communication.vue

@@ -1,185 +1,184 @@
-<template>
-    <div>
-        <el-table
-            :data="tableData"
-            :header-cell-style="{
-                textAlign: 'center',
-                backgroundColor: 'var(--el-color-primary)',
-                color: '#fff'
-            }"
-            stripe
-            :height="`calc(100vh -  ${props.shrink ? '535px' : '480px'})`"
-            :style="{ overflow: 'hidden' }"
-            row-key="id"
-            :expand-row-keys="[props.activeName]"
-        >
-            <el-table-column prop="name" label="指标" show-overflow-tooltip />
-            <el-table-column align="center" label="参与误差比较" width="110px">
-                <template #default="{ row }">
-                    <el-switch
-                        v-model="row.errorFlag"
-                        v-if="row.show"
-                        :active-value="1"
-                        :inactive-value="0"
-                        :disabled="row.disabled || disabled"
-                    >
-                        <template #active-action>
-                            <span>√</span>
-                        </template>
-                        <template #inactive-action>
-                            <span>×</span>
-                        </template>
-                    </el-switch>
-                </template>
-            </el-table-column>
-            <el-table-column align="center" label="是否启用" width="85px">
-                <template #default="{ row }">
-                    <el-switch
-                        v-model="row.enable"
-                        v-if="row.show"
-                        :active-value="1"
-                        :inactive-value="0"
-                        :disabled="row.disabled || disabled"
-                    >
-                        <template #active-action>
-                            <span>√</span>
-                        </template>
-                        <template #inactive-action>
-                            <span>×</span>
-                        </template>
-                    </el-switch>
-                </template>
-            </el-table-column>
-        </el-table>
-    </div>
-</template>
-<script setup lang="ts">
-import { ref, reactive } from 'vue'
-import type { Dict } from '@/api/system/dictionary/interface'
-import { getDictTreeByCode } from '@/api/system/dictionary/dictTree'
-import { checkDataList } from '@/api/device/testScript'
-
-const props = defineProps({
-    activeName: {
-        type: String,
-        required: true
-    },
-    formContent: {
-        type: Object,
-        required: true
-    },
-    disabled: {
-        type: Boolean,
-        default: true
-    },
-    options: {
-        type: Array,
-        required: true
-    },
-    shrink: {
-        type: Boolean
-    }
-})
-const tableData = ref<any[]>([])
-const info = async () => {
-    let checkData: any = []
-    let title = props.options.filter((i: any) => i.value == props.activeName)[0]
-
-    await checkDataList({
-        scriptId: props.formContent.id,
-        scriptType: props.activeName
-    }).then((res: any) => {
-        checkData = res.data
-    })
-
-    let { data } = await getDictTreeByCode({
-        name: '',
-        id: '',
-        pid: '',
-        pids: '',
-        code: 'Script_Error',
-        sort: 0
-    })
-
-    data[0].children.forEach((item: any, i: number) => {
-        tableData.value.push({
-            id: item.id,
-            name: item.name,
-            show: false,
-            children: []
-        })
-        item.children.forEach((k: any) => {
-            let childrenList: any = []
-            checkData.forEach((j: any) => {
-                if (j.valueType == k.id) {
-                    childrenList.push(j)
-                }
-            })
-            if (childrenList.length > 0) {
-                tableData.value[i].children.push({
-                    id: k.id,
-                    pid: item.id,
-                    name: k.name,
-                    pname: item.name,
-                    dataType:
-                        item.name == '谐波有功功率'
-                            ? 'avg'
-                            : item.name == '闪变'
-                              ? 'avg'
-                              : item.name == '暂态'
-                                ? 'avg'
-                                : 'real',
-                    show: true,
-                    errorFlag: childrenList[0].errorFlag,
-                    enable: childrenList[0].enable
-                })
-            } else {
-                tableData.value[i].children.push({
-                    id: k.id,
-                    pid: item.id,
-                    name: k.name,
-                    disabled: false,
-                    pname: item.name,
-                    dataType: item.name =='谐波有功功率'
-                        ? 'avg'
-                        : item.name == '闪变'
-                          ? 'avg'
-                          : item.name == '暂态'
-                            ? 'avg'
-                            : 'real',
-                    show: true,
-                    errorFlag: 0,
-                    enable: 0
-                })
-            }
-        })
-        // 默认够选通讯脚本
-        if (item.name == title.label.replace(/准确度|检测/g, '')) {
-            if (item.name == '暂态') {
-                tableData.value[i].children.forEach((k: any) => {
-                    k.disabled = true
-                    k.enable = 1
-                    k.errorFlag = 1
-                })
-            } else {
-                tableData.value[i].children[0].disabled = true
-                tableData.value[i].children[0].enable = 1
-                tableData.value[i].children[0].errorFlag = 1
-            }
-        }
-    })
-
-    //console.log('🚀 ~ item.children.forEach ~ tableData.value:', tableData.value)
-}
-const getData = () => {
-    return tableData.value
-}
-onMounted(() => {
-    info()
-    // tableData.value = data.data[0].children || []
-})
-
-// 对外映射
-defineExpose({ getData })
-</script>
-<style lang="scss" scoped></style>
+<template>
+    <div>
+        <el-table
+            :data="tableData"
+            :header-cell-style="{
+                textAlign: 'center',
+                backgroundColor: 'var(--el-color-primary)',
+                color: '#fff'
+            }"
+            stripe
+            :height="`calc(100vh -  ${props.shrink ? '535px' : '480px'})`"
+            :style="{ overflow: 'hidden' }"
+            row-key="id"
+            :expand-row-keys="[props.activeName]"
+        >
+            <el-table-column prop="name" label="指标" show-overflow-tooltip />
+            <el-table-column align="center" label="参与误差比较" width="110px">
+                <template #default="{ row }">
+                    <el-switch
+                        v-model="row.errorFlag"
+                        v-if="row.show"
+                        :active-value="1"
+                        :inactive-value="0"
+                        :disabled="row.disabled || disabled"
+                    >
+                        <template #active-action>
+                            <span>√</span>
+                        </template>
+                        <template #inactive-action>
+                            <span>×</span>
+                        </template>
+                    </el-switch>
+                </template>
+            </el-table-column>
+            <el-table-column align="center" label="是否启用" width="85px">
+                <template #default="{ row }">
+                    <el-switch
+                        v-model="row.enable"
+                        v-if="row.show"
+                        :active-value="1"
+                        :inactive-value="0"
+                        :disabled="row.disabled || disabled"
+                    >
+                        <template #active-action>
+                            <span>√</span>
+                        </template>
+                        <template #inactive-action>
+                            <span>×</span>
+                        </template>
+                    </el-switch>
+                </template>
+            </el-table-column>
+        </el-table>
+    </div>
+</template>
+<script setup lang="ts">
+import { ref, reactive } from 'vue'
+import type { Dict } from '@/api/system/dictionary/interface'
+import { getDictTreeByCode } from '@/api/system/dictionary/dictTree'
+import { checkDataList } from '@/api/device/testScript'
+
+const props = defineProps({
+    activeName: {
+        type: String,
+        required: true
+    },
+    formContent: {
+        type: Object,
+        required: true
+    },
+    disabled: {
+        type: Boolean,
+        default: true
+    },
+    options: {
+        type: Array,
+        required: true
+    },
+    shrink: {
+        type: Boolean
+    }
+})
+const tableData = ref<any[]>([])
+const info = async () => {
+    let checkData: any = []
+    let title = props.options.filter((i: any) => i.value == props.activeName)[0]
+
+    await checkDataList({
+        scriptId: props.formContent.id,
+        scriptType: props.activeName
+    }).then((res: any) => {
+        checkData = res.data
+    })
+
+    let { data } = await getDictTreeByCode({
+        name: '',
+        id: '',
+        pid: '',
+        pids: '',
+        code: 'Script_Error',
+        sort: 0
+    })
+
+    data[0].children.forEach((item: any, i: number) => {
+        tableData.value.push({
+            id: item.id,
+            name: item.name,
+            show: false,
+            children: []
+        })
+        item.children.forEach((k: any) => {
+            let childrenList: any = []
+            checkData.forEach((j: any) => {
+                if (j.valueType == k.id) {
+                    childrenList.push(j)
+                }
+            })
+            if (childrenList.length > 0) {
+                tableData.value[i].children.push({
+                    id: k.id,
+                    pid: item.id,
+                    name: k.name,
+                    pname: item.name,
+                    dataType:
+                        item.name == '谐波有功功率'
+                            ? 'avg'
+                            : item.name == '闪变'
+                              ? 'avg'
+                              : item.name == '暂态'
+                                ? 'avg'
+                                : 'real',
+                    show: true,
+                    errorFlag: childrenList[0].errorFlag,
+                    enable: childrenList[0].enable
+                })
+            } else {
+                tableData.value[i].children.push({
+                    id: k.id,
+                    pid: item.id,
+                    name: k.name,
+                    disabled: false,
+                    pname: item.name,
+                    dataType: item.name =='谐波有功功率'
+                        ? 'avg'
+                        : item.name == '闪变'
+                          ? 'avg'
+                          : item.name == '暂态'
+                            ? 'avg'
+                            : 'real',
+                    show: true,
+                    errorFlag: 0,
+                    enable: 0
+                })
+            }
+        })
+        // 默认够选通讯脚本
+        if (item.name == title.label.replace(/准确度|检测/g, '')) {
+            if (item.name == '暂态') {
+                tableData.value[i].children.forEach((k: any) => {
+                    k.disabled = true
+                    k.enable = 1
+                    k.errorFlag = 1
+                })
+            } else {
+                tableData.value[i].children[0].disabled = true
+                tableData.value[i].children[0].enable = 1
+                tableData.value[i].children[0].errorFlag = 1
+            }
+        }
+    })
+
+}
+const getData = () => {
+    return tableData.value
+}
+onMounted(() => {
+    info()
+    // tableData.value = data.data[0].children || []
+})
+
+// 对外映射
+defineExpose({ getData })
+</script>
+<style lang="scss" scoped></style>

frontend/src/views/machine/testScript/components/setValueTable.vue

@@ -1,351 +1,354 @@
-<template>
-    <div class="table-container">
-        <div class="recalculation">
-            <el-button type="primary" :icon="Refresh" @click="recalculation">一键重算</el-button>
-        </div>
-
-        <el-table
-            :data="tableData"
-            :header-cell-style="{
-                textAlign: 'center',
-                backgroundColor: 'var(--el-color-primary)',
-                color: '#fff'
-            }"
-            stripe
-            :cell-style="{ textAlign: 'center' }"
-            height="550px"
-        >
-            <el-table-column type="index" label="序号" width="60" />
-            <el-table-column prop="pname" label="参考设定值类型" />
-            <el-table-column prop="name" label="参考设定值子类型" width="250">
-                <template #default="{ row }">{{ row.harmNum ? `(${row.harmNum}次)` : '' }} {{ row.name }}</template>
-            </el-table-column>
-            <!-- <el-table-column prop="dataType" label="值类型">
-                <template #default="{ row }">
-                    <el-select v-model="row.dataType" v-if="!row.show">
-                        <el-option v-for="item in typeList" :key="item.value" :label="item.label" :value="item.value" />
-                    </el-select>
-                    <span v-else>
-                        {{ typeList.find(item => item.value == row.dataType)?.label || row.dataType }}
-                    </span>
-                </template>
-            </el-table-column> -->
-            <el-table-column prop="phase" label="相别" />
-            <el-table-column prop="value" label="参考设定值">
-                <template #default="{ row }">
-                    <span v-if="row.show">{{ parseFloat((row.value - 0).toFixed(4)) }}{{ setUnit(row) || '' }}</span>
-                    <el-input type="number" v-else v-model="row.value" placeholder="请输入值" />
-                </template>
-            </el-table-column>
-            <el-table-column prop="value" label="参与误差比较">
-                <template #default="{ row }">
-                    {{ row.errorFlag == 0 ? '否' : '是' }}
-                </template>
-            </el-table-column>
-            <el-table-column label="操作">
-                <template #default="{ row }">
-                    <el-button type="primary" link :icon="EditPen" @click="row.show = !row.show" v-if="row.show">
-                        编辑
-                    </el-button>
-                    <el-button type="primary" link :icon="Check" @click="row.show = !row.show" v-else>保存</el-button>
-                </template>
-            </el-table-column>
-        </el-table>
-    </div>
-
-    <el-dialog :title="dialogTitle" v-model="showForm" @close="close" width="500">
-        <el-form ref="form" :model="form" label-width="auto">
-            <el-form-item label="参考设定值类型" prop="name">
-                <el-input v-model="form.name" />
-            </el-form-item>
-            <el-form-item label="参考设定值子类型" prop="standardName">
-                <el-input v-model="form.standardName" />
-            </el-form-item>
-            <el-form-item label="参考设定值" prop="standardTime">
-                <el-input v-model="form.standardTime" />
-            </el-form-item>
-        </el-form>
-        <template #footer>
-            <div>
-                <el-button @click="close()">取 消</el-button>
-                <el-button type="primary" @click="save">保 存</el-button>
-            </div>
-        </template>
-    </el-dialog>
-</template>
-
-<script setup lang="ts">
-import { Refresh, EditPen, Check, Share } from '@element-plus/icons-vue'
-import { reactive, ref } from 'vue'
-import { getDictTreeByCode } from '@/api/system/dictionary/dictTree'
-import { dialogBig } from '@/utils/elementBind'
-import { checkDataList, scriptDtlsCheckDataList } from '@/api/device/testScript/index'
-const showForm = ref(false)
-const dialogVisible = ref(false)
-const dialogTitle = ref('')
-const props = defineProps({
-    activeName: {
-        type: String,
-        required: true
-    },
-
-    formContent: {
-        type: [Object, Array],
-        required: true
-    },
-    form: {
-        type: [Object, Array],
-        required: true
-    },
-    valueCode: {
-        type: String,
-        required: true
-    }
-})
-const emit = defineEmits(['recalculation'])
-const tableData: any = ref([])
-// 表格配置项
-const typeList = [
-    {
-        label: '实时',
-        value: 'real'
-    },
-    {
-        label: 'CP95值',
-        value: 'cp95'
-    },
-    {
-        label: '平均值',
-        value: 'avg'
-    },
-    {
-        label: '最小值',
-        value: 'min'
-    },
-    {
-        label: '最大值',
-        value: 'max'
-    }
-]
-const form = ref({
-    name: 220,
-    standardName: 0,
-    standardTime: 0
-})
-
-// 打开弹窗，可能是新增，也可能是编辑
-
-const open = async (row: any, copyRowList: any) => {
-    let treeData: any = []
-    await getDictTreeByCode({
-        name: '',
-        id: '',
-        pid: '',
-        pids: '',
-        code: 'Script_Error',
-        sort: 0
-    }).then((res: any) => {
-        treeData = res.data[0].children
-    })
-    let checkDataList: any = []
-    await row.forEach((item: any) => {
-        item.children.forEach((k: any) => {
-            if (k.enable != 0 || k.errorFlag != 0) {
-                checkDataList.push({
-                    pid: k.pid,
-                    valueType: k.id,
-                    dataType: k.dataType,
-                    enable: k.enable,
-                    errorFlag: k.errorFlag
-                })
-            }
-        })
-    })
-
-    let form = handleHarmData(JSON.parse(JSON.stringify(props.form)))
-    let retryCompute = isEqual(form, copyRowList)
-    await scriptDtlsCheckDataList({
-        ...form,
-        scriptId: props.formContent?.id,
-        scriptType: props.activeName,
-        checkDataList: checkDataList,
-        retryCompute: retryCompute
-    }).then((res: any) => {
-        res.data.forEach((item: any) => {
-            let pList = treeData.filter((i: any) => i.id == item.pid)[0]
-            item.pname = pList.name
-            item.name = pList.children.filter((i: any) => i.id == item.valueType)[0].name
-            item.show = true
-        })
-        tableData.value = res.data
-    })
-}
-// 重算
-const recalculation = () => {
-    emit('recalculation')
-}
-// 处理多余数据
-const handleHarmData = (row: any) => {
-    row.channelList.forEach((channel: any) => {
-        // 筛选出 famp 和 fphase 不同时为 0 的对象
-        channel.harmList = channel.harmList.filter((item: any) => item.famp != 0 || item.fphase != 0)
-        channel.inharmList = channel.inharmList.filter(
-            (item: any) => item.inharm !== '' || item.famp !== 0 || item.fphase !== 0
-        )
-    })
-    return row
-}
-// 判断数据是否变化
-const isEqual = (obj1: any, obj2: any) => {
-    // 如果两个对象是同一个引用，直接返回 true
-    if (obj1 == obj2) return true
-    // 如果其中一个是 null 或者不是对象，返回 false
-    if (obj1 === null || typeof obj1 !== 'object' || obj2 === null || typeof obj2 !== 'object') {
-        return false
-    }
-    // 获取两个对象的键
-    const keys1 = Object.keys(obj1)
-    const keys2 = Object.keys(obj2)
-    // 如果键的数量不同，返回 false
-    if (keys1.length !== keys2.length) return false
-    // 遍历所有键，递归比较值
-    for (const key of keys1) {
-        if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
-            return false
-        }
-    }
-
-    return true
-}
-const unit = [
-    {
-        label: '频率',
-        unit: 'Hz'
-    },
-    {
-        label: '相电压有效值',
-        unit: 'V'
-    },
-    {
-        label: '电压偏差',
-        unit: '%'
-    },
-    {
-        label: '电压相角',
-        unit: '°'
-    },
-    {
-        label: '基波电压有效值',
-        unit: ''
-    },
-    {
-        label: '电流有效值',
-        unit: 'A'
-    },
-    {
-        label: '电流相角',
-        unit: '°'
-    },
-    {
-        label: '基波电流有效值',
-        unit: ''
-    },
-    {
-        label: '谐波电压',
-        unit: '%'
-    },
-    {
-        label: '谐波电流',
-        unit: '%'
-    },
-    {
-        label: '谐波电流幅值',
-        unit: 'A'
-    },
-    {
-        label: '谐波有功功率',
-        unit: 'W'
-    },
-    {
-        label: '间谐波电压',
-        unit: '%'
-    },
-    {
-        label: '间谐波电流',
-        unit: '%'
-    },
-    {
-        label: '电压幅值',
-        unit: '%'
-    },
-    {
-        label: '持续时间',
-        unit: '周波'
-    },
-    {
-        label: '三相电压不平衡度',
-        unit: '%'
-    },
-    {
-        label: '三相电流不平衡度',
-        unit: '%'
-    },
-    {
-        label: '闪变',
-        unit: ''
-    },
-    
-    {
-        label: '电流',
-        unit: props.valueCode == 'Absolute' ? 'A' : '%'
-    },
-    
-]
-// 参考设定值添加单位
-const setUnit = (row: any) => {
-    console.log('🚀 ~ setUnit ~ row:', row)
-    let text = ''
-    if (row.pname == '暂态') {
-        row.name == '电压幅值' ? (text = '%') : ''
-        row.name == '持续时间' ? (text = '周波') : ''
-    } else if (row.pname == '电压') {
-        let o = props.valueCode == 'Absolute' ? 'V' : '%'
-        row.name == '相电压有效值' ? (text = o) : ''
-        row.name == '电压偏差' ? (text = '%') : ''
-        row.name == '电压相角' ? (text = '°') : ''
-    }else if (row.pname == '电流') {
-        let o = props.valueCode == 'Absolute' ? 'A' : '%'
-        row.name == '电流有效值' ? (text = o) : ''
-        row.name == '电流相角' ? (text = '°') : ''
-    } else {
-        text = unit.filter(item => item.label == row.pname)[0]?.unit
-    }
-
-    return text || ''
-}
-const save = () => {
-    dialogVisible.value = false
-}
-const getTableData = () => {
-    return tableData.value
-}
-
-// 关闭弹窗
-const close = () => {
-    dialogVisible.value = false
-}
-
-onMounted(() => {})
-
-// 对外映射
-defineExpose({ open, getTableData })
-</script>
-
-<style scoped>
-.recalculation {
-    width: 100%;
-    display: flex;
-    justify-content: end;
-    margin-bottom: 10px;
-}
-</style>
+<template>
+    <div class="table-container">
+        <div class="recalculation">
+            <el-button type="primary" :icon="Refresh" @click="recalculation">一键重算</el-button>
+        </div>
+
+        <el-table
+            :data="tableData"
+            :header-cell-style="{
+                textAlign: 'center',
+                backgroundColor: 'var(--el-color-primary)',
+                color: '#fff'
+            }"
+            stripe
+            :cell-style="{ textAlign: 'center' }"
+            height="550px"
+        >
+            <el-table-column type="index" label="序号" width="60" />
+            <el-table-column prop="pname" label="参考设定值类型" />
+            <el-table-column prop="name" label="参考设定值子类型" width="250">
+                <template #default="{ row }">{{ row.harmNum ? `(${row.harmNum}次)` : '' }} {{ row.name }}</template>
+            </el-table-column>
+            <!-- <el-table-column prop="dataType" label="值类型">
+                <template #default="{ row }">
+                    <el-select v-model="row.dataType" v-if="!row.show">
+                        <el-option v-for="item in typeList" :key="item.value" :label="item.label" :value="item.value" />
+                    </el-select>
+                    <span v-else>
+                        {{ typeList.find(item => item.value == row.dataType)?.label || row.dataType }}
+                    </span>
+                </template>
+            </el-table-column> -->
+            <el-table-column prop="phase" label="相别" />
+            <el-table-column prop="value" label="参考设定值">
+                <template #default="{ row }">
+                    <span v-if="row.show">{{ parseFloat((row.value - 0).toFixed(4)) }}{{ setUnit(row) || '' }}</span>
+                    <el-input type="number" v-else v-model="row.value" placeholder="请输入值" />
+                </template>
+            </el-table-column>
+            <el-table-column prop="value" label="参与误差比较">
+                <template #default="{ row }">
+                    {{ row.errorFlag == 0 ? '否' : '是' }}
+                </template>
+            </el-table-column>
+            <el-table-column label="操作">
+                <template #default="{ row }">
+                    <el-button type="primary" link :icon="EditPen" @click="row.show = !row.show" v-if="row.show">
+                        编辑
+                    </el-button>
+                    <el-button type="primary" link :icon="Check" @click="row.show = !row.show" v-else>保存</el-button>
+                </template>
+            </el-table-column>
+        </el-table>
+    </div>
+
+    <el-dialog :title="dialogTitle" v-model="showForm" @close="close" width="500">
+        <el-form ref="form" :model="form" label-width="auto">
+            <el-form-item label="参考设定值类型" prop="name">
+                <el-input v-model="form.name" />
+            </el-form-item>
+            <el-form-item label="参考设定值子类型" prop="standardName">
+                <el-input v-model="form.standardName" />
+            </el-form-item>
+            <el-form-item label="参考设定值" prop="standardTime">
+                <el-input v-model="form.standardTime" />
+            </el-form-item>
+        </el-form>
+        <template #footer>
+            <div>
+                <el-button @click="close()">取 消</el-button>
+                <el-button type="primary" @click="save">保 存</el-button>
+            </div>
+        </template>
+    </el-dialog>
+</template>
+
+<script setup lang="ts">
+import { Refresh, EditPen, Check, Share } from '@element-plus/icons-vue'
+import { reactive, ref } from 'vue'
+import { getDictTreeByCode } from '@/api/system/dictionary/dictTree'
+import { dialogBig } from '@/utils/elementBind'
+import { checkDataList, scriptDtlsCheckDataList } from '@/api/device/testScript/index'
+const showForm = ref(false)
+const dialogVisible = ref(false)
+const dialogTitle = ref('')
+const props = defineProps({
+    activeName: {
+        type: String,
+        required: true
+    },
+
+    formContent: {
+        type: [Object, Array],
+        required: true
+    },
+    form: {
+        type: [Object, Array],
+        required: true
+    },
+    valueCode: {
+        type: String,
+        required: true
+    }
+})
+const emit = defineEmits(['recalculation'])
+const tableData: any = ref([])
+// 表格配置项
+const typeList = [
+    {
+        label: '实时',
+        value: 'real'
+    },
+    {
+        label: 'CP95值',
+        value: 'cp95'
+    },
+    {
+        label: '平均值',
+        value: 'avg'
+    },
+    {
+        label: '最小值',
+        value: 'min'
+    },
+    {
+        label: '最大值',
+        value: 'max'
+    }
+]
+const form = ref({
+    name: 220,
+    standardName: 0,
+    standardTime: 0
+})
+
+// 打开弹窗，可能是新增，也可能是编辑
+
+const open = async (row: any, copyRowList: any) => {
+    let treeData: any = []
+    await getDictTreeByCode({
+        name: '',
+        id: '',
+        pid: '',
+        pids: '',
+        code: 'Script_Error',
+        sort: 0
+    }).then((res: any) => {
+        treeData = res.data[0].children
+    })
+    let checkDataList: any = []
+    await row.forEach((item: any) => {
+        item.children.forEach((k: any) => {
+            if (k.enable != 0 || k.errorFlag != 0) {
+                checkDataList.push({
+                    pid: k.pid,
+                    valueType: k.id,
+                    dataType: k.dataType,
+                    enable: k.enable,
+                    errorFlag: k.errorFlag
+                })
+            }
+        })
+    })
+
+    let form = handleHarmData(JSON.parse(JSON.stringify(props.form)))
+    let retryCompute = isEqual(form, copyRowList)
+    await scriptDtlsCheckDataList({
+        ...form,
+        scriptId: props.formContent?.id,
+        scriptType: props.activeName,
+        checkDataList: checkDataList,
+        retryCompute: retryCompute
+    }).then((res: any) => {
+        res.data.forEach((item: any) => {
+            let pList = treeData.filter((i: any) => i.id == item.pid)[0]
+            item.pname = pList.name
+            item.name = pList.children.filter((i: any) => i.id == item.valueType)[0].name
+            item.show = true
+        })
+        tableData.value = res.data
+    })
+}
+// 重算
+const recalculation = () => {
+    emit('recalculation')
+}
+// 处理多余数据
+const handleHarmData = (row: any) => {
+    row.channelList.forEach((channel: any) => {
+        // 筛选出 famp 和 fphase 不同时为 0 的对象
+        channel.harmList = channel.harmList.filter((item: any) => item.famp != 0 || item.fphase != 0)
+        channel.inharmList = channel.inharmList.filter(
+            (item: any) => item.inharm !== '' || item.famp !== 0 || item.fphase !== 0
+        )
+    })
+    return row
+}
+// 判断数据是否变化
+const isEqual = (obj1: any, obj2: any) => {
+    // 如果两个对象是同一个引用，直接返回 true
+    if (obj1 == obj2) return true
+    // 如果其中一个是 null 或者不是对象，返回 false
+    if (obj1 === null || typeof obj1 !== 'object' || obj2 === null || typeof obj2 !== 'object') {
+        return false
+    }
+    // 获取两个对象的键
+    const keys1 = Object.keys(obj1)
+    const keys2 = Object.keys(obj2)
+    // 如果键的数量不同，返回 false
+    if (keys1.length !== keys2.length) return false
+    // 遍历所有键，递归比较值
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !isEqual(obj1[key], obj2[key])) {
+            return false
+        }
+    }
+
+    return true
+}
+const unit = [
+    {
+        label: '频率',
+        unit: 'Hz'
+    },
+    {
+        label: '相电压有效值',
+        unit: 'V'
+    },
+  {
+    label: '功率',
+    unit: 'W'
+  },
+    {
+        label: '电压偏差',
+        unit: '%'
+    },
+    {
+        label: '电压相角',
+        unit: '°'
+    },
+    {
+        label: '基波电压有效值',
+        unit: ''
+    },
+    {
+        label: '电流有效值',
+        unit: 'A'
+    },
+    {
+        label: '电流相角',
+        unit: '°'
+    },
+    {
+        label: '基波电流有效值',
+        unit: ''
+    },
+    {
+        label: '谐波电压',
+        unit: '%'
+    },
+    {
+        label: '谐波电流',
+        unit: '%'
+    },
+    {
+        label: '谐波电流幅值',
+        unit: 'A'
+    },
+    {
+        label: '谐波有功功率',
+        unit: '%Ph'
+    },
+    {
+        label: '间谐波电压',
+        unit: '%'
+    },
+    {
+        label: '间谐波电流',
+        unit: '%'
+    },
+    {
+        label: '电压幅值',
+        unit: '%'
+    },
+    {
+        label: '持续时间',
+        unit: '周波'
+    },
+    {
+        label: '三相电压不平衡度',
+        unit: '%'
+    },
+    {
+        label: '三相电流不平衡度',
+        unit: '%'
+    },
+    {
+        label: '闪变',
+        unit: ''
+    },
+    
+    {
+        label: '电流',
+        unit: props.valueCode == 'Absolute' ? 'A' : '%'
+    },
+    
+]
+// 参考设定值添加单位
+const setUnit = (row: any) => {
+    let text = ''
+    if (row.pname == '暂态') {
+        row.name == '电压幅值' ? (text = '%') : ''
+        row.name == '持续时间' ? (text = '周波') : ''
+    } else if (row.pname == '电压') {
+        let o = props.valueCode == 'Absolute' ? 'V' : '%'
+        row.name == '相电压有效值' ? (text = o) : ''
+        row.name == '电压偏差' ? (text = '%') : ''
+        row.name == '电压相角' ? (text = '°') : ''
+    }else if (row.pname == '电流') {
+        let o = props.valueCode == 'Absolute' ? 'A' : '%'
+        row.name == '电流有效值' ? (text = o) : ''
+        row.name == '电流相角' ? (text = '°') : ''
+    } else {
+        text = unit.filter(item => item.label == row.pname)[0]?.unit
+    }
+
+    return text || ''
+}
+const save = () => {
+    dialogVisible.value = false
+}
+const getTableData = () => {
+    return tableData.value
+}
+
+// 关闭弹窗
+const close = () => {
+    dialogVisible.value = false
+}
+
+onMounted(() => {})
+
+// 对外映射
+defineExpose({ open, getTableData })
+</script>
+
+<style scoped>
+.recalculation {
+    width: 100%;
+    display: flex;
+    justify-content: end;
+    margin-bottom: 10px;
+}
+</style>

frontend/src/views/machine/testScript/components/testScriptFlickerTab.vue

@@ -204,6 +204,10 @@ const waveList = [
             {
                 fchagFre: '2400',
                 fchagValue: '0.77'
+            },
+             {
+                fchagFre: '4000',
+                fchagValue: '2.4'
             }
         ]
     },

frontend/src/views/machine/testScript/components/testScriptHarmTab.vue

@@ -1,378 +1,377 @@
-<template>
-  <div class="tabs-container">
-    <el-tabs type="border-card" class="right-tabs" style="height: 100%">
-      <el-tab-pane label="电压通道">
-        <el-form :inline="true" :model="formInline" :disabled="!props.childForm[0].harmFlag">
-          <el-form-item label="次数">
-            <el-select
-                v-model="formInline.harm"
-                multiple
-                collapse-tags
-                collapse-tags-tooltip
-                style="width: 160px"
-                filterable
-                clearable
-            >
-              <el-option label="全部" value="0"/>
-              <el-option v-for="item in 49" :key="item" :label="item + 1" :value="item + 1"/>
-            </el-select>
-          </el-form-item>
-          <el-form-item label="含有率">
-            <el-input
-                v-model="formInline.famp"
-                type="number"
-                placeholder="含有率"
-                style="width: 80px"
-                onkeypress="return (/[\d.]/.test(String.fromCharCode(event.keyCode)))"
-                @input="validateInput('famp',0)"
-                clearable
-            />
-          </el-form-item>
-          <el-form-item label="相角">
-            <el-input
-                v-model="formInline.fphase"
-                type="number"
-                placeholder="相角"
-                style="width: 80px"
-                onkeypress="return (/[\d-]/.test(String.fromCharCode(event.keyCode)))"
-                @input="validateInput('fphase',0)"
-                clearable
-            />
-          </el-form-item>
-          <el-form-item>
-            <el-button type="primary" :icon="Check" @click="onSubmit" size="small">确定</el-button>
-            <el-button type="primary" :icon="Delete" @click="empty(0)" size="small">清空表格</el-button>
-          </el-form-item>
-        </el-form>
-        <!-- 电压通道内容 -->
-        <div class="table-container">
-          <el-table :data="form[0].harmList" border stripe size="small">
-            <el-table-column prop="harm" align="center" label="次数" width="60"/>
-            <el-table-column prop="famp" align="center" label="谐波含有率">
-              <template #default="{ row }">
-                <el-input type="number" v-if="row.show" v-model="row.famp"/>
-                <span v-else>{{ row.famp }}%</span>
-              </template>
-            </el-table-column>
-            <el-table-column prop="fphase" label="谐波相角" align="center">
-              <template #default="{ row }">
-                <el-input type="number" v-if="row.show" v-model="row.fphase"/>
-                <span v-else>{{ row.fphase }}°</span>
-              </template>
-            </el-table-column>
-            <el-table-column label="操作" align="center">
-              <template #default="{ row, $index }">
-                <el-button
-                    type="primary"
-                    link
-                    :icon="EditPen"
-                    v-if="!row.show"
-                    @click="row.show = true"
-                >
-                  编辑
-                </el-button>
-                <el-button type="primary" link :icon="Check" v-else @click="row.show = false">
-                  保存
-                </el-button>
-                <el-button type="primary" link :icon="Delete" @click="HarmFlagDelete(0, $index)">
-                  删除
-                </el-button>
-              </template>
-            </el-table-column>
-          </el-table>
-        </div>
-      </el-tab-pane>
-    </el-tabs>
-    <el-tabs type="border-card" style="height: 100%">
-      <el-tab-pane label="电流通道">
-        <el-form :inline="true" :model="formInline1" :disabled="!props.childForm[1].harmFlag">
-          <el-form-item label="次数">
-            <el-select
-                v-model="formInline1.harm"
-                multiple
-                collapse-tags
-                collapse-tags-tooltip
-                style="width: 160px"
-                filterable
-                clearable
-            >
-              <el-option label="全部" value="0"/>
-              <el-option v-for="item in 49" :key="item" :label="item + 1" :value="item + 1"/>
-            </el-select>
-          </el-form-item>
-          <el-form-item label="含有率">
-            <el-input
-                v-model="formInline1.famp"
-                type="number"
-                placeholder="含有率"
-                style="width: 80px"
-                onkeypress="return (/[\d]/.test(String.fromCharCode(event.keyCode)))"
-                @input="validateInput('famp',1)"
-                clearable
-            />
-          </el-form-item>
-          <el-form-item label="相角">
-            <el-input
-                v-model="formInline1.fphase"
-                type="number"
-                placeholder="相角"
-                style="width: 80px"
-                onkeypress="return (/[\d-]/.test(String.fromCharCode(event.keyCode)))"
-                @input="validateInput('fphase',1)"
-                clearable
-            />
-          </el-form-item>
-          <el-form-item>
-            <el-button type="primary" :icon="Check" @click="onSubmit1" size="small">确定</el-button>
-            <el-button type="primary" :icon="Delete" @click="empty(1)" size="small">清空表格</el-button>
-          </el-form-item>
-        </el-form>
-        <!-- 电流通道内容 -->
-        <div class="table-container">
-          <el-table :data="form[1].harmList" border stripe size="small">
-            <el-table-column prop="harm" align="center" label="次数" width="60"/>
-            <el-table-column prop="famp" align="center" label="谐波含有率">
-              <template #default="{ row }">
-                <el-input type="number" v-if="row.show" v-model="row.famp"/>
-                <span v-else>{{ row.famp }}%</span>
-              </template>
-            </el-table-column>
-            <el-table-column prop="fphase" label="谐波相角" align="center">
-              <template #default="{ row }">
-                <el-input type="number" v-if="row.show" v-model="row.fphase"/>
-                <span v-else>{{ row.fphase }}°</span>
-              </template>
-            </el-table-column>
-            <el-table-column label="操作" align="center">
-              <template #default="{ row, $index }">
-                <el-button
-                    type="primary"
-                    link
-                    :icon="EditPen"
-                    v-if="!row.show"
-                    @click="row.show = true"
-                >
-                  编辑
-                </el-button>
-                <el-button type="primary" link :icon="Check" v-else @click="row.show = false">
-                  保存
-                </el-button>
-                <el-button type="primary" link :icon="Delete" @click="HarmFlagDelete(1, $index)">
-                  删除
-                </el-button>
-              </template>
-            </el-table-column>
-          </el-table>
-        </div>
-      </el-tab-pane>
-    </el-tabs>
-  </div>
-</template>
-
-<script setup lang="ts">
-import {Check, Delete, EditPen} from '@element-plus/icons-vue'
-import {ref} from 'vue'
-
-const props = defineProps({
-  childForm: {
-    type: Array as any,
-    required: true
-  }
-})
-
-const form: any = computed({
-  get() {
-    return props.childForm
-  },
-  set(value) {
-  }
-})
-const formInline = ref({
-  harm: [],
-  famp: '',
-  fphase: ''
-})
-const formInline1 = ref({
-  harm: [],
-  famp: '',
-  fphase: ''
-})
-
-// 定义表格数据项的类型
-interface TableItem {
-  date: string
-  harmonicRate?: string
-  harmonicPhase?: string
-  name?: string
-}
-
-const empty = (index: number) => {
-  props.childForm[index].harmList = []
-}
-const onSubmit = () => {
-  console.log('🚀 ~ onSubmit ~ props.childForm[0]:', props.childForm[0].harmList)
-  if (formInline.value.harm.length == 0 || formInline.value.famp == '' || formInline.value.fphase == '') {
-    ElMessage.warning('请填写值!')
-    return
-  }
-  if (formInline.value.harm.includes('0')) {
-    props.childForm[0].harmList = []
-    for (let i = 2; i < 51; i++) {
-      props.childForm[0].harmList.push({
-        harm: i, //间谐波次数
-        famp: formInline.value.famp, //间谐波含有率
-        fphase: formInline.value.fphase // 间谐波相角
-      })
-    }
-  } else {
-    formInline.value.harm.forEach((item: any) => {
-      props.childForm[0].harmList.push({
-        harm: item, //间谐波次数
-        famp: formInline.value.famp, //间谐波含有率
-        fphase: formInline.value.fphase // 间谐波相角
-      })
-    })
-    const seen = new Set()
-    const uniqueData = []
-
-    // 反向遍历数组
-    for (let i = props.childForm[0].harmList.length - 1; i >= 0; i--) {
-      const item = props.childForm[0].harmList[i]
-      // 如果 harm 还未出现过，则添加到结果数组
-      if (!seen.has(item.harm)) {
-        seen.add(item.harm)
-        uniqueData.unshift(item) // 添加到结果数组的开头
-      }
-    }
-    props.childForm[0].harmList = uniqueData.sort((a, b) => a.harm - b.harm)
-  }
-}
-const onSubmit1 = () => {
-  if (formInline1.value.harm.length == 0 || formInline1.value.famp == '' || formInline1.value.fphase == '') {
-    ElMessage.warning('请填写值!')
-    return
-  }
-  if (formInline1.value.harm.includes('0')) {
-    props.childForm[1].harmList = []
-    for (let i = 2; i < 51; i++) {
-      props.childForm[1].harmList.push({
-        harm: i, //间谐波次数
-        famp: formInline1.value.famp, //间谐波含有率
-        fphase: formInline1.value.fphase // 间谐波相角
-      })
-    }
-  } else {
-    formInline1.value.harm.forEach((item: any) => {
-      props.childForm[1].harmList.push({
-        harm: item, //间谐波次数
-        famp: formInline1.value.famp, //间谐波含有率
-        fphase: formInline1.value.fphase // 间谐波相角
-      })
-    })
-    const seen = new Set()
-    const uniqueData = []
-
-    // 反向遍历数组
-    for (let i = props.childForm[1].harmList.length - 1; i >= 0; i--) {
-      const item = props.childForm[1].harmList[i]
-      // 如果 harm 还未出现过，则添加到结果数组
-      if (!seen.has(item.harm)) {
-        seen.add(item.harm)
-        uniqueData.unshift(item) // 添加到结果数组的开头
-      }
-    }
-    props.childForm[1].harmList = uniqueData.sort((a, b) => a.harm - b.harm)
-  }
-}
-// 删除
-const HarmFlagDelete = (index: number, number: number) => {
-  props.childForm[index].harmList.splice(number, 1)
-}
-
-const validateInput = (type: string, index: number) => {
-  if (type == 'famp') {
-    if (Number(formInline.value.famp) < 0 || Number(formInline1.value.famp) < 0) {
-      ElMessage.warning("含有率不能低于0")
-      if (index == 0) {
-        formInline.value.famp = '0'
-      }
-      if (index == 1) {
-        formInline1.value.famp = '0'
-      }
-    }
-    if (Number(formInline.value.famp) > 200 || Number(formInline1.value.famp) > 200) {
-      ElMessage.warning("含有率不能高于200")
-      if (index == 0) {
-        formInline.value.famp = '200'
-      }
-      if (index == 1) {
-        formInline1.value.famp = '200'
-      }
-    }
-  }
-  if (type == 'fphase') {
-    if (Number(formInline.value.fphase) < -360 || Number(formInline1.value.fphase) < -360) {
-      ElMessage.warning("相角不能低于-360°")
-      if (index == 0) {
-        formInline.value.fphase = '-360';
-      }
-      if (index == 1) {
-        formInline1.value.fphase = '-360';
-      }
-    } else if (Number(formInline.value.fphase) > 360 || Number(formInline1.value.fphase) > 360) {
-      ElMessage.warning("相角不能高于360°")
-      if (index == 0) {
-        formInline.value.fphase = '360';
-      }
-      if (index == 1) {
-        formInline1.value.fphase = '360';
-      }
-    }
-  }
-}
-</script>
-
-<style lang="scss" scoped>
-.tabs-container {
-  display: flex;
-  justify-content: space-between; /* 使两个 el-tabs 之间有间距 */
-  height: 100%;
-}
-
-.right-tabs {
-  flex: 1; /* 使两个 el-tabs 占据相同的空间 */
-  margin-right: 10px; /* 可选：添加右侧间距 */
-}
-
-.el-tabs {
-  flex: 1; /* 使两个 el-tabs 占据相同的空间 */
-}
-
-.table-container {
-  display: flex;
-  justify-content: space-between; /* 使两个表格之间有间距 */
-  width: 100%;
-}
-
-.half-width-table {
-  flex: 1; /* 使两个表格占据相同的空间 */
-  margin-right: 10px; /* 可选：添加表格之间的间距 */
-}
-
-.half-width-table:last-child {
-  margin-right: 0; /* 最后一个表格不需要右侧间距 */
-}
-
-.input-label-container {
-  display: flex;
-  align-items: center; /* 垂直居中对齐 */
-}
-
-.input-label-container label {
-  margin-left: 5px; /* 添加标签与输入框之间的间距 */
-}
-
-// 全局css 加上以下代码，可以隐藏上下箭头
-
-// 取消input的上下箭头
-</style>
+<template>
+  <div class="tabs-container">
+    <el-tabs type="border-card" class="right-tabs" style="height: 100%">
+      <el-tab-pane label="电压通道">
+        <el-form :inline="true" :model="formInline" :disabled="!props.childForm[0].harmFlag">
+          <el-form-item label="次数">
+            <el-select
+                v-model="formInline.harm"
+                multiple
+                collapse-tags
+                collapse-tags-tooltip
+                style="width: 160px"
+                filterable
+                clearable
+            >
+              <el-option label="全部" value="0"/>
+              <el-option v-for="item in 49" :key="item" :label="item + 1" :value="item + 1"/>
+            </el-select>
+          </el-form-item>
+          <el-form-item label="含有率">
+            <el-input
+                v-model="formInline.famp"
+                type="number"
+                placeholder="含有率"
+                style="width: 80px"
+                onkeypress="return (/[\d.]/.test(String.fromCharCode(event.keyCode)))"
+                @input="validateInput('famp',0)"
+                clearable
+            />
+          </el-form-item>
+          <el-form-item label="相角">
+            <el-input
+                v-model="formInline.fphase"
+                type="number"
+                placeholder="相角"
+                style="width: 80px"
+                onkeypress="return (/[\d-]/.test(String.fromCharCode(event.keyCode)))"
+                @input="validateInput('fphase',0)"
+                clearable
+            />
+          </el-form-item>
+          <el-form-item>
+            <el-button type="primary" :icon="Check" @click="onSubmit" size="small">确定</el-button>
+            <el-button type="primary" :icon="Delete" @click="empty(0)" size="small">清空表格</el-button>
+          </el-form-item>
+        </el-form>
+        <!-- 电压通道内容 -->
+        <div class="table-container">
+          <el-table :data="form[0].harmList" border stripe size="small">
+            <el-table-column prop="harm" align="center" label="次数" width="60"/>
+            <el-table-column prop="famp" align="center" label="谐波含有率">
+              <template #default="{ row }">
+                <el-input type="number" v-if="row.show" v-model="row.famp"/>
+                <span v-else>{{ row.famp }}%</span>
+              </template>
+            </el-table-column>
+            <el-table-column prop="fphase" label="谐波相角" align="center">
+              <template #default="{ row }">
+                <el-input type="number" v-if="row.show" v-model="row.fphase"/>
+                <span v-else>{{ row.fphase }}°</span>
+              </template>
+            </el-table-column>
+            <el-table-column label="操作" align="center">
+              <template #default="{ row, $index }">
+                <el-button
+                    type="primary"
+                    link
+                    :icon="EditPen"
+                    v-if="!row.show"
+                    @click="row.show = true"
+                >
+                  编辑
+                </el-button>
+                <el-button type="primary" link :icon="Check" v-else @click="row.show = false">
+                  保存
+                </el-button>
+                <el-button type="primary" link :icon="Delete" @click="HarmFlagDelete(0, $index)">
+                  删除
+                </el-button>
+              </template>
+            </el-table-column>
+          </el-table>
+        </div>
+      </el-tab-pane>
+    </el-tabs>
+    <el-tabs type="border-card" style="height: 100%">
+      <el-tab-pane label="电流通道">
+        <el-form :inline="true" :model="formInline1" :disabled="!props.childForm[1].harmFlag">
+          <el-form-item label="次数">
+            <el-select
+                v-model="formInline1.harm"
+                multiple
+                collapse-tags
+                collapse-tags-tooltip
+                style="width: 160px"
+                filterable
+                clearable
+            >
+              <el-option label="全部" value="0"/>
+              <el-option v-for="item in 49" :key="item" :label="item + 1" :value="item + 1"/>
+            </el-select>
+          </el-form-item>
+          <el-form-item label="含有率">
+            <el-input
+                v-model="formInline1.famp"
+                type="number"
+                placeholder="含有率"
+                style="width: 80px"
+                onkeypress="return (/[\d]/.test(String.fromCharCode(event.keyCode)))"
+                @input="validateInput('famp',1)"
+                clearable
+            />
+          </el-form-item>
+          <el-form-item label="相角">
+            <el-input
+                v-model="formInline1.fphase"
+                type="number"
+                placeholder="相角"
+                style="width: 80px"
+                onkeypress="return (/[\d-]/.test(String.fromCharCode(event.keyCode)))"
+                @input="validateInput('fphase',1)"
+                clearable
+            />
+          </el-form-item>
+          <el-form-item>
+            <el-button type="primary" :icon="Check" @click="onSubmit1" size="small">确定</el-button>
+            <el-button type="primary" :icon="Delete" @click="empty(1)" size="small">清空表格</el-button>
+          </el-form-item>
+        </el-form>
+        <!-- 电流通道内容 -->
+        <div class="table-container">
+          <el-table :data="form[1].harmList" border stripe size="small">
+            <el-table-column prop="harm" align="center" label="次数" width="60"/>
+            <el-table-column prop="famp" align="center" label="谐波含有率">
+              <template #default="{ row }">
+                <el-input type="number" v-if="row.show" v-model="row.famp"/>
+                <span v-else>{{ row.famp }}%</span>
+              </template>
+            </el-table-column>
+            <el-table-column prop="fphase" label="谐波相角" align="center">
+              <template #default="{ row }">
+                <el-input type="number" v-if="row.show" v-model="row.fphase"/>
+                <span v-else>{{ row.fphase }}°</span>
+              </template>
+            </el-table-column>
+            <el-table-column label="操作" align="center">
+              <template #default="{ row, $index }">
+                <el-button
+                    type="primary"
+                    link
+                    :icon="EditPen"
+                    v-if="!row.show"
+                    @click="row.show = true"
+                >
+                  编辑
+                </el-button>
+                <el-button type="primary" link :icon="Check" v-else @click="row.show = false">
+                  保存
+                </el-button>
+                <el-button type="primary" link :icon="Delete" @click="HarmFlagDelete(1, $index)">
+                  删除
+                </el-button>
+              </template>
+            </el-table-column>
+          </el-table>
+        </div>
+      </el-tab-pane>
+    </el-tabs>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {Check, Delete, EditPen} from '@element-plus/icons-vue'
+import {ref} from 'vue'
+
+const props = defineProps({
+  childForm: {
+    type: Array as any,
+    required: true
+  }
+})
+
+const form: any = computed({
+  get() {
+    return props.childForm
+  },
+  set(value) {
+  }
+})
+const formInline = ref({
+  harm: [],
+  famp: '',
+  fphase: ''
+})
+const formInline1 = ref({
+  harm: [],
+  famp: '',
+  fphase: ''
+})
+
+// 定义表格数据项的类型
+interface TableItem {
+  date: string
+  harmonicRate?: string
+  harmonicPhase?: string
+  name?: string
+}
+
+const empty = (index: number) => {
+  props.childForm[index].harmList = []
+}
+const onSubmit = () => {
+  if (formInline.value.harm.length == 0 || formInline.value.famp == '' || formInline.value.fphase == '') {
+    ElMessage.warning('请填写值!')
+    return
+  }
+  if (formInline.value.harm.includes('0')) {
+    props.childForm[0].harmList = []
+    for (let i = 2; i < 51; i++) {
+      props.childForm[0].harmList.push({
+        harm: i, //间谐波次数
+        famp: formInline.value.famp, //间谐波含有率
+        fphase: formInline.value.fphase // 间谐波相角
+      })
+    }
+  } else {
+    formInline.value.harm.forEach((item: any) => {
+      props.childForm[0].harmList.push({
+        harm: item, //间谐波次数
+        famp: formInline.value.famp, //间谐波含有率
+        fphase: formInline.value.fphase // 间谐波相角
+      })
+    })
+    const seen = new Set()
+    const uniqueData = []
+
+    // 反向遍历数组
+    for (let i = props.childForm[0].harmList.length - 1; i >= 0; i--) {
+      const item = props.childForm[0].harmList[i]
+      // 如果 harm 还未出现过，则添加到结果数组
+      if (!seen.has(item.harm)) {
+        seen.add(item.harm)
+        uniqueData.unshift(item) // 添加到结果数组的开头
+      }
+    }
+    props.childForm[0].harmList = uniqueData.sort((a, b) => a.harm - b.harm)
+  }
+}
+const onSubmit1 = () => {
+  if (formInline1.value.harm.length == 0 || formInline1.value.famp == '' || formInline1.value.fphase == '') {
+    ElMessage.warning('请填写值!')
+    return
+  }
+  if (formInline1.value.harm.includes('0')) {
+    props.childForm[1].harmList = []
+    for (let i = 2; i < 51; i++) {
+      props.childForm[1].harmList.push({
+        harm: i, //间谐波次数
+        famp: formInline1.value.famp, //间谐波含有率
+        fphase: formInline1.value.fphase // 间谐波相角
+      })
+    }
+  } else {
+    formInline1.value.harm.forEach((item: any) => {
+      props.childForm[1].harmList.push({
+        harm: item, //间谐波次数
+        famp: formInline1.value.famp, //间谐波含有率
+        fphase: formInline1.value.fphase // 间谐波相角
+      })
+    })
+    const seen = new Set()
+    const uniqueData = []
+
+    // 反向遍历数组
+    for (let i = props.childForm[1].harmList.length - 1; i >= 0; i--) {
+      const item = props.childForm[1].harmList[i]
+      // 如果 harm 还未出现过，则添加到结果数组
+      if (!seen.has(item.harm)) {
+        seen.add(item.harm)
+        uniqueData.unshift(item) // 添加到结果数组的开头
+      }
+    }
+    props.childForm[1].harmList = uniqueData.sort((a, b) => a.harm - b.harm)
+  }
+}
+// 删除
+const HarmFlagDelete = (index: number, number: number) => {
+  props.childForm[index].harmList.splice(number, 1)
+}
+
+const validateInput = (type: string, index: number) => {
+  if (type == 'famp') {
+    if (Number(formInline.value.famp) < 0 || Number(formInline1.value.famp) < 0) {
+      ElMessage.warning("含有率不能低于0")
+      if (index == 0) {
+        formInline.value.famp = '0'
+      }
+      if (index == 1) {
+        formInline1.value.famp = '0'
+      }
+    }
+    if (Number(formInline.value.famp) > 200 || Number(formInline1.value.famp) > 200) {
+      ElMessage.warning("含有率不能高于200")
+      if (index == 0) {
+        formInline.value.famp = '200'
+      }
+      if (index == 1) {
+        formInline1.value.famp = '200'
+      }
+    }
+  }
+  if (type == 'fphase') {
+    if (Number(formInline.value.fphase) < -360 || Number(formInline1.value.fphase) < -360) {
+      ElMessage.warning("相角不能低于-360°")
+      if (index == 0) {
+        formInline.value.fphase = '-360';
+      }
+      if (index == 1) {
+        formInline1.value.fphase = '-360';
+      }
+    } else if (Number(formInline.value.fphase) > 360 || Number(formInline1.value.fphase) > 360) {
+      ElMessage.warning("相角不能高于360°")
+      if (index == 0) {
+        formInline.value.fphase = '360';
+      }
+      if (index == 1) {
+        formInline1.value.fphase = '360';
+      }
+    }
+  }
+}
+</script>
+
+<style lang="scss" scoped>
+.tabs-container {
+  display: flex;
+  justify-content: space-between; /* 使两个 el-tabs 之间有间距 */
+  height: 100%;
+}
+
+.right-tabs {
+  flex: 1; /* 使两个 el-tabs 占据相同的空间 */
+  margin-right: 10px; /* 可选：添加右侧间距 */
+}
+
+.el-tabs {
+  flex: 1; /* 使两个 el-tabs 占据相同的空间 */
+}
+
+.table-container {
+  display: flex;
+  justify-content: space-between; /* 使两个表格之间有间距 */
+  width: 100%;
+}
+
+.half-width-table {
+  flex: 1; /* 使两个表格占据相同的空间 */
+  margin-right: 10px; /* 可选：添加表格之间的间距 */
+}
+
+.half-width-table:last-child {
+  margin-right: 0; /* 最后一个表格不需要右侧间距 */
+}
+
+.input-label-container {
+  display: flex;
+  align-items: center; /* 垂直居中对齐 */
+}
+
+.input-label-container label {
+  margin-left: 5px; /* 添加标签与输入框之间的间距 */
+}
+
+// 全局css 加上以下代码，可以隐藏上下箭头
+
+// 取消input的上下箭头
+</style>

frontend/src/views/machine/testScript/components/testScriptInHarmTab.vue

@@ -206,7 +206,6 @@ const empty = (index: number) => {
     props.childForm[index].inharmList = []
 }
 const onSubmit = () => {
-    console.log('🚀 ~ onSubmit ~ props.childForm[0]:', props.childForm[0].inharmList)
     if (formInline.value.inharm.length == 0 || formInline.value.famp == '' || formInline.value.fphase == '') {
         ElMessage.warning('请填写值!')
         return

frontend/src/views/machine/testScript/components/testScriptPopup.vue

@@ -224,7 +224,6 @@ const open = async (title: string, row: any) => {
     } else {
         let list = JSON.parse(row)
         formContent.value = list
-        console.log('🚀 ~ open ~ list:', formContent.value)
         show.value = true
     }
     // 重置表单
@@ -243,7 +242,6 @@ const treeInfo = async (currentMode: string) => {
     const result = await getDictTreeByCode(data)
     const result1 = (await getDictTreeByCode({ ...data, code: 'Script_Error' })).data[0].children
     const allOptions = await convertToOptions(result.data as Dict.ResDictTree[])
-    //console.log('🚀 ~ treeInfo ~ result1:', allOptions[0]?.children)
     const setallTree = await setTree(allOptions[0]?.children, result1)
     secondLevelOptions.push(...(setallTree || []))
     modeId.value = dictStore.getDictData('Pattern').find(item => item.name === currentMode)?.id