Fork: 0
codedev / xc-business-system
Transfer to URL with SHA Find file
Newer
Older
xc-business-system / src / views / business / taskMeasure / measureData / components / thirteenth / templateDetail.vue
dutingting on 2 Dec 80 KB 临时提交
Raw Blame History 
<!-- 第13套：示波器检定装置 -->
<!-- 检定数据管理详情模板 -->
<script lang="ts" setup name="MeasureDataTemplateDetail">
import { ref } from 'vue'
import { ElLoading, ElMessage } from 'element-plus'
import dayjs from 'dayjs'
import changeRecord from '../changeRecord.vue'
import selectStandard from '../../dialog/selectStandardDialog.vue'
import categoryNameDict from '/public/config/categoryNameDict.json'
import TemplateFormAndTable from '../templateFormAndTable.vue'
import { useSolveFormData } from '../useSolveFormData'
import type { IDetailMeasureList } from './thirteenth-interface'
import templateTable from './templateTable.vue'
import useUserStore from '@/store/modules/user'
import type { dictType } from '@/global'
import { getDictByCode } from '@/api/system/dict'
import type { TableColumn } from '@/components/NormalTable/table_interface'
import { calculateHandle, getInfo } from '@/api/business/taskMeasure/measureData'
import { getInfo as getItemInfo } from '@/api/business/measure/item'
import { useCheckList } from '@/commonMethods/useCheckList'
import { calc } from '@/utils/useCalc'
import { useMergeTableRow } from '@/commonMethods/useMergeTableRow'
import { useScientificNotation } from '@/commonMethods/useScientificNotation'

const props = defineProps({
  infoId: String, // id
  dataNo: String, // 检定数据编号
})
const emits = defineEmits(['giveInfoId', 'changeMeterIdentify'])
const user = useUserStore() // 用户信息
const $router = useRouter() // 关闭页面使用
const $route = useRoute() // 路由参数
const ruleFormRef = ref() // 表单ref
const templateFormAndTableRef = ref() // 表单和被检设备、测量设备表格公共组件ref
const itemFormData = ref({ // 有关于检定项的数据
  itemId: '', // 检定项id
  itemCategoryName: '', // 设备检定项分类名称
  itemCategoryId: '', // 设备检定项分类名称id
  belongStandardEquipment: '', // 标准装置code
  belongStandardEquipmentName: '', // 标准装置名称

  methodType: '', // 时基方法
  appearance: 1, // 外观及功能性检查
  appearanceFunctionCheck: '正常', // 外观及功能性检查
  timeBase: 1, // 时基(示波器-数字)
  currentGain: 1, // 直流增益(示波器-数字)
  currentBias: 1, // 直流偏置(示波器-数字)
  bandWidth: 1, // 频带宽度(示波器-数字/模拟)
  triggerSensitivity: 1, // 触发灵敏度(示波器-数字)
  riseTime: 1, // 上升时间(示波器-数字/模拟)
  inputResistance: 1, // 输入电阻(示波器-数字/模拟)
  calibratingSignal: 1, // 校准信号(示波器-数字/模拟)
  scanTimeCoefficient: 1, // 扫描时间系数及扩展(示波器-模拟)
  triggerCharacter: 1, // 触发特性(示波器-模拟)
  verticalAmplitude: 1, // 垂直幅度(示波器-模拟)

  remark: '', // 备注
})
// -------------------------------------------路由参数------------------------------------------
const pageType = ref('add') // 页面类型: add, edit, detail
const infoId = ref('') // 列表id
if ($route.params && $route.params.type) {
  pageType.value = $route.params.type as string

  if ($route.params.id) {
    infoId.value = $route.params.id as string
  }
}

// ------------------------------------------标签----------------------------------------------------------
const radioMenus = ref([ // 标签内容
  { name: '检定数据', value: 'measure-data' },
  { name: '历史修改记录', value: 'change-record' },
])
const current = ref('measure-data') // 选择的tab 默认基本信息

// ---------------------------------------检定项数据表格----------------------------------------------------
const timeBaseList = ref<IDetailMeasureList[]>([]) // 时基
const zeroFrequencyGainList = ref<IDetailMeasureList[]>([]) // 直流增益
const DCBiasList = ref<IDetailMeasureList[]>([]) // 直流偏置
const frequencyBandwidthList = ref<IDetailMeasureList[]>([]) // 频带宽度(数字示波器)
const triggerSensitivityList = ref<IDetailMeasureList[]>([]) // 触发灵敏度
const risetimeList = ref<IDetailMeasureList[]>([]) // 上升时间(数字示波器)
const inputResistanceList = ref<IDetailMeasureList[]>([]) // 输入电阻(数字示波器)
const calibratingSignalList = ref<IDetailMeasureList[]>([]) // 校准信号(数字示波器)
const scanningTimeList = ref<IDetailMeasureList[]>([]) // 扫描时间系数及扩展
const verticalSizeList = ref<IDetailMeasureList[]>([]) // 垂直幅度
const frequencyBandwidthSimulateList = ref<IDetailMeasureList[]>([]) // 频带宽度(模拟示波器)
const triggerCharacteristicList = ref<IDetailMeasureList[]>([]) // 触发特性
const inputResistanceSimulateList = ref<IDetailMeasureList[]>([]) // 输入电阻(模拟示波器)
const risetimeSimulateList = ref<IDetailMeasureList[]>([]) // 上升时间(模拟示波器)
const calibratingSignalSimulateList = ref<IDetailMeasureList[]>([]) // 校准信号(模拟示波器)

const timeBaseLoading = ref(false) // 时基
const zeroFrequencyGainLoading = ref(false) // 直流增益
const DCBiasLoading = ref(false) // 直流偏置
const frequencyBandwidthLoading = ref(false) // 频带宽度(数字示波器)
const triggerSensitivityLoading = ref(false) // 触发灵敏度
const risetimeLoading = ref(false) // 上升时间(数字示波器)
const inputResistanceLoading = ref(false) // 输入电阻(数字示波器)
const calibratingSignalLoading = ref(false) // 校准信号(数字示波器)
const scanningTimeLoading = ref(false) // 扫描时间系数及扩展
const verticalSizeLoading = ref(false) // 垂直幅度
const frequencyBandwidthSimulateLoading = ref(false) // 频带宽度(模拟示波器)
const triggerCharacteristicLoading = ref(false) // 触发特性
const inputResistanceSimulateLoading = ref(false) // 输入电阻(模拟示波器)
const risetimeSimulateLoading = ref(false) // 上升时间(模拟示波器)
const calibratingSignalSimulateLoading = ref(false) // 校准信号(模拟示波器)

const columns_time_base_method1 = ref<TableColumn[]>([ // 时基--方法一
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '周期时标信号', value: 'cycleSignalDefineFront', align: 'center', required: true },
  { text: '时基绝对误差△T/ns', value: 'timeBaseAbsoluteError', align: 'center', required: true, width: '180' },
  { text: '时基相对误差△δ', value: 'timeBaseRelativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_time_base_method2 = ref<TableColumn[]>([ // 时基--方法二
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '参考输出', value: 'cycleSignalDefineFront', align: 'center', required: true },
  { text: '差拍波形频率测量值（Hz）', value: 'timeBaseAbsoluteError', align: 'center', required: true, width: '180' },
  { text: '时基相对误差△δ', value: 'timeBaseRelativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_zero_frequency_gain = ref<TableColumn[]>([ // 直流增益
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '垂直偏转系数(/div)', value: 'verticalDeflectCoefficientDefineFront', align: 'center', required: true },
  { text: '标准值', value: 'standardValueDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '180' },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_DC_bias = ref<TableColumn[]>([ // 直流偏置
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '垂直偏转系数(/div)', value: 'verticalDeflectCoefficientDefineFront', align: 'center', required: true },
  { text: '标准值', value: 'standardValue', align: 'center', required: true, width: '180' },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '180' },
  { text: '误差', value: 'errorValue', align: 'center', required: false },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_frequency_bandwidth = ref<TableColumn[]>([ // 频带宽度（数字示波器）
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '垂直偏转系数(/div)', value: 'verticalDeflectCoefficientDefineFront', align: 'center', required: true },
  { text: '频带宽度', value: 'bandWidthDefineFront', align: 'center', required: true },
  { text: '参考幅度', value: 'referenceAmplitude', align: 'center', required: true, width: '180' },
  { text: '参考幅度单位', value: 'referenceAmplitudeUnit', align: 'center', required: true, width: '120' },
  { text: '测量幅度', value: 'measureAmplitude', align: 'center', required: true, width: '180' },
  { text: '测量幅度单位', value: 'measureAmplitudeUnit', align: 'center', required: true, width: '120' },
  { text: '分贝数(dB)', value: 'decibelNumber', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_trigger_sensitivity = ref<TableColumn[]>([ // 触发灵敏度
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '110' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '触发类型', value: 'triggerType', align: 'center', required: true },
  { text: '信号频率', value: 'signalFrequencyDefineFront', align: 'center', required: true },
  { text: '标称值', value: 'nominalValueDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_risetime = ref<TableColumn[]>([ // 上升时间(数字示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '垂直偏转系数(/div)', value: 'verticalDeflectCoefficientDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '180' },
  { text: '测量值单位', value: 'measureValueUnit', align: 'center', required: true, width: '120' },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_input_resistance = ref<TableColumn[]>([ // 输入电阻(数字示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '标称值', value: 'nominalValueDefineFront', align: 'center', required: true },
  { text: '垂直偏转系数(/div)', value: 'verticalDeflectCoefficientDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_calibrating_signal = ref<TableColumn[]>([ // 校准信号(数字示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true },
  { text: '项目', value: 'itemType', align: 'center', required: true },
  { text: '标称值', value: 'nominalValueDefineFront', align: 'center', required: true },
  { text: '顶部测量值', value: 'topMeasureValue', align: 'center', required: true, width: '220' },
  { text: '底部测量值', value: 'bottomMeasureValue', align: 'center', required: true, width: '220' },
  { text: '测量值', value: 'measureValue', align: 'center', required: false, width: '220' },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
])

const columns_scan_time = ref<TableColumn[]>([ // 扫描时间系数及扩展
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '160' },
  { text: '扫描方式', value: 'scanType', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '水平刻度档位', value: 'horizontalScaleGearDefineFront', align: 'center', required: true },
  { text: '标称值', value: 'nominalValue', align: 'center', required: true, width: '220' },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_vertical_size = ref<TableColumn[]>([ // 垂直幅度
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '垂直刻度档位', value: 'verticalScaleGearDefineFront', align: 'center', required: true },
  { text: '标称值', value: 'nominalValueDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_frequency_bandwidth_simulate = ref<TableColumn[]>([ // 频带宽度（模拟示波器）
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '垂直刻度档位', value: 'verticalScaleGearDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_trigger_characteristic = ref<TableColumn[]>([ // 触发特性
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '扫描方式', value: 'scanType', align: 'center', required: true },
  { text: '触发类型', value: 'triggerType', align: 'center', required: true },
  { text: '频率上限', value: 'frequencyUpperDefineFront', align: 'center', required: true },
  { text: '输出信号幅度', value: 'outputSignalAmplitude', align: 'center', required: true, width: '220' },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '触发特性', value: 'conclusion', align: 'center', required: false },
])

const columns_input_resistance_simulate = ref<TableColumn[]>([ // 输入电阻(模拟示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '测量值', value: 'measureValue', align: 'center', required: true, width: '220' },
  { text: '相对误差', value: 'relativeError', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_risetime_simulate = ref<TableColumn[]>([ // 上升时间(模拟示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '通道', value: 'thoroughfare', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '垂直刻度档位', value: 'verticalScaleGearDefineFront', align: 'center', required: true },
  { text: '水平刻度档位', value: 'horizontalScaleGearDefineFront', align: 'center', required: true },
  { text: '标称值', value: 'nominalValue', align: 'center', required: true, width: '220' },
  { text: '上升时间', value: 'riseTime', align: 'center', required: true, width: '220' },
  { text: '修正上升时间', value: 'correctRiseTime', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])

const columns_calibrating_signal_simulate = ref<TableColumn[]>([ // 校准信号(模拟示波器)
  { text: '检定项目', value: 'params', align: 'center', required: true, width: '90' },
  { text: '信号类型', value: 'signalType', align: 'center', required: true },
  { text: '阻抗', value: 'impedanceDefineFront', align: 'center', required: true },
  { text: '幅度标称值', value: 'nominalAmplitudeValueDefineFront', align: 'center', required: true },
  { text: '幅度测量值', value: 'measureAmplitudeValue', align: 'center', required: true, width: '220' },
  { text: '幅度偏差', value: 'amplitudeDeviation', align: 'center', required: false },
  { text: '频率标称值', value: 'nominalFrequencyValueDefineFront', align: 'center', required: true },
  { text: '频率测量值', value: 'measureFrequencyValue', align: 'center', required: true, width: '220' },
  { text: '频率偏差', value: 'frequencyDeviation', align: 'center', required: false },
  { text: '技术指标', value: 'technicalIndexDefineFront', align: 'center', required: false },
  { text: '结论', value: 'conclusion', align: 'center', required: false },
])
// -------------------------------------------获取详情信息--------------------------------------------------
// 获取页面详情信息
const fetchInfo = () => {
  const loading = ElLoading.service({
    lock: true,
    background: 'rgba(255, 255, 255, 0.8)',
  })
  getInfo({
    id: infoId.value,
    belongStandardEquipment: itemFormData.value.belongStandardEquipment,
    // 我的任务跳转过来如果已经配置过检定项了，到编辑页面，且用一下三个字段替代传id请求详情
    itemId: $route.query.itemId, // 检定项id
    orderId: $route.query.orderId, // 任务单id
    sampleId: $route.query.sampleId, // 被检设备id
  }).then((res) => {
    // 有关于检定项的数据
    itemFormData.value.itemId = res.data.itemId // 检定项id
    itemFormData.value.itemCategoryName = res.data.itemCategoryName // 设备检定项分类名称
    itemFormData.value.itemCategoryId = res.data.itemCategoryId ? res.data.itemCategoryId : itemFormData.value.itemCategoryId // 设备检定项分类名称id
    itemFormData.value.appearanceFunctionCheck = `${res.data.appearanceFunctionCheck}` // 外观（1/0）
    itemFormData.value.remark = res.data.remark // 结论、备注
    // =======================================表单公共组件数据处理=======================================================
    useSolveFormData(res, templateFormAndTableRef.value)
    // ==================================检定数据========================================================================
    const data = res.data.measureDataOscilloscopeList
    if (itemFormData.value.itemCategoryName === '数字示波器') {
      // 时基
      timeBaseList.value = data.filter((item: any) => `${item.dataType}` === '1')
      timeBaseList.value = timeBaseList.value.map((item: any) => {
        return {
          ...item,
          params: '时基',
          cycleSignalDefineFront: item.cycleSignal + item.cycleSignalUnit, // 周期时标信号
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.timeBase = timeBaseList.value.length > 0 ? 1 : 0 // 时基

      // 直流增益
      zeroFrequencyGainList.value = data.filter((item: any) => `${item.dataType}` === '2')
      zeroFrequencyGainList.value = zeroFrequencyGainList.value.map((item: any) => {
        return {
          ...item,
          params: '直流增益',
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
          standardValueDefineFront: item.standardValue + item.standardValueUnit, // 标准值
          measureValueUnit: item.standardValueUnit, // 测量值单位
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.currentGain = zeroFrequencyGainList.value.length > 0 ? 1 : 0
      useMergeTableRow(zeroFrequencyGainList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 直流偏置
      DCBiasList.value = data.filter((item: any) => `${item.dataType}` === '3')
      DCBiasList.value = DCBiasList.value.map((item: any) => {
        return {
          ...item,
          params: '直流偏置',
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          thoroughfare: item.thoroughfare, // 通道
          verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
          standardValue: item.standardValue, // 标准值
          measureValueUnit: item.standardValueUnit, // 测量值单位
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.currentBias = DCBiasList.value.length > 0 ? 1 : 0
      useMergeTableRow(DCBiasList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 频带宽度(数字示波器)
      frequencyBandwidthList.value = data.filter((item: any) => `${item.dataType}` === '4')
      frequencyBandwidthList.value = frequencyBandwidthList.value.map((item: any) => {
        return {
          ...item,
          params: '频带宽度',
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          thoroughfare: item.thoroughfare, // 通道
          verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
          bandWidthDefineFront: item.bandWidth + item.bandWidthUnit, // 频带宽度
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.bandWidth = frequencyBandwidthList.value.length > 0 ? 1 : 0
      useMergeTableRow(frequencyBandwidthList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 触发灵敏度
      triggerSensitivityList.value = data.filter((item: any) => `${item.dataType}` === '5')
      triggerSensitivityList.value = triggerSensitivityList.value.map((item: any) => {
        return {
          ...item,
          params: '触发灵敏度',
          thoroughfare: item.thoroughfare, // 通道
          triggerType: item.triggerType, // 触发类型
          signalFrequencyDefineFront: item.signalFrequency + item.signalFrequencyUnit, // 信号频率
          nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
          measureValueUnit: item.nominalValueUnit, // 测量值单位
        }
      })
      itemFormData.value.triggerSensitivity = triggerSensitivityList.value.length > 0 ? 1 : 0
      useMergeTableRow(triggerSensitivityList.value, ['thoroughfare']) // 合并单元格

      // 上升时间
      risetimeList.value = data.filter((item: any) => `${item.dataType}` === '6')
      risetimeList.value = risetimeList.value.map((item: any) => {
        return {
          ...item,
          params: '上升时间',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.riseTime = risetimeList.value.length > 0 ? 1 : 0
      useMergeTableRow(risetimeList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 输入电阻
      inputResistanceList.value = data.filter((item: any) => `${item.dataType}` === '7')
      inputResistanceList.value = inputResistanceList.value.map((item: any) => {
        return {
          ...item,
          params: '输入电阻',
          thoroughfare: item.thoroughfare, // 通道
          nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
          verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
          measureValueUnit: item.nominalValueUnit, // 测量值单位
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.inputResistance = inputResistanceList.value.length > 0 ? 1 : 0
      useMergeTableRow(inputResistanceList.value, ['thoroughfare', 'nominalValueDefineFront']) // 合并单元格

      // 校准信号
      calibratingSignalList.value = data.filter((item: any) => `${item.dataType}` === '8')
      calibratingSignalList.value = calibratingSignalList.value.map((item: any) => {
        return {
          ...item,
          params: '校准信号',
          itemType: item.itemType, // 项目
          nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
          topMeasureValue: item.itemType === '频率' ? '-' : item.topMeasureValue, // 顶部测量值
          bottomMeasureValue: item.itemType === '频率' ? '-' : item.bottomMeasureValue, // 底部测量值
        }
      })
      itemFormData.value.calibratingSignal = calibratingSignalList.value.length > 0 ? 1 : 0
    }
    else if (itemFormData.value.itemCategoryName === '模拟示波器') {
      // 扫描时间系数及扩展
      scanningTimeList.value = data.filter((item: any) => `${item.dataType}` === '1')
      scanningTimeList.value = scanningTimeList.value.map((item: any) => {
        return {
          ...item,
          params: '扫描时间系数及扩展',
          scanType: item.scanType, // 扫描方式
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          horizontalScaleGearDefineFront: item.horizontalScaleGear + item.horizontalScaleGearUnit, // 阻抗
          nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.scanTimeCoefficient = scanningTimeList.value.length > 0 ? 1 : 0
      useMergeTableRow(scanningTimeList.value, ['scanType', 'impedanceDefineFront']) // 合并单元格

      // 垂直幅度
      verticalSizeList.value = data.filter((item: any) => `${item.dataType}` === '2')
      verticalSizeList.value = verticalSizeList.value.map((item: any) => {
        return {
          ...item,
          params: '垂直幅度',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
          nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.verticalAmplitude = verticalSizeList.value.length > 0 ? 1 : 0
      useMergeTableRow(verticalSizeList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 频带宽度
      frequencyBandwidthSimulateList.value = data.filter((item: any) => `${item.dataType}` === '3')
      frequencyBandwidthSimulateList.value = frequencyBandwidthSimulateList.value.map((item: any) => {
        return {
          ...item,
          params: '频带宽度',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.bandWidth = frequencyBandwidthSimulateList.value.length > 0 ? 1 : 0
      useMergeTableRow(frequencyBandwidthSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 触发特性
      triggerCharacteristicList.value = data.filter((item: any) => `${item.dataType}` === '4')
      triggerCharacteristicList.value = triggerCharacteristicList.value.map((item: any) => {
        return {
          ...item,
          params: '触发特性',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          scanType: item.scanType, // 扫描方式
          triggerType: item.triggerType, // 触发类型
          frequencyUpperDefineFront: item.frequencyUpper + item.frequencyUpperUnit, // 频率上限
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.triggerCharacter = triggerCharacteristicList.value.length > 0 ? 1 : 0
      useMergeTableRow(triggerCharacteristicList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 输入电阻（模拟示波器）
      inputResistanceSimulateList.value = data.filter((item: any) => `${item.dataType}` === '5')
      inputResistanceSimulateList.value = inputResistanceSimulateList.value.map((item: any) => {
        return {
          ...item,
          params: '输入电阻',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.inputResistance = inputResistanceSimulateList.value.length > 0 ? 1 : 0
      useMergeTableRow(inputResistanceSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 上升时间（模拟示波器）
      risetimeSimulateList.value = data.filter((item: any) => `${item.dataType}` === '6')
      risetimeSimulateList.value = risetimeSimulateList.value.map((item: any) => {
        return {
          ...item,
          params: '上升时间',
          thoroughfare: item.thoroughfare, // 通道
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
          horizontalScaleGearDefineFront: item.horizontalScaleGear + item.horizontalScaleGearUnit, // 水平刻度档位
          amplitude: item.amplitude, // 幅度
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.riseTime = risetimeSimulateList.value.length > 0 ? 1 : 0
      useMergeTableRow(risetimeSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

      // 校准信号（模拟示波器）
      calibratingSignalSimulateList.value = data.filter((item: any) => `${item.dataType}` === '7')
      calibratingSignalSimulateList.value = calibratingSignalSimulateList.value.map((item: any) => {
        return {
          ...item,
          params: '校准信号',
          signalType: item.signalType, // 信号类型
          impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
          nominalAmplitudeValueDefineFront: item.nominalAmplitudeValue + item.nominalAmplitudeValueUnit, // 幅度标称值
          nominalFrequencyValueDefineFront: item.nominalFrequencyValue + item.nominalFrequencyValueUnit, // 频率标称值
          technicalIndexDefineFront: item.technicalIndexSymbol + item.technicalIndex + item.technicalIndexUnit, // 技术指标
        }
      })
      itemFormData.value.calibratingSignal = calibratingSignalSimulateList.value.length > 0 ? 1 : 0
    }

    infoId.value = res.data.id
    emits('giveInfoId', infoId.value)
    loading.close()
  })
}

// 初始化输入数据
const initInputData = (data: any) => {
  if (itemFormData.value.itemCategoryName === '数字示波器') {
    // 时基
    timeBaseList.value = data.filter((item: any) => `${item.dataType}` === '1')
    timeBaseList.value = timeBaseList.value.map((item: any) => {
      return {
        ...item,
        params: '时基',
        cycleSignalDefineFront: item.cycleSignal + item.cycleSignalUnit, // 周期时标信号
        timeBaseAbsoluteError: undefined, // 时基绝对误差△T/ns
        timeBaseRelativeError: '', // 时基相对误差△δ
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })

    // 直流增益
    zeroFrequencyGainList.value = data.filter((item: any) => `${item.dataType}` === '2')
    zeroFrequencyGainList.value = zeroFrequencyGainList.value.map((item: any) => {
      return {
        ...item,
        params: '直流增益',
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
        standardValueDefineFront: item.standardValue + item.standardValueUnit, // 标准值
        measureValue: undefined, // 测量值
        measureValueUnit: item.standardValueUnit, // 测量值单位
        relativeError: '', // 相对误差
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(zeroFrequencyGainList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 直流偏置
    DCBiasList.value = data.filter((item: any) => `${item.dataType}` === '3')
    DCBiasList.value = DCBiasList.value.map((item: any) => {
      return {
        ...item,
        params: '直流偏置',
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        thoroughfare: item.thoroughfare, // 通道
        verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
        standardValue: item.standardValue, // 标准值
        measureValue: undefined, // 测量值
        measureValueUnit: item.standardValueUnit, // 测量值单位
        relativeError: '', // 相对误差
        errorValue: '', // 误差
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(DCBiasList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 频带宽度(数字示波器)
    frequencyBandwidthList.value = data.filter((item: any) => `${item.dataType}` === '4')
    frequencyBandwidthList.value = frequencyBandwidthList.value.map((item: any) => {
      return {
        ...item,
        params: '频带宽度',
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        thoroughfare: item.thoroughfare, // 通道
        verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
        bandWidthDefineFront: item.bandWidth + item.bandWidthUnit, // 频带宽度
        referenceAmplitude: undefined, // 参考幅度
        referenceAmplitudeUnit: 'V', // 参考幅度单位
        measureAmplitude: undefined, // 测量幅度
        measureAmplitudeUnit: 'V', // 测量幅度单位
        decibelNumber: '', // 分贝数(dB)
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(frequencyBandwidthList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 触发灵敏度
    triggerSensitivityList.value = data.filter((item: any) => `${item.dataType}` === '5')
    triggerSensitivityList.value = triggerSensitivityList.value.map((item: any) => {
      return {
        ...item,
        params: '触发灵敏度',
        thoroughfare: item.thoroughfare, // 通道
        triggerType: item.triggerType, // 触发类型
        signalFrequencyDefineFront: item.signalFrequency + item.signalFrequencyUnit, // 信号频率
        nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
        measureValue: undefined, // 测量值
        measureValueUnit: item.nominalValueUnit, // 测量值单位
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(triggerSensitivityList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 上升时间
    risetimeList.value = data.filter((item: any) => `${item.dataType}` === '6')
    risetimeList.value = risetimeList.value.map((item: any) => {
      return {
        ...item,
        params: '上升时间',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
        measureValue: undefined, // 测量值
        measureValueUnit: '', // 测量值单位
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(risetimeList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 输入电阻
    inputResistanceList.value = data.filter((item: any) => `${item.dataType}` === '7')
    inputResistanceList.value = inputResistanceList.value.map((item: any) => {
      return {
        ...item,
        params: '输入电阻',
        thoroughfare: item.thoroughfare, // 通道
        nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
        verticalDeflectCoefficientDefineFront: item.verticalDeflectCoefficient + item.verticalDeflectCoefficientUnit, // 垂直偏转系数
        measureValue: undefined, // 测量值
        measureValueUnit: item.nominalValueUnit, // 测量值单位
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(inputResistanceList.value, ['nominalValueDefineFront', 'thoroughfare']) // 合并单元格

    // 校准信号
    calibratingSignalList.value = data.filter((item: any) => `${item.dataType}` === '8')
    calibratingSignalList.value = calibratingSignalList.value.map((item: any) => {
      return {
        ...item,
        params: '校准信号',
        itemType: item.itemType, // 项目
        nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
        topMeasureValue: item.itemType === '频率' ? '-' : undefined, // 顶部测量值
        bottomMeasureValue: item.itemType === '频率' ? '-' : undefined, // 底部测量值
        measureValue: '', // 测量值
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
  }
  else if (itemFormData.value.itemCategoryName === '模拟示波器') {
    // 扫描时间系数及扩展
    scanningTimeList.value = data.filter((item: any) => `${item.dataType}` === '1')
    scanningTimeList.value = scanningTimeList.value.map((item: any) => {
      return {
        ...item,
        params: '扫描时间系数及扩展',
        scanType: item.scanType, // 扫描方式
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        horizontalScaleGearDefineFront: item.horizontalScaleGear + item.horizontalScaleGearUnit, // 阻抗
        nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
        measureValue: '', // 测量值
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(scanningTimeList.value, ['scanType', 'impedanceDefineFront']) // 合并单元格

    // 垂直幅度
    verticalSizeList.value = data.filter((item: any) => `${item.dataType}` === '2')
    verticalSizeList.value = verticalSizeList.value.map((item: any) => {
      return {
        ...item,
        params: '垂直幅度',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
        nominalValueDefineFront: item.nominalValue + item.nominalValueUnit, // 标称值
        measureValue: '', // 测量值
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(verticalSizeList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 频带宽度
    frequencyBandwidthSimulateList.value = data.filter((item: any) => `${item.dataType}` === '3')
    frequencyBandwidthSimulateList.value = frequencyBandwidthSimulateList.value.map((item: any) => {
      return {
        ...item,
        params: '频带宽度',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
        measureValue: '', // 测量值
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(frequencyBandwidthSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 触发特性
    triggerCharacteristicList.value = data.filter((item: any) => `${item.dataType}` === '4')
    triggerCharacteristicList.value = triggerCharacteristicList.value.map((item: any) => {
      return {
        ...item,
        params: '触发特性',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        scanType: item.scanType, // 扫描方式
        triggerType: item.triggerType, // 触发类型
        frequencyUpperDefineFront: item.frequencyUpper + item.frequencyUpperUnit, // 频率上限
        outputSignalAmplitude: '', // 测量值
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(triggerCharacteristicList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 输入电阻（模拟示波器）
    inputResistanceSimulateList.value = data.filter((item: any) => `${item.dataType}` === '5')
    inputResistanceSimulateList.value = inputResistanceSimulateList.value.map((item: any) => {
      return {
        ...item,
        params: '输入电阻',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        measureValue: '', // 测量值
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(inputResistanceSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 上升时间（模拟示波器）
    risetimeSimulateList.value = data.filter((item: any) => `${item.dataType}` === '6')
    risetimeSimulateList.value = risetimeSimulateList.value.map((item: any) => {
      return {
        ...item,
        params: '上升时间',
        thoroughfare: item.thoroughfare, // 通道
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        verticalScaleGearDefineFront: item.verticalScaleGear + item.verticalScaleGearUnit, // 垂直刻度档位
        horizontalScaleGearDefineFront: item.horizontalScaleGear + item.horizontalScaleGearUnit, // 水平刻度档位
        nominalValue: item.amplitude, // 幅度
        nominalValueUnit: item.amplitudeUnit, // 幅度单位
        riseTime: '', // 上升时间
        correctRiseTime: '', // 修正上升时间
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        relativeError: '', // 相对误差
        conclusion: '', // 结论
      }
    })
    useMergeTableRow(risetimeSimulateList.value, ['impedanceDefineFront', 'thoroughfare']) // 合并单元格

    // 校准信号（模拟示波器）
    calibratingSignalSimulateList.value = data.filter((item: any) => `${item.dataType}` === '7')
    calibratingSignalSimulateList.value = calibratingSignalSimulateList.value.map((item: any) => {
      return {
        ...item,
        params: '校准信号',
        signalType: item.signalType, // 信号类型
        impedanceDefineFront: item.impedance + item.impedanceUnit, // 阻抗
        nominalAmplitudeValueDefineFront: item.nominalAmplitudeValue + item.nominalAmplitudeValueUnit, // 幅度标称值
        measureAmplitudeValue: '', // 幅度测量值
        amplitudeDeviation: '', // 幅度偏差
        nominalFrequencyValueDefineFront: item.nominalFrequencyValue + item.nominalFrequencyValueUnit, // 频率标称值
        measureFrequencyValue: '', // 频率测量值
        frequencyDeviation: '', // 频率偏差
        technicalIndexDefineFront: item.technicalIndexSymbol + (item.technicalIndex || '/') + item.technicalIndexUnit, // 技术指标
        technicalIndex: `${item.technicalIndex}` === '' ? '/' : item.technicalIndex, // 技术指标
        conclusion: '', // 结论
      }
    })
  }
}

/**
 * 新增的时候获取检定项输入数据(获取检定项分类详情)
 * @param itemId  检定项id
 * @param itemCategoryName 检定项分类名字
 * @param belongStandardEquipment 检校标准装置字典
 */
const fetchItemInfo = (itemId: string, itemCategoryName: string, belongStandardEquipment = '') => {
  const params = {
    id: itemId,
    itemCategoryName, // 检定项分类名字
    belongStandardEquipment, // 检校标准装置字典code
  }
  getItemInfo(params).then((res) => {
    itemFormData.value.appearance = res.data.appearanceFunctionCheck // 外观及功能检查 1有外观，2没有外观
    itemFormData.value.appearanceFunctionCheck = res.data.appearanceFunctionCheck ? '正常' : ''// 外观及功能检查 1有外观，2没有外观
    itemFormData.value.timeBase = res.data.timeBase // 时基
    itemFormData.value.currentGain = res.data.currentGain // 直流增益
    itemFormData.value.currentBias = res.data.currentBias // 直流偏置
    itemFormData.value.bandWidth = res.data.bandWidth // 频带宽度
    itemFormData.value.triggerSensitivity = res.data.triggerSensitivity // 触发灵敏度
    itemFormData.value.riseTime = res.data.riseTime // 上升时间
    itemFormData.value.inputResistance = res.data.inputResistance // 输入电阻
    itemFormData.value.calibratingSignal = res.data.calibratingSignal // 校准信号
    itemFormData.value.scanTimeCoefficient = res.data.scanTimeCoefficient // 扫描时间系数及扩展
    itemFormData.value.triggerCharacter = res.data.triggerCharacter // 触发特性
    itemFormData.value.verticalAmplitude = res.data.verticalAmplitude // 垂直幅度

    if (res.data.measureItemDataOscilloscopeList && res.data.measureItemDataOscilloscopeList.length) {
      const tempTimeBaseList = res.data.measureItemDataOscilloscopeList.filter((item: any) => `${item.dataType}` === '1')
      if (tempTimeBaseList && tempTimeBaseList.length) {
        itemFormData.value.methodType = tempTimeBaseList[0].methodType
      }
    }
    initInputData(res.data.measureItemDataOscilloscopeList)
  })
}

// ----------------------------------------计算---------------------------------------
// 点击计算结果校验
const checkout = (type: string) => {
  let result = true
  if (itemFormData.value.itemCategoryName === '数字示波器') {
    switch (type) {
      case '时基': {
        const columns = itemFormData.value.methodType === '方法一' ? columns_time_base_method1.value : columns_time_base_method2.value
        result = useCheckList(timeBaseList.value, columns, type)
        break
      }
      case '直流增益':
        result = useCheckList(zeroFrequencyGainList.value, columns_zero_frequency_gain.value, type)
        break
      case '直流偏置':
        result = useCheckList(DCBiasList.value, columns_DC_bias.value, type)
        break
      case '频带宽度':
        result = useCheckList(frequencyBandwidthList.value, columns_frequency_bandwidth.value, type)
        break
      case '触发灵敏度':
        result = useCheckList(triggerSensitivityList.value, columns_trigger_sensitivity.value, type)
        break
      case '上升时间':
        result = useCheckList(risetimeList.value, columns_risetime.value, type)
        break
      case '输入电阻':
        result = useCheckList(inputResistanceList.value, columns_input_resistance.value, type)
        break
      case '校准信号':
        result = useCheckList(calibratingSignalList.value, columns_calibrating_signal.value, type)
        break
      default:
        break
    }
  }
  else if (itemFormData.value.itemCategoryName === '模拟示波器') {
    switch (type) {
      case '扫描时间系数及扩展':
        result = useCheckList(scanningTimeList.value, columns_scan_time.value, type)
        break
      case '垂直幅度':
        result = useCheckList(verticalSizeList.value, columns_vertical_size.value, type)
        break
      case '频带宽度':
        result = useCheckList(frequencyBandwidthSimulateList.value, columns_frequency_bandwidth_simulate.value, type)
        break
      case '触发特性':
        result = useCheckList(triggerCharacteristicList.value, columns_trigger_characteristic.value, type)
        break
      case '输入电阻':
        result = useCheckList(inputResistanceSimulateList.value, columns_input_resistance_simulate.value, type)
        break
      case '上升时间':
        result = useCheckList(risetimeSimulateList.value, columns_risetime_simulate.value, type)
        break
      case '校准信号':
        result = useCheckList(calibratingSignalSimulateList.value, columns_calibrating_signal_simulate.value, type)
        break
      default:
        break
    }
  }
  return result
}

// 计算之前参数处理
const solveParamsBeforeCalculate = (type: string) => {
  let list = [] as any
  if (itemFormData.value.itemCategoryName === '数字示波器') {
    switch (type) {
      case '时基':
        list = timeBaseList.value
        break
      case '直流增益':
        list = zeroFrequencyGainList.value
        break
      case '直流偏置':
        list = DCBiasList.value
        break
      case '频带宽度':
        list = frequencyBandwidthList.value
        break
      case '触发灵敏度':
        list = triggerSensitivityList.value
        break
      case '上升时间':
        list = risetimeList.value
        break
      case '输入电阻':
        list = inputResistanceList.value
        break
      case '校准信号':
        list = calibratingSignalList.value
        break
      default:
        break
    }
  }
  else if (itemFormData.value.itemCategoryName === '模拟示波器') {
    switch (type) {
      case '扫描时间系数及扩展':
        list = scanningTimeList.value
        break
      case '垂直幅度':
        list = verticalSizeList.value
        break
      case '频带宽度':
        list = frequencyBandwidthSimulateList.value
        break
      case '触发特性':
        list = triggerCharacteristicList.value
        break
      case '输入电阻':
        list = inputResistanceSimulateList.value
        break
      case '上升时间':
        list = risetimeSimulateList.value
        break
      case '校准信号':
        list = calibratingSignalSimulateList.value
        break
      default:
        break
    }
  }

  return list
}

// 计算之后参数处理
const solveParamsAfterCalculate = (type: string, list: any) => {
  if (itemFormData.value.itemCategoryName === '数字示波器') {
    switch (type) {
      case '时基':
        timeBaseList.value = timeBaseList.value.map((item, index) => {
          return {
            ...item,
            timeBaseRelativeError: list[index].timeBaseRelativeError,
            conclusion: list[index].conclusion,
            exceedMark: list[index].exceedMark,
          }
        }).map((item: any) => ({
          ...item,
          timeBaseRelativeError: useScientificNotation(Number(item.timeBaseRelativeError), 2, 2),
        }))
        break
      case '直流增益':
        zeroFrequencyGainList.value = zeroFrequencyGainList.value.map((item, index) => {
          return {
            ...item,
            relativeError: list[index].relativeError,
            conclusion: list[index].conclusion,
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '直流偏置':
        DCBiasList.value = DCBiasList.value.map((item, index) => {
          return {
            ...item,
            errorValue: list[index].errorValue + item.standardValueUnit, // 误差
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '频带宽度':
        frequencyBandwidthList.value = frequencyBandwidthList.value.map((item, index) => {
          return {
            ...item,
            decibelNumber: list[index].decibelNumber, // 分贝数(dB)
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '触发灵敏度':
        triggerSensitivityList.value = triggerSensitivityList.value.map((item, index) => {
          return {
            ...item,
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '上升时间':
        risetimeList.value = risetimeList.value.map((item, index) => {
          return {
            ...item,
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '输入电阻':
        inputResistanceList.value = inputResistanceList.value.map((item, index) => {
          return {
            ...item,
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '校准信号':
        calibratingSignalList.value = calibratingSignalList.value.map((item, index) => {
          return {
            ...item,
            measureValue: item.itemType === '幅度' ? list[index].measureValue + item.nominalValueUnit : item.measureValue, // 测量值
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      default:
        break
    }
  }
  else if (itemFormData.value.itemCategoryName === '模拟示波器') {
    switch (type) {
      case '扫描时间系数及扩展':
        scanningTimeList.value = scanningTimeList.value.map((item, index) => {
          return {
            ...item,
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '垂直幅度':
        verticalSizeList.value = verticalSizeList.value.map((item, index) => {
          return {
            ...item,
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '频带宽度':
        frequencyBandwidthSimulateList.value = frequencyBandwidthSimulateList.value.map((item, index) => {
          return {
            ...item,
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '触发特性':
        triggerCharacteristicList.value = triggerCharacteristicList.value.map((item, index) => {
          return {
            ...item,
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '输入电阻':
        inputResistanceSimulateList.value = inputResistanceSimulateList.value.map((item, index) => {
          return {
            ...item,
            relativeError: list[index].relativeError, // 相对误差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '上升时间':
        risetimeSimulateList.value = risetimeSimulateList.value.map((item, index) => {
          return {
            ...item,
            correctRiseTime: `${list[index].correctRiseTime}ns`, // 修正上升时间
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
          }
        })
        break
      case '校准信号':
        calibratingSignalSimulateList.value = calibratingSignalSimulateList.value.map((item, index) => {
          return {
            ...item,
            amplitudeDeviation: list[index].amplitudeDeviation, // 幅度偏差
            frequencyDeviation: list[index].frequencyDeviation, // 频率偏差
            conclusion: list[index].conclusion, // 结论
            exceedMark: list[index].exceedMark,
            exceedMarkOne: list[index].exceedMarkOne,
          }
        })
        break
      default:
        break
    }
  }

  return list
}
// 点击计算结果
const calculate = (type: string) => {
  if (!checkout(type)) {
    return false
  }
  const list = solveParamsBeforeCalculate(type)
  // =============表格loading==============================
  timeBaseLoading.value = type === '时基'
  zeroFrequencyGainLoading.value = type === '直流增益'
  DCBiasLoading.value = type === '直流偏置'
  frequencyBandwidthLoading.value = type === '频带宽度' && itemFormData.value.itemCategoryName === '数字示波器'
  triggerSensitivityLoading.value = type === '触发灵敏度'
  risetimeLoading.value = type === '上升时间' && itemFormData.value.itemCategoryName === '数字示波器'
  inputResistanceLoading.value = type === '输入电阻' && itemFormData.value.itemCategoryName === '数字示波器'
  calibratingSignalLoading.value = type === '校准信号' && itemFormData.value.itemCategoryName === '数字示波器'
  scanningTimeLoading.value = type === '扫描时间系数及扩展'
  verticalSizeLoading.value = type === '垂直幅度'
  frequencyBandwidthSimulateLoading.value = type === '频带宽度' && itemFormData.value.itemCategoryName === '模拟示波器'
  triggerCharacteristicLoading.value = type === '触发特性'
  inputResistanceSimulateLoading.value = type === '输入电阻' && itemFormData.value.itemCategoryName === '模拟示波器'
  risetimeSimulateLoading.value = type === '上升时间' && itemFormData.value.itemCategoryName === '模拟示波器'
  calibratingSignalSimulateLoading.value = type === '校准信号' && itemFormData.value.itemCategoryName === '模拟示波器'
  // =======================================================
  const params = {
    belongStandardEquipment: itemFormData.value.belongStandardEquipment, // 检校标准装置
    itemCategoryName: itemFormData.value.itemCategoryName, // 检定项分类名称
    measureDataOscilloscopeList: list.map((item: { exceedMark: number }) => {
      return {
        ...item,
        exceedMark: 0,
        exceedMarkOne: 0,
      }
    }),
  }
  calculateHandle(params).then((res) => {
    if (res.data && res.data.length) {
      solveParamsAfterCalculate(type, res.data)
    }
    timeBaseLoading.value = false
    zeroFrequencyGainLoading.value = false
    DCBiasLoading.value = false
    frequencyBandwidthLoading.value = false
    triggerSensitivityLoading.value = false
    risetimeLoading.value = false
    inputResistanceLoading.value = false
    calibratingSignalLoading.value = false
    scanningTimeLoading.value = false
    verticalSizeLoading.value = false
    frequencyBandwidthSimulateLoading.value = false
    triggerCharacteristicLoading.value = false
    inputResistanceSimulateLoading.value = false
    risetimeSimulateLoading.value = false
    calibratingSignalSimulateLoading.value = false
  }).catch(() => {
    timeBaseLoading.value = false
    zeroFrequencyGainLoading.value = false
    DCBiasLoading.value = false
    frequencyBandwidthLoading.value = false
    triggerSensitivityLoading.value = false
    risetimeLoading.value = false
    inputResistanceLoading.value = false
    calibratingSignalLoading.value = false
    scanningTimeLoading.value = false
    verticalSizeLoading.value = false
    frequencyBandwidthSimulateLoading.value = false
    triggerCharacteristicLoading.value = false
    inputResistanceSimulateLoading.value = false
    risetimeSimulateLoading.value = false
    calibratingSignalSimulateLoading.value = false
  })
}

// -----------------------------------------保存之前处理数据------------------------------------
const solveParamsBeforeSave = () => {
  let list = [] as any
  if (itemFormData.value.itemCategoryName === '数字示波器') {
    list = list.concat(
      timeBaseList.value,
      zeroFrequencyGainList.value,
      DCBiasList.value,
      frequencyBandwidthList.value,
      triggerSensitivityList.value,
      risetimeList.value,
      inputResistanceList.value,
      calibratingSignalList.value,
    )
  }
  else {
    list = list.concat(
      scanningTimeList.value, // 扫描时间系数及扩展
      verticalSizeList.value, // 垂直幅度
      frequencyBandwidthSimulateList.value, // 频带宽度(模拟示波器)
      triggerCharacteristicList.value, // 触发特性
      inputResistanceSimulateList.value, // 输入电阻(模拟示波器)
      risetimeSimulateList.value, // 上升时间(模拟示波器)
      calibratingSignalSimulateList.value, // 校准信号(模拟示波器)
    )
  }
  let result = ''
  const index1 = list.findIndex((item: { exceedMark: number; exceedMarkOne: number }) => item.exceedMark === 1 && (itemFormData.value.itemCategoryName === '模拟示波器' && item.exceedMarkOne === 1)) // 找不符合指标
  const index0 = list.findIndex((item: { exceedMark: number; exceedMarkOne: number }) => item.exceedMark === 0 && (itemFormData.value.itemCategoryName === '模拟示波器' && item.exceedMarkOne === 0)) // 找符合指标
  if (index1 !== -1 && index0 !== -1) { // 找到不符合指标和符合指标了
    result = '除*外其余所检项目合格'
  }
  else if (index1 === -1) { // 没找到不符合指标--合格
    result = '所检项目合格'
  }
  else if (index0 === -1) { // 没找到符合指标--不合格
    result = '不合格'
  }
  templateFormAndTableRef.value.form.conclusion = result
  return list
}
// ----------------------------------------------------------------------------------------
const isNeverDefineItemCategory = ref(false) // 检定项分类是否是从未定义过的
watch(() => itemFormData.value.itemCategoryName, (newValue) => {
  if (newValue) {
    // 判断是否是新增的检定项分类
    const index = categoryNameDict.findIndex((item: any) => item === newValue)
    if (index === -1) {
      isNeverDefineItemCategory.value = true
    }
    else {
      isNeverDefineItemCategory.value = false
    }
  }
})
// ------------------------------------------钩子----------------------------------------------

watch(() => props.infoId, (newValue) => {
  if (newValue) {
    infoId.value = newValue
  }
}, { immediate: true })

onMounted(() => {
  if (pageType.value === 'add') { // 从我的任务跳转过来（新增）
    itemFormData.value.itemId = $route.query.itemId as string// 检定项id
    itemFormData.value.itemCategoryName = $route.query.itemCategoryName as string// 设备检定项分类名称
    itemFormData.value.itemCategoryId = $route.query.itemCategoryId as string// 设备检定项分类名称id
    itemFormData.value.belongStandardEquipment = $route.query.belongStandardEquipment as string// 标准装置code
    itemFormData.value.belongStandardEquipmentName = $route.query.belongStandardEquipmentName as string// 标准装置名称
    // 查输入值(查检定项管理的详情)
    fetchItemInfo($route.query.itemId! as string, $route.query.itemCategoryName! as string, $route.query.belongStandardEquipment as string)
  }
  else {
    itemFormData.value.itemCategoryName = $route.query.itemCategoryName as string // 设备检定项分类名称
    itemFormData.value.itemCategoryId = $route.query.itemCategoryId as string// 设备检定项分类名称id
    itemFormData.value.belongStandardEquipment = $route.query.belongStandardEquipment as string// 标准装置code
    itemFormData.value.belongStandardEquipmentName = $route.query.belongStandardEquipmentName as string// 标准装置名称
    fetchInfo()
    // fetchItemInfo($route.query.itemId! as string, $route.query.itemCategoryName! as string, $route.query.belongStandardEquipment as string)
  }
})

defineExpose({ fetchInfo, checkout, itemFormData, templateFormAndTableRef, pageType, solveParamsBeforeSave })
</script>

<template>
  <div class="measure-data-template-detail">
    <template-form-and-table
      ref="templateFormAndTableRef" :page-type="pageType"
      @change-meter-identify="emits('changeMeterIdentify')"
    />
    <!-- 标签 -->
    <detail-block v-if="!isNeverDefineItemCategory" :title="pageType !== 'detail' ? '检定数据' : ''" :class="pageType === 'detail' ? 'setBottom' : ''">
      <el-radio-group v-if="pageType === 'detail'" v-model="current">
        <el-radio-button v-for="item in radioMenus" :key="item.value" :label="item.value">
          {{ item.name }}
        </el-radio-button>
      </el-radio-group>

      <el-form
        v-if="current === 'measure-data' && itemFormData.appearance" ref="formRef" :model="itemFormData"
        label-width="140" label-position="right" style="margin-top: 20px;"
      >
        <el-row>
          <!-- 外观  -->
          <el-col :span="12">
            <el-form-item label="外观及功能性检查:" prop="appearanceFunctionCheck">
              <el-input
                v-model="itemFormData.appearanceFunctionCheck" class="full-width-input" autosize type="textarea"
                :disabled="pageType === 'detail'"
              />
            </el-form-item>
          </el-col>
        </el-row>
      </el-form>

      <!-- 时基 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.timeBase"
        title="时基"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('时基')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="timeBaseLoading" :data="timeBaseList"
          :columns="itemFormData.methodType === '方法一' ? columns_time_base_method1 : columns_time_base_method2"
          :page-type="pageType"
        />
      </detail-block>

      <!-- 直流增益 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.currentGain"
        title="直流增益"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('直流增益')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="zeroFrequencyGainLoading" :data="zeroFrequencyGainList"
          :columns="columns_zero_frequency_gain" :page-type="pageType"
        />
      </detail-block>

      <!-- 直流偏置 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.currentBias"
        title="直流偏置"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('直流偏置')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="DCBiasLoading" type="直流偏置" :data="DCBiasList" :columns="columns_DC_bias"
          :page-type="pageType"
        />
      </detail-block>

      <!-- 频带宽度 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.bandWidth"
        title="频带宽度"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('频带宽度')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="frequencyBandwidthLoading" :data="frequencyBandwidthList"
          :columns="columns_frequency_bandwidth" :page-type="pageType"
        />
      </detail-block>

      <!--  触发灵敏度 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.triggerSensitivity"
        title="触发灵敏度"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('触发灵敏度')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="triggerSensitivityLoading" type="触发灵敏度" :data="triggerSensitivityList"
          :columns="columns_trigger_sensitivity" :page-type="pageType"
        />
      </detail-block>

      <!-- 上升时间 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.riseTime"
        title="上升时间"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('上升时间')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="risetimeLoading" type="上升时间(数字示波器)" :data="risetimeList" :columns="columns_risetime"
          :page-type="pageType"
        />
      </detail-block>

      <!--  输入电阻 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.inputResistance"
        title="输入电阻"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('输入电阻')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="inputResistanceLoading" type="输入电阻(数字示波器)" :data="inputResistanceList"
          :columns="columns_input_resistance" :page-type="pageType"
        />
      </detail-block>

      <!--  校准信号 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '数字示波器' && itemFormData.calibratingSignal"
        title="校准信号"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('校准信号')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="calibratingSignalLoading" type="校准信号(数字示波器)" :data="calibratingSignalList"
          :columns="columns_calibrating_signal" :page-type="pageType"
        />
      </detail-block>

      <!--  扫描时间系数及扩展 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.scanTimeCoefficient"
        title="扫描时间系数及扩展"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('扫描时间系数及扩展')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="scanningTimeLoading" type="扫描时间系数及扩展" :data="scanningTimeList"
          :columns="columns_scan_time" :page-type="pageType"
        />
      </detail-block>

      <!--  垂直幅度 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.verticalAmplitude"
        title="垂直幅度"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('垂直幅度')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="verticalSizeLoading" type="垂直幅度" :data="verticalSizeList"
          :columns="columns_vertical_size" :page-type="pageType"
        />
      </detail-block>

      <!--  频带宽度 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.bandWidth"
        title="频带宽度"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('频带宽度')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="frequencyBandwidthSimulateLoading" type="频带宽度(模拟示波器)"
          :data="frequencyBandwidthSimulateList" :columns="columns_frequency_bandwidth_simulate"
          :page-type="pageType"
        />
      </detail-block>

      <!--  触发特性 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.triggerCharacter"
        title="触发特性"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('触发特性')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="triggerCharacteristicLoading" type="触发特性" :data="triggerCharacteristicList"
          :columns="columns_trigger_characteristic" :page-type="pageType"
        />
      </detail-block>

      <!--  输入电阻 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.inputResistance"
        title="输入电阻"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('输入电阻')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="inputResistanceSimulateLoading" type="输入电阻(模拟示波器)"
          :data="inputResistanceSimulateList" :columns="columns_input_resistance_simulate" :page-type="pageType"
        />
      </detail-block>

      <!--  上升时间 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.riseTime"
        title="上升时间"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('上升时间')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="risetimeSimulateLoading" type="上升时间(模拟示波器)" :data="risetimeSimulateList"
          :columns="columns_risetime_simulate" :page-type="pageType"
        />
      </detail-block>

      <!--  校准信号 -->
      <detail-block
        v-if="current === 'measure-data' && itemFormData.itemCategoryName === '模拟示波器' && itemFormData.calibratingSignal"
        title="校准信号"
      >
        <template v-if="pageType !== 'detail'" #btns>
          <el-button type="primary" @click="calculate('校准信号')">
            计算结果
          </el-button>
        </template>
        <template-table
          v-loading="calibratingSignalSimulateLoading" type="校准信号(模拟示波器)"
          :data="calibratingSignalSimulateList" :columns="columns_calibrating_signal_simulate" :page-type="pageType"
        />
      </detail-block>

      <!-- 历史修改记录 -->
      <change-record v-if="pageType === 'detail' && current === 'change-record'" :info-id="infoId" />
    </detail-block>

    <!-- ------------------------------------------------结论------------------------------------------------ -->
    <el-form
      v-if="current === 'measure-data' && !isNeverDefineItemCategory" ref="formRef" :model="itemFormData" label-width="140"
      label-position="right" style="margin-top: 20px;"
    >
      <el-row>
        <el-col :span="12">
          <el-form-item label="备注:" prop="remark">
            <el-input
              v-model="itemFormData.remark" class="full-width-input"
              :placeholder="pageType === 'detail' ? ' ' : '备注'" autosize type="textarea"
              :disabled="pageType === 'detail'"
            />
          </el-form-item>
        </el-col>
      </el-row>
    </el-form>
  </div>
</template>

<style lang="scss">
.measure-data-template-detail {
  .el-radio__label {
    display: block !important;
  }
}
</style>