GitBucket
Newer
<!-- 第一套：多功能校准源标准库 -->
<!-- 检定数据管理详情模板 -->
<script lang="ts" setup name="MeasureDataTemplateDetail">
import dayjs from 'dayjs'
import { ElLoading, ElMessage } from 'element-plus'
import { ref } from 'vue'
import selectStandard from '../../dialog/selectStandardDialog.vue'
import type { IForm } from '../../measureData-interface'
import { useMaximumError } from '../../useCaculate'
import changeRecord from '../changeRecord.vue'
import type { IDetailMeasureList } from './first-interface'
import { getEquipmentList } from '@/api/equipment/standard/book'
import {
calculateHandle,
getInfo,
getLocationList,
getRecentList,
} from '@/api/business/taskMeasure/measureData'
import { getClassificationList } from '@/api/business/measure/classification'
import { getInfo as getItemInfo } from '@/api/business/measure/item'
import { getDeptTreeList } from '@/api/system/dept'
import { getDictByCode } from '@/api/system/dict'
import { getUserList } from '@/api/system/user'
import { useCheckList } from '@/commonMethods/useCheckList'
import type { TableColumn } from '@/components/NormalTable/table_interface'
import type { deptType, dictType } from '@/global'
import useUserStore from '@/store/modules/user'
import { toTreeList } from '@/utils/structure'
import { useUniqueArray } from '@/utils/useUniqueArray'
import { getDataNum, getDataUnit } from '@/utils/validate'
import { addSign, removeSign } from '@/commonMethods/useSign'
import filePreviewUrl from '@/components/filePreview/filePreviewUrl.vue'
import { suggestions_number } from '@/views/business/taskMeasure/measureData/components/third/input-suggestions'
import categoryNameDict from '/public/config/categoryNameDict.json'
import { UploadFile, getPhotoUrl } from '@/api/file'
import WordOreview from '@/components/filePreview/wordOreview.vue'
const props = defineProps({
infoId: String, // id
dataNo: String, // 检定数据编号
})
const emits = defineEmits(['giveInfoId', 'changeMeterIdentify'])
const user = useUserStore() // 用户信息
const $router = useRouter() // 关闭页面使用
const $route = useRoute() // 路由参数
const isNeverDefineItemCategory = ref(false) // 检定项分类是否是从未定义过的
const ruleFormRef = ref() // 表单ref
const form = ref<IForm>({
dataNo: '', // 检定数据编号
measureCategory: '', // 检校类别
measureCategoryName: '', // 检校类别名称
customerName: '', // 委托单位
traceDate: '', // 测试、校准或检定日期
measureValidDate: '', // 检定有效期
measureAddress: '', // 测试、校准或检定地点
temperature: '', // 温度
humidity: '', // 相对湿度
orderId: '', // 任务单id
orderNo: '', // 任务单编号
technologyFile: '', // 依据的技术文件（编号、名称）
createUserId: '', // 检定员id
createUserName: '', // 检定员
dataSource: '', // 数据来源
meterIdentify: '', // 计量标识
conclusion: '', // 结论
restrictionInstruction: '', // 限用说明
appearanceFunctionCheck: '', // 外观及功能性检查
itemId: '', // 检定项id
itemCategoryName: '', // 智能模型检定项分类名称
itemCategoryId: '', // 智能模型检定项分类名称id
belongStandardEquipment: '', // 标准装置code
belongStandardEquipmentName: '', // 标准装置名称
ipri: '', // 电流转换系数
ipriUnit: 'A', // 电流转换系数单位
isec: '', // 电流转换系数
isecUnit: 'A', // 电流转换系数单位
vpri: '', // 电压转换系数
vpriUnit: 'V', // 电压转换系数单位
vsec: '', // 电压转换系数
vsecUnit: 'V', // 电压转换系数单位
remark: '', // 备注
humidityLower: '', // 湿度下限
humidityUpper: '', // 湿度上限
temperatureLower: '', // 温度下限
temperatureUpper: '', // 温度上限
labCode: '', // 实验室
groupCode: '', // 部门
constCertificateExcelData: '', // 检校证书 --const检定证书文件base64 / 非已定义检定项分类时上传的检定证书minio存储文件名
constRecordExcelData: '', // 原始记录 -- const原始记录文件base64 / 非已定义检定项分类时上传的原始记录minio存储文件名
})
const helpInstruction = ref('') // 辅助字段
const helpFieldInstruction = ref('') // 辅助字段说明
const validateHumidity = (rule: any, value: any, callback: any) => {
const type = rule.field === 'humidity' ? '相对湿度' : '温度'
const reg = /(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/
if (!reg.test(value)) {
callback(new Error(`${type}只能为数字`))
}
if (!value && value?.length) {
callback(new Error(`${type}不能为空`))
}
else {
console.log('温度下限', form.value.temperatureLower)
console.log('温度上限', form.value.temperatureUpper)
console.log('湿度下限', form.value.humidityLower)
console.log('湿度上限', form.value.humidityUpper)
if (type === '温度' && (Number(value) < Number(form.value.temperatureLower) || Number(value) > Number(form.value.temperatureUpper))) {
const temperatureLower = `${form.value.temperatureLower}`
const temperatureUpper = `${form.value.temperatureUpper}`
if (temperatureLower && temperatureUpper) {
callback(new Error(`${type}范围为 ${temperatureLower} ~ ${temperatureUpper}`))
}
else if (temperatureLower && !temperatureUpper && Number(value) < Number(form.value.temperatureLower)) {
callback(new Error(`${type}下限为${temperatureLower}`))
}
else if (!temperatureLower && temperatureUpper && Number(value) > Number(form.value.temperatureUpper)) {
callback(new Error(`${type}上限为${temperatureUpper}`))
}
}
if (type === '相对湿度' && (Number(value) < Number(form.value.humidityLower) || Number(value) > Number(form.value.humidityUpper))) {
const humidityLower = `${form.value.humidityLower}`
const humidityUpper = `${form.value.humidityUpper}`
if (humidityLower && humidityUpper) {
callback(new Error(`${type}范围为 ${humidityLower} ~ ${humidityUpper}`))
}
else if (humidityLower && !humidityUpper && Number(value) < Number(form.value.humidityLower)) {
callback(new Error(`${type}下限为${humidityLower}`))
}
else if (!humidityLower && humidityUpper && Number(value) > Number(form.value.humidityUpper)) {
callback(new Error(`${type}上限为${humidityUpper}`))
}
}
if (Number(value) > 100) {
callback(new Error(`${type}不能大于100`))
}
callback()
}
}
// 校验规则
const rules = ref({
measureCategory: [{ required: true, message: '检校类别不能为空', trigger: ['blur', 'change'] }],
// customerName: [{ required: true, message: '委托单位不能为空', trigger: ['blur', 'change'] }],
traceDate: [{ required: true, message: '测试、校准或检定日期不能为空', trigger: ['blur', 'change'] }],
measureValidDate: [{ required: true, message: '检定有效期不能为空', trigger: ['blur', 'change'] }],
measureAddress: [{ required: true, message: '测试、校准或检定地点不能为空', trigger: ['blur', 'change'] }],
temperature: [{ required: true, validator: validateHumidity, trigger: ['blur', 'change'] }],
humidity: [{ required: true, validator: validateHumidity, trigger: ['blur', 'change'] }],
// orderNo: [{ required: true, message: '任务单编号不能为空', trigger: ['blur', 'change'] }],
// technologyFile: [{ required: true, message: '依据的技术文件不能为空', trigger: ['blur', 'change'] }],
createUserName: [{ required: true, message: '检定员不能为空', trigger: ['blur', 'change'] }],
conclusion: [{ required: true, message: '结论不能为空', trigger: ['blur', 'change'] }],
restrictionInstruction: [{ required: true, message: '限用说明不能为空', trigger: ['blur', 'change'] }],
appearanceFunctionCheck: [{ required: true, message: '外观及功能性检查不能为空', trigger: ['blur', 'change'] }],
meterIdentify: [{ required: true, message: '计量标识不能为空', trigger: ['blur', 'change'] }],
labCode: [{ required: true, message: '实验室不能为空', trigger: ['blur', 'change'] }],
groupCode: [{ required: true, message: '部门不能为空', trigger: ['blur', 'change'] }],
constCertificateExcelData: [{ required: true, message: '检校证书不能为空', trigger: ['blur', 'change'] }],
constRecordExcelData: [{ required: true, message: '原始记录不能为空', trigger: ['blur', 'change'] }],
})
const itemCategoryName = ref('') // 智能模型检定项分类名称
const measureItemConfigCalibrator = ref({}) as any // 后五种智能模型表单配置
// -------------------------------------------路由参数------------------------------------------
const pageType = ref('add') // 页面类型: add, edit, detail
const getInfoId = ref('') // 列表id
if ($route.params && $route.params.type) {
pageType.value = $route.params.type as string
if ($route.params.id) {
getInfoId.value = $route.params.id as string
}
}
// -------------------------------------------字典---------------------------------------------+
const conclusionList = ref<dictType[]>([]) // 结论
const measureCategoryList = ref<dictType[]>([]) // 检校类别
const measureCategoryDict = ref([]) as any // 检校类别
const IUnitList = ref<dictType[]>([]) // 电流转换系数单位
const UUnitList = ref<dictType[]>([]) // 电压转换系数
const positionList = ref([]) as any // 测试、校准或检定地点
const userList = ref<{ [key: string]: string }[]>([]) // 用户列表
const useDeptList = ref<deptType[]>([]) // 所属部门列表
const deptList = ref<deptType[]>([]) // 所属部门列表
const lineModeList = ref<dictType[]>([]) // 两线/四线模式
const meterIdentifyDict = ref<dictType[]>([]) // 计量标识
const labCodeList = ref<dictType[]>([]) // 实验室代码
const groupCodeList = ref<dictType[]>([]) // 组别代码
// 获取字典值
async function getDict() {
getDictByCode('bizGroupCodeEquipment').then((response) => {
labCodeList.value = response.data
})
// 组别代码
getDictByCode('bizGroupCode').then((response) => {
groupCodeList.value = response.data
})
// 检校类别
getDictByCode('measureCategory').then((response) => {
response.data.forEach((item: { value: string; name: string }) => {
measureCategoryDict.value[`${item.value}`] = item.name
})
measureCategoryList.value = response.data
})
// 结论
getDictByCode('bizConclusion').then((response) => {
conclusionList.value = response.data
})
// I单位（电流转换系数单位）
getDictByCode('bizFirstStandardUnitI').then((response) => {
IUnitList.value = response.data
})
// U单位（电压转换系数单位）
getDictByCode('bizFirstStandardUnitU').then((response) => {
UUnitList.value = response.data
})
// 两线/四线模式
getDictByCode('bizFirstStandardLineMode').then((response) => {
lineModeList.value = response.data
})
// 测试、校准或检定地点
getLocationList({
locationName: '', // 地点名称
locationNo: '', // 地点编号
labName: user.bizLabCode === 'H' ? '海口实验室' : user.bizLabCode === 'X' ? '西昌实验室' : '',
limit: 999999,
offset: 1,
}).then((res) => {
positionList.value = res.data.rows.map(
(item: {
id: string
locationName: string
temperature: string
humidity: string
}) => {
return {
id: item.id,
name: item.locationName, // 地点名称
temperature: `${item.temperature}` || '', // 温度
humidity: `${item.humidity}` || '', // 湿度
}
},
)
})
// 获取用户列表
getUserList({ offset: 1, limit: 999999 }).then((res: any) => {
userList.value = res.data.rows
})
// 获取部门列表
getDeptTreeList().then((res) => {
deptList.value = res.data
// 转成树结构
useDeptList.value = toTreeList(res.data, '0', true)
})
// 获取用户列表
// getStaffList({ offset: 1, limit: 999999 }).then((res: any) => {
// userList.value = res.data.rows
// })
// 计量标识
getDictByCode('eqptMeterIdentify').then((response) => {
meterIdentifyDict.value = response.data
})
}
// --------------------------------------被检件信息--------------------------------------------------------
const sampleList = ref([]) as any // 被检件
const columns = ref<TableColumn[]>([
// 表头
{ text: '智能模型名称', value: 'sampleName', align: 'center' },
{ text: '规格型号', value: 'sampleModel', align: 'center' },
{ text: '出厂编号', value: 'manufactureNo', align: 'center' },
{ text: '制造厂家', value: 'manufacturer', align: 'center' },
{ text: '辅助字段', value: 'helpInstruction', align: 'center' },
{ text: '辅助字段说明', value: 'helpFieldInstruction', align: 'center' },
{ text: '智能模型检定项分类', value: 'categoryName', align: 'center' },
])
// --------------------------------------所使用的标准，主要测量智能模型--------------------------------------------------------
const measureDataCalibratorList = ref([]) as any // 列表
const selectStandardRef = ref() // 所使用的标准，主要测量智能模型组件ref
const checkoutMeasureDataCalibratorList = ref([]) as any // 选中列表
const tableLoading = ref(false) // 表格loading
const measureDataCalibratorColumns = ref<TableColumn[]>([
// 表头
{ text: '标准装置名称', value: 'standardName', align: 'center' },
{ text: '智能模型名称', value: 'equipmentName', align: 'center' },
{ text: '规格型号', value: 'model', align: 'center' },
{ text: '出厂编号', value: 'manufactureNo', align: 'center' },
{
text: '不确定度或允许误差极限或准确度等级',
value: 'uncertainty',
align: 'center',
},
{ text: '证书有效期', value: 'measureValidDate', align: 'center' },
])
// 用标准装置id获取标准配套智能模型查询条件
const listQuery = ref({
standardId: '',
offset: 1,
limit: 999999,
})
// 批量增加
const multiFilesAdd = () => {
selectStandardRef.value.initDialog()
}
// 根据数组中按照标准装置和智能模型id去重
function useUniqueArrayOnObject(arr: any) {
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i].standardId == arr[j].standardId && arr[i].id == arr[j].id) {
arr.splice(j, 1)
j--
}
}
}
return arr
}
// 选好标准库
const confirmSelectStandard = (val: any) => {
if (val.length) {
measureDataCalibratorList.value = useUniqueArrayOnObject(measureDataCalibratorList.value.concat(val))
}
}
// 表格多选
const handleSelectionChange = (e: any) => {
checkoutMeasureDataCalibratorList.value = e
}
// 删除行
const delRow = () => {
if (checkoutMeasureDataCalibratorList.value.length <= 0) {
ElMessage({ message: '请选中要删除的行', type: 'warning' })
}
else {
checkoutMeasureDataCalibratorList.value.forEach((item: any) => {
measureDataCalibratorList.value.forEach((element: any, index: number) => {
if (element.equipmentNo === item.equipmentNo) {
measureDataCalibratorList.value.splice(index, 1)
}
})
})
}
}
// ------------------------------------------标签----------------------------------------------------------
const radioMenus = ref([
// 标签内容
{ name: '检定数据', value: 'measure-data' },
{ name: '历史修改记录', value: 'change-record' },
])
const current = ref('measure-data') // 选择的tab 默认基本信息
// ---------------------------------------检定项数据表格----------------------------------------------------
const list = ref<IDetailMeasureList[]>([]) // 表格数据
const appearanceFunctionCheck = ref('') // 外观及功能性检查
const measureColumns = ref([]) as any // 表头数据
// 数字多用表(手持)、钳形电流表、指针式万用表
const columns_digitalMultimeterHandheld = ref([
{
text: '参数',
value: 'params',
align: 'center',
required: true,
width: '80',
},
{
text: '量',
value: 'capacity',
align: 'center',
width: '80',
required: true,
},
{ text: '单位', value: 'unit', align: 'center', width: '80', required: true },
{ text: '频率', value: 'frequency', align: 'center' },
{ text: '单位', value: 'frequencyUnit', align: 'center', width: '80' },
{ text: '量程', value: 'rangeRange', align: 'center', required: true },
{ text: '标准值', value: 'standardValue', align: 'center', required: true },
{ text: '示值', value: 'indicatingValue', align: 'center', required: true },
{ text: '绝对误差', value: 'absoluteError', align: 'center' },
{ text: '最大允许误差', value: 'maximumError', align: 'center' },
{ text: '分辨力', value: 'resolution', align: 'center', required: true },
])
// 数字多用表(台式)
const columns_digitalMultimeterTable = ref([
{ text: '参数', value: 'params', align: 'center', required: true },
{
text: '量',
value: 'capacity',
align: 'center',
width: '120',
required: true,
},
{
text: '单位',
value: 'unit',
align: 'center',
width: '120',
required: true,
},
{ text: '频率', value: 'frequency', align: 'center' },
{ text: '单位', value: 'frequencyUnit', align: 'center', width: '120' },
{ text: '量程', value: 'rangeRange', align: 'center', required: true },
{ text: '标准值', value: 'standardValue', align: 'center', required: true },
{
text: '两线/四线模式',
value: 'lineMode',
align: 'center',
required: false,
width: '120',
},
{ text: '示值', value: 'indicatingValue', align: 'center', required: true },
{ text: '绝对误差', value: 'absoluteError', align: 'center' },
{ text: '最大允许误差', value: 'maximumError', align: 'center' },
{ text: '分辨力', value: 'resolution', align: 'center', required: true },
{ text: '输出备注', value: 'remark', align: 'center' },
])
// 多功能电力参数测量仪
const columns_multifunctionalPowerParameterMeasuringInstrument = ref([
{
text: '参数',
value: 'params',
align: 'center',
required: true,
width: '120',
},
{
text: '量',
value: 'capacity',
align: 'center',
width: '120',
required: true,
},
{
text: '单位',
value: 'unit',
align: 'center',
width: '120',
required: true,
},
{ text: '频率', value: 'frequency', align: 'center' },
{ text: '单位', value: 'frequencyUnit', align: 'center', width: '120' },
{ text: '标准值', value: 'standardValue', align: 'center', required: true },
{ text: 'AN', value: 'an', align: 'center', required: true, width: '180' },
{ text: 'BN', value: 'bn', align: 'center', required: true, width: '180' },
{ text: 'CN', value: 'cn', align: 'center', required: true, width: '180' },
{ text: '最大允许误差', value: 'maximumError', align: 'center' },
{ text: '△AN', value: 'deltaAn', align: 'center', width: '180' },
{ text: '△BN', value: 'deltaBn', align: 'center', width: '180' },
{ text: '△CN', value: 'deltaCn', align: 'center', width: '180' },
{ text: '分辨力', value: 'resolution', align: 'center', required: true },
])
// 交流电压表、交流电流表、直流电压表、直流电流表、75mV电流表
const columns_lastFive = ref([
{
text: '参数',
value: 'params',
align: 'center',
required: true,
width: '120',
},
{
text: '量',
value: 'capacity',
align: 'center',
width: '120',
required: true,
},
{
text: '单位',
value: 'unit',
align: 'center',
width: '120',
required: true,
},
{
text: '被检表示值',
value: 'measureIndicationValue',
align: 'center',
width: '120',
required: true,
},
{
text: '标准值',
value: 'standardValue',
align: 'center',
width: '120',
required: true,
},
{ text: '最大允许误差', value: 'maximumError', align: 'center' },
{ text: '绝对误差', value: 'absoluteError', align: 'center' },
{ text: '分辨力', value: 'resolution', align: 'center', required: true },
])
// -------------------------------------------获取详情信息--------------------------------------------------
// 获取页面详情信息
const fetchInfo = () => {
const loading = ElLoading.service({
lock: true,
background: 'rgba(255, 255, 255, 0.8)',
})
getInfo({
id: getInfoId.value,
belongStandardEquipment: form.value.belongStandardEquipment,
// 我的任务跳转过来如果已经配置过检定项了，到编辑页面，且用一下三个字段替代传id请求详情
itemId: $route.query.itemId, // 检定项id
orderId: $route.query.orderId, // 任务单id
sampleId: $route.query.sampleId, // 被检智能模型id
}).then((res) => {
form.value = res.data
form.value.itemCategoryName = $route.query.itemCategoryName as string // 智能模型检定项分类名称
form.value.itemCategoryId = $route.query.itemCategoryId as string // 智能模型检定项分类名称id
form.value.belongStandardEquipment = $route.query.belongStandardEquipment as string // 标准装置code
form.value.belongStandardEquipmentName = $route.query.belongStandardEquipmentName as string // 标准装置名称
getInfoId.value = res.data.id
form.value.remark = res.data.remark // 备注
form.value.constCertificateExcelData = res.data.constCertificateExcelData// 检定证书
form.value.constRecordExcelData = res.data.constRecordExcelData// 原始记录
itemCategoryName.value = $route.query.itemCategoryName as string // 检定项分类名称
measureDataCalibratorList.value = res.data.equipmentList.map((item: any) => {
return {
...item,
id: item.equipmentId,
}
}) // 所使用的标准，主要测量智能模型
// 获取依据的技术文件
fetchClassificationData(false, $route.query.itemCategoryName! as string, res.data.belongStandardEquipment as string)
form.value.technologyFile = res.data.technologyFile.split(',')
helpFieldInstruction.value = res.data.helpFieldInstruction // 辅助字段说明
sampleList.value = [
{
// 被检智能模型
sampleId: res.data.sampleId, // 智能模型id
sampleName: res.data.sampleName, // 智能模型名称
sampleModel: res.data.model, // 规格型号
manufactureNo: res.data.manufactureNo, // 出厂编号
manufacturer: res.data.manufacturer, // 制造厂家（厂商）
categoryName: $route.query.itemCategoryName, // 智能模型检定项分类
helpInstruction: res.data.helpInstruction, // 辅助字段
helpFieldInstruction: helpFieldInstruction.value, // 辅助字段说明
},
]
list.value = res.data.measureDataCalibratorList.map((item: IDetailMeasureList) => {
return {
...item,
resolution: Number(item.resolution),
redStar: Math.abs(Number(item.absoluteError)) <= Math.abs(Number(getDataNum(item.maximumError))) ? 'normal' : 'error',
ANRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaAn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △AN标星
BNRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaBn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △BN标星
CNRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaCn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △CN标星
maximumError: addSign(item.maximumError), // 最大允许误差添加±
}
}) // 检定数据
if (res.data && res.data.measureDataCalibratorList && res.data.measureDataCalibratorList.length) {
measureItemConfigCalibrator.value = {
standardValueUpper: res.data.measureDataCalibratorList[0].standardValueUpper, // 标准值上限
standardValueUpperUnit: res.data.measureDataCalibratorList[0].standardValueUpperUnit,
accuracyLevel: res.data.measureDataCalibratorList[0].accuracyLevel, // 准确度等级
fullScaleValue: res.data.measureDataCalibratorList[0].fullScaleValue,
fullScaleValueUnit: res.data.measureDataCalibratorList[0].fullScaleValueUnit,
} // 后五种智能模型表单配置
if (itemCategoryName.value === '交流电压表' || itemCategoryName.value === '交流电流表' || itemCategoryName.value === '直流电压表' || itemCategoryName.value === '直流电流表' || itemCategoryName.value === '75mV电流表') {
solveColumn(res)
}
}
emits('giveInfoId', getInfoId.value)
loading.close()
})
}
function solveColumn(res: any) {
columns_lastFive.value = [
// 交流电压表、交流电流表、直流电压表、直流电流表、75mV电流表
{
text: '参数',
value: 'params',
align: 'center',
required: true,
width: '120',
},
{
text: '量',
value: 'capacity',
align: 'center',
width: '120',
required: true,
},
{
text: '单位',
value: 'unit',
align: 'center',
width: '120',
required: true,
},
{
// text: `被检表示值(${getDataUnit(res.data.measureItemDataCalibratorList[0].measureIndicationValue) || res.data.measureItemDataCalibratorList[0].unit})`,
text: `被检表示值(${measureItemConfigCalibrator.value.fullScaleValueUnit})`,
value: 'measureIndicationValue',
align: 'center',
width: '120',
required: true,
},
{
text: `标准值(${measureItemConfigCalibrator.value.standardValueUpperUnit})`,
value: 'standardValue',
align: 'center',
width: '120',
required: true,
},
{
text: `最大允许误差(${measureItemConfigCalibrator.value.standardValueUpperUnit})`,
value: 'maximumError',
align: 'center',
},
{
text: `绝对误差(${measureItemConfigCalibrator.value.standardValueUpperUnit})`,
value: 'absoluteError',
align: 'center',
},
{ text: '分辨力', value: 'resolution', align: 'center', required: true },
]
measureColumns.value = columns_lastFive.value
}
/**
* 新增的时候获取检定项输入数据(获取检定项分类详情)
* @param itemId 检定项id
* @param itemCategoryName 检定项分类名字
* @param belongStandardEquipment 检校标准库字典
*/
const fetchItemInfo = async (itemId: string, itemCategoryName: string, belongStandardEquipment = '') => {
const params = {
id: itemId,
itemCategoryName, // 检定项分类名字
belongStandardEquipment, // 检校标准库字典code
}
const res = await getItemInfo(params)
appearanceFunctionCheck.value = res.data.appearanceFunctionCheck // 外观及功能检查 1有外观，2没有外观
if (res.data.appearanceFunctionCheck) {
// 勾选外观
form.value.appearanceFunctionCheck = '外观完好，工作正常'
}
else {
form.value.appearanceFunctionCheck = ''
}
helpInstruction.value = res.data.helpInstruction as string // 辅助字段
helpFieldInstruction.value = res.data.helpFieldInstruction as string // 辅助字段说明
sampleList.value = sampleList.value.map(
(item: { helpInstruction: string; helpFieldInstruction: string }) => {
return {
...item,
helpInstruction: res.data.helpInstruction, // 辅助字段
helpFieldInstruction: res.data.helpFieldInstruction, // 辅助字段说明
}
},
)
measureItemConfigCalibrator.value = res.data.measureItemConfigCalibrator // 后五种智能模型表单配置
if (itemCategoryName === '交流电压表' || itemCategoryName === '交流电流表' || itemCategoryName === '直流电压表' || itemCategoryName === '直流电流表' || itemCategoryName === '75mV电流表') {
solveColumn(res)
list.value = res.data.measureItemDataCalibratorList.map(
(item: IDetailMeasureList) => {
return {
itemDataId: item.id,
params: item.params, // 参数
capacity: item.capacity, // 量
unit: item.unit, // 单位
frequency: item.frequency, // 频率
frequencyUnit: item.frequencyUnit, // 频率单位
rangeRange: item.rangeRange, // 量程
standardValue: item.standardValue, // 标准值
resolution: Number(item.resolution), // 分辨力
indicatingValue: item.indicatingValue, /// 示值
lineMode: item.lineMode || '/',
maximumError: item.maximumError, // 最大允许误差
absoluteError: '', // 绝对误差
remark: '', // 输出备注
an: '', // AN
bn: '', // BN
cn: '', // CN
deltaAn: '', // △AN
deltaBn: '', // △BN
deltaCn: '', // △CN
measureIndicationValue: getDataNum(item.measureIndicationValue), // 被检表示值
maximumErrorFormula: '', // 最大允许误差（把公式给后台传过去）
errorParamA: item.errorParamA, // 误差参数a
errorParamB: item.errorParamB, // 误差参数b
standardValueUpperLimit: measureItemConfigCalibrator.value.standardValueUpper, // 标准值上限
accuracyLevel: measureItemConfigCalibrator.value.accuracyLevel, // 准确度等级
fullScaleValue: measureItemConfigCalibrator.value.fullScaleValue, // 指针式仪表满量程值---用于指针式万用表最大允许误差计算
fullScaleValueUnit: measureItemConfigCalibrator.value.fullScaleValueUnit, // 指针式仪表满量程值单位---用于指针式万用表最大允许误差计算
standardValueUpper: measureItemConfigCalibrator.value.standardValueUpper, // 标准值上限
standardValueUpperUnit: measureItemConfigCalibrator.value.standardValueUpperUnit,
}
},
) // 检定项表格
}
else {
list.value = res.data.measureItemDataCalibratorList.map(
(item: IDetailMeasureList) => {
return {
itemDataId: item.id,
params: item.params, // 参数
capacity: item.capacity, // 量
unit: item.unit, // 单位
frequency: item.frequency, // 频率
frequencyUnit: item.frequencyUnit, // 频率单位
rangeRange: item.rangeRange, // 量程
standardValue: item.standardValue, // 标准值
resolution: Number(item.resolution), // 分辨力
indicatingValue: itemCategoryName === '数字多用表(手持)'
|| itemCategoryName === '钳形电流表'
|| itemCategoryName === '数字多用表(台式)'
? ''
: item.indicatingValue, /// 示值
lineMode: item.lineMode || '/',
// maximumError: itemCategoryName === '指针式万用表' ? useMaximumError(item.accuracyA!, item.fullScaleValue!) + item.fullScaleValueUnit! : item.maximumError, // 最大允许误差
maximumError: item.maximumError, // 最大允许误差
maximumErrorFormula: item.maximumError, // 最大允许误差公式
absoluteError: '', // 绝对误差
remark: '', // 输出备注
an: '', // AN
bn: '', // BN
cn: '', // CN
deltaAn: '', // △AN
deltaBn: '', // △BN
deltaCn: '', // △CN
measureIndicationValue: item.measureIndicationValue, // 被检表示值
errorParamA: item.errorParamA, // 误差参数a
errorParamB: item.errorParamB, // 误差参数b
accuracyA: item.accuracyA, // 准确度a ---用于指针式万用表最大允许误差计算
fullScaleValue: item.fullScaleValue, // 指针式仪表满量程值---用于指针式万用表最大允许误差计算
fullScaleValueUnit: item.fullScaleValueUnit, // 指针式仪表满量程值单位---用于指针式万用表最大允许误差计算
standardValueUpper: measureItemConfigCalibrator.value.standardValueUpper, // 标准值上限
standardValueUpperUnit: measureItemConfigCalibrator.value.standardValueUpperUnit,
}
},
) // 检定项表格
}
}
// 获取检定项分类的技术文件
// 查询条件
const fetchClassificationListQuery = ref({
belongStandardEquipment: '', // 检校标准库
categoryName: '', // 检定项分类名称
categoryNo: '', // 检定项分类编号
deviceType: '', // 智能模型分类
measureCategory: '', // 检校类别
limit: 20,
offset: 1,
})
// 删除依据的技术文件
const delFile = (index: number) => {
if (Array.isArray(form.value.technologyFile)) {
form.value.technologyFile.splice(index, 1)
}
}
// 数据查询--依据的技术文件
function fetchClassificationData(isNowPage = false, categoryName = '', belongStandardEquipment = '') {
if (!isNowPage) {
// 是否显示当前页，否则跳转第一页
listQuery.value.offset = 1
}
fetchClassificationListQuery.value.categoryName = categoryName // 智能模型分类型名称
fetchClassificationListQuery.value.belongStandardEquipment = belongStandardEquipment // 检校标准装置名称
getClassificationList(fetchClassificationListQuery.value).then((response) => {
if (response.data.rows.length) {
form.value.humidityLower = response.data.rows[0].humidityLower// 湿度下限
form.value.humidityUpper = response.data.rows[0].humidityUpper// 湿度上限
form.value.temperatureLower = response.data.rows[0].temperatureLower// 温度下限
form.value.temperatureUpper = response.data.rows[0].temperatureUpper// 温度上限
console.log('温度下限', form.value.temperatureLower)
console.log('温度上限', form.value.temperatureUpper)
console.log('湿度下限', form.value.humidityLower)
console.log('湿度上限', form.value.temperatureLower)
if (pageType.value === 'add') {
if (user.bizLabCode === 'H') { // 当前用户是海口实验室的
form.value.measureAddress = response.data.rows[0].labH
}
else if (user.bizLabCode === 'X') { // 当前用户是西昌实验室的
form.value.measureAddress = response.data.rows[0].labX
}
if (form.value.measureAddress) {
const index = positionList.value.findIndex((item: { name: string }) => item.name === form.value.measureAddress)
if (index !== -1) {
form.value.temperature = positionList.value[index].temperature
form.value.humidity = positionList.value[index].humidity
}
}
}
if (pageType.value === 'add' && response.data.rows.length) {
form.value.technologyFile = response.data.rows[0].technologyFile.split(';')
if (pageType.value === 'add') { form.value.measureCategory = response.data.rows[0].measureCategory } // 检校类别
}
}
})
}
// ----------------------------------------点击保存时校验---------------------------------------
// 校验
const checkout = (isSave = true) => {
if (itemCategoryName.value === '多功能电力参数测量仪') {
if (!form.value.ipri) {
ElMessage.warning('请输入电流转换系数Ipri')
return false
}
if (!form.value.ipriUnit) {
ElMessage.warning('请输入电流转换系数Ipri单位')
return false
}
if (!form.value.isec) {
ElMessage.warning('请输入电流转换系数Isec')
return false
}
if (!form.value.isecUnit) {
ElMessage.warning('请输入电流转换系数Isec单位')
return false
}
if (!form.value.vpri) {
ElMessage.warning('请输入电压转换系数Vpri')
return false
}
if (!form.value.vpriUnit) {
ElMessage.warning('请输入电压转换系数Vpri单位')
return false
}
if (!form.value.vsec) {
ElMessage.warning('请输入电压转换系数Vsec')
return false
}
if (!form.value.vsecUnit) {
ElMessage.warning('请输入电压转换系数Vsec单位')
return false
}
}
else {
if (isSave) {
if (!measureDataCalibratorList.value.length) {
ElMessage.warning('所使用的标准，主要测量智能模型不能为空')
return false
}
if (appearanceFunctionCheck.value && !form.value.appearanceFunctionCheck) {
ElMessage.warning('外观及功能性检查 不能为空')
return false
}
}
if (!useCheckList(list.value, measureColumns.value, '检定数据')) {
return false
}
}
return true
}
const checkoutCommonForm = () => {
if (!measureDataCalibratorList.value.length) {
ElMessage.warning('所使用的标准，主要测量智能模型不能为空')
return false
}
if (isNeverDefineItemCategory.value) { // 检定项是从未定义过的
console.log('校验从未定义过的检定项')
// 在这里校验上传的证书
if (!form.value.constCertificateExcelData) {
ElMessage.warning('请上传检校证书')
return false
}
if (!form.value.constRecordExcelData) {
ElMessage.warning('请上传原始记录')
return false
}
}
return true
}
// -----------------------------------------生成结果处理----------------------------------------
const measureTableLoading = ref(false) // 表格loading
// 点击生成结果处理
const createResult = () => {
if (!list.value.length) {
ElMessage.warning('没有检定项数据，无法生成结果')
return false
}
if (!checkout(false)) {
return false
}
let tempList = []
if (form.value.itemCategoryName === '多功能电力参数测量仪') {
tempList = list.value.map((item, index) => {
return {
...item,
ipri: form.value.ipri, // 电流转换系数
ipriUnit: form.value.ipriUnit, // 电流转换系数单位
isec: form.value.isec, // 电流转换系数
isecUnit: form.value.isecUnit, // 电流转换系数单位
vpri: form.value.vpri, // 电压转换系数
vpriUnit: form.value.vpriUnit, // 电压转换系数单位
vsec: form.value.vsec, // 电压转换系数
vsecUnit: form.value.vsecUnit, // 电压转换系数单位
}
})
}
else if (form.value.itemCategoryName === '交流电压表') {
tempList = list.value.map((item, index) => {
return {
...item,
standardValueUpperLimit: measureItemConfigCalibrator.value.standardValueUpper, // 标准值上限
measureIndicationValue: getDataNum(item.measureIndicationValue), // 被检表示值（单位）
}
})
}
else {
tempList = list.value
}
const params = {
belongStandardEquipment: form.value.belongStandardEquipment, // 检校标准库
itemCategoryName: form.value.itemCategoryName, // 检定项分类名称
measureDataCalibratorList: tempList.map((item) => {
return {
...item,
maximumError: getDataNum(removeSign(item.maximumError)),
}
}),
measureItemConfigCalibrator: measureItemConfigCalibrator.value,
}
measureTableLoading.value = true
calculateHandle(params).then((res) => {
if (res.data && res.data.length) {
list.value = res.data.map((item: IDetailMeasureList, index: number) => {
return {
...item,
resolution: Number(item.resolution),
maximumError: addSign(item.maximumError),
ANRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaAn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △AN标星
BNRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaBn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △BN标星
CNRedStar: itemCategoryName.value === '多功能电力参数测量仪' ? Math.abs(Number(item.deltaCn)) <= Number(item.maximumError.slice(1)) ? 'normal' : 'error' : 'normal', // △CN标星
redStar: Math.abs(Number(item.absoluteError)) <= Math.abs(Number(getDataNum(item.maximumError))) ? 'normal' : 'error',
}
}) // 检定数据
}
else {
list.value = res.data
}
measureTableLoading.value = false
}).catch(() => {
measureTableLoading.value = false
})
}
// -------------------------------------示值focus事件------------------------------------------
// 第一次点击示值，把标准值默认赋值给示值
const indicatingValueFocus = (row: IDetailMeasureList) => {
if (itemCategoryName.value === '数字多用表(手持)' || itemCategoryName.value === '钳形电流表' || itemCategoryName.value === '数字多用表(台式)') {
if (`${row.indicatingValue}` === '') {
row.indicatingValue = row.standardValue
}
}
}
// ---------------------------------------点击任务单编号事件---------------------------------------
// 点击任务单编号
const handleClickOrder = () => {
$router.push({
path: `/manager/detail/${form.value.orderId}`,
})
}
// -------------------------------------地点变化事件--------------------------------------------
const handleChangeAddress = (name: string) => {
if (name) {
const index = positionList.value.findIndex((item: { name: string }) => item.name === name)
if (index !== -1) {
form.value.temperature = positionList.value[index].temperature
form.value.humidity = positionList.value[index].humidity
}
}
}
// -------------------------------------------文件上传--------------------------------------
// 文件上传
const certificateFileRef = ref()
const originalRecordFileRef = ref()
const onCertificateFileChange = (event: any) => {
if (isNeverDefineItemCategory.value) { // 新增检定项分类模式上传word
if (event.target.files[0].type !== 'application/msword' && event.target.files[0].type !== 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') {
ElMessage.warning('请上传doc、docx文件格式')
return
}
}
else { // 康斯特模式上传pdf
if (event.target.files[0].type !== 'application/pdf') {
ElMessage.warning('请上传pdf格式')
return
}
}
UploadFileFn(event, 'constCertificateExcelData', '文件上传成功')
}
const onOriginalRecordFileChange = (event: any) => {
if (isNeverDefineItemCategory.value) { // 新增检定项分类模式上传word
if (event.target.files[0].type !== 'application/msword' && event.target.files[0].type !== 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') {
ElMessage.warning('请上传doc、docx文件格式')
return
}
}
else { // 康斯特模式上传pdf
if (event.target.files[0].type !== 'application/pdf') {
ElMessage.warning('请上传pdf格式')
return
}
}
UploadFileFn(event, 'constRecordExcelData', '文件上传成功')
}
// 上传文件操作
function UploadFileFn(event: any, prop: string, message: string) {
if (event.target.files?.length !== 0) {
// 创建formdata对象
const fd = new FormData()
fd.append('multipartFile', event.target.files[0])
const loading = ElLoading.service({
lock: true,
background: 'rgba(255, 255, 255, 0.8)',
})
UploadFile(fd).then((res) => {
if (res.code === 200) {
form.value[prop] = res.data[0]
event.target.value = null
// 重置当前验证
ElMessage.success(message)
loading.close()
}
else {
ElMessage.error(res.message)
loading.close()
}
})
}
}
const upload = (fileRef: any) => {
fileRef.click()
}
// --------------------------------------根据智能模型id查询此智能模型上次使用的标准，主要测量智能模型-----------------------------------------------
// 查询标准装置下的配套智能模型
const fetchStandardEquipment = (list: any = []) => {
const resultList = [] as any
const allRequest = [] as any // 所有的请求
// 请求标准装置下的配套智能模型
list.forEach((e: any) => {
const request = getEquipmentList({
standardId: e.standardId, // 标准库id
standardName: e.standardName, // 选好的标准库name
offset: 1,
limit: 999999,
}).then((res) => {
if (res && res.data && res.data.rows && res.data.rows.length) {
const solveResList = res.data.rows.map((item: any) => {
if (!item.technicalTargetList.length) {
return {
...item,
standardId: e.standardId, // 标准库id
standardName: e.standardName, // 标准库名称
}
}
else {
let tempUncertainty = '' // 不确定度
let tempMeasureRange = '' // 测量范围
item.technicalTargetList.forEach((i: any) => {
tempUncertainty = `${tempUncertainty}${i.uncertainty}; `
tempMeasureRange = `${tempMeasureRange}${i.measureRange}; `
})
return {
...item,
uncertainty: tempUncertainty,
measureRange: tempMeasureRange,
standardId: e.standardId, // 标准库id
standardName: e.standardName, // 标准库名称
}
}
})
// 从对应的标准装置中挑出上次存的所有的智能模型
const map = new Map()
solveResList.forEach((item: { id: string }, index: number) => {
map.set(item.id, item)
})
e.standardEquipmentIds.forEach((id: string) => {
resultList.push(map.get(id))
})
}
})
allRequest.push(request)
})
Promise.all(allRequest).then(() => { // 等待所有请求完成
measureDataCalibratorList.value = resultList
})
}
const fetchRecentEquipment = (id: string) => {
if (!id) { return false }
getRecentList({ id }).then((res) => {
if (res && res.data && res.data.length) {
fetchStandardEquipment(res.data)
}
})
}
// ------------------------------------------钩子----------------------------------------------
watch(
() => itemCategoryName.value,
(newValue) => {
const index = categoryNameDict.findIndex((item: any) => item === newValue)
if (index === -1) {
isNeverDefineItemCategory.value = true
}
else {
isNeverDefineItemCategory.value = false
}
if (newValue) {
switch (newValue) {
case '数字多用表(手持)':
console.log('匹配到数字多用表(手持)')
measureColumns.value = columns_digitalMultimeterHandheld.value
break
case '数字多用表(台式)':
measureColumns.value = columns_digitalMultimeterTable.value
break
case '多功能电力参数测量仪':
measureColumns.value = columns_multifunctionalPowerParameterMeasuringInstrument.value
break
case '钳形电流表':
measureColumns.value = columns_digitalMultimeterHandheld.value
break
case '指针式万用表':
measureColumns.value = columns_digitalMultimeterHandheld.value
break
// default: // 交流电压表、交流电流表、直流电压表、直流电流表、75mV电流表
// measureColumns.value = columns_lastFive.value
// break
}
console.log(measureColumns.value)
}
},
{ immediate: true },
)
watch(
() => props.infoId,
(newValue) => {
if (newValue) {
getInfoId.value = newValue
if (pageType.value === 'detail' && form.value.belongStandardEquipment) {
fetchInfo()
}
}
},
{ immediate: true },
)
watch(
() => props.dataNo,
(newValue) => {
if (newValue) {
form.value.dataNo = newValue
}
},
{ immediate: true },
)
// 监听列表合并列
// watch(() => list.value, (newValue) => {
// if (Array.isArray(newValue)) {
// list.value = list.value.map((item) => {
// return {
// ...item,
// resolution: Number(item.resolution),
// // redStar: Math.abs(Number(item.absoluteError)) <= Math.abs(Number(getDataNum(item.maximumError))) ? 'normal' : 'error',
// }
// })
// }
// if (pageType.value === 'detail') {
// if (itemCategoryName.value === '数字多用表(手持)' || itemCategoryName.value === '钳形电流表' || itemCategoryName.value === '指针式万用表') {
// useMergeTableRow(list.value, ['params', 'capacity', 'unit', 'frequency', 'frequencyUnit', 'rangeRange', 'standardValue', 'resolution'])
// }
// }
// }, { deep: true })
onMounted(async () => {
console.log(pageType.value, 'pageType')
console.log(getInfoId.value, 'getInfoId.value')
pageType.value === 'add'
getDict().then(() => {
if (pageType.value === 'add') {
// 从我的任务跳转过来（新增）
form.value.orderId = $route.query.orderId as string // 任务单id
form.value.orderNo = $route.query.orderNo as string // 任务单编号
form.value.customerName = $route.query.customerName as string // 委托单位
form.value.traceDate = dayjs().format('YYYY-MM-DD') // 测试校准检定日期默认今天
form.value.measureValidDate = `${dayjs().add(Number($route.query.checkCycle), 'month').subtract(1, 'day')}` // 检定有效期--今天 + 检定周期 - 1天
form.value.measureValidDate = dayjs(form.value.measureValidDate).format('YYYY-MM-DD')
form.value.createUserName = user.name // 检定员
form.value.itemId = $route.query.itemId as string // 检定项id
form.value.itemCategoryName = $route.query.itemCategoryName as string // 智能模型检定项分类名称
form.value.itemCategoryId = $route.query.itemCategoryId as string // 智能模型检定项分类名称id
form.value.belongStandardEquipment = $route.query.belongStandardEquipment as string // 标准装置code
form.value.belongStandardEquipmentName = $route.query.belongStandardEquipmentName as string // 标准装置名称
sampleList.value = [
{
// 被检智能模型
sampleId: $route.query.sampleId, // 智能模型id
sampleName: $route.query.sampleName, // 智能模型名称
sampleModel: $route.query.sampleModel, // 规格型号
manufactureNo: $route.query.manufactureNo, // 出厂编号
manufacturer: $route.query.manufacturer, // 制造厂家（厂商）
categoryName: $route.query.itemCategoryName, // 智能模型检定项分类
helpInstruction: $route.query.helpInstruction, // 辅助字段
helpFieldInstruction: $route.query.helpFieldInstruction, // 辅助字段说明
},
]
helpInstruction.value = $route.query.helpInstruction as string // 辅助字段
helpFieldInstruction.value = $route.query.helpFieldInstruction as string // 辅助字段说明
itemCategoryName.value = $route.query.itemCategoryName as string // 智能模型检定项分类名称
// 查依据的技术文件（编号、名称）
fetchClassificationData(
false,
$route.query.itemCategoryName! as string,
$route.query.belongStandardEquipment as string,
)
// 查输入值(查检定项管理的详情)
fetchItemInfo(
$route.query.itemId! as string,
$route.query.itemCategoryName! as string,
$route.query.belongStandardEquipment as string,
)
form.value.labCode = user.bizLabCode // 实验室
form.value.groupCode = user.groupNo // 部门名称
fetchRecentEquipment($route.query.sampleId as string)
}
else {
helpInstruction.value = $route.query.helpInstruction as string // 辅助字段
form.value.itemCategoryName = $route.query.itemCategoryName as string // 智能模型检定项分类名称
itemCategoryName.value = $route.query.itemCategoryName as string // 智能模型检定项分类名称
form.value.itemCategoryId = $route.query.itemCategoryId as string // 智能模型检定项分类名称id
form.value.belongStandardEquipment = $route.query.belongStandardEquipment as string // 标准装置code
form.value.belongStandardEquipmentName = $route.query.belongStandardEquipmentName as string // 标准装置名称
fetchInfo()
}
})
})
// 检定结论变化
const changeConclusion = (val: string) => {
if (val === '所检项目合格') {
form.value.meterIdentify = '合格'
form.value.remark = `经${measureCategoryDict.value[form.value.measureCategory]}，该${sampleList.value[0].sampleName}所${measureCategoryDict.value[form.value.measureCategory]}指标均符合技术说明书要求。` // 检校类别
}
else if (val === '不合格') {
form.value.meterIdentify = '停用'
form.value.remark = `经${measureCategoryDict.value[form.value.measureCategory]}，该${sampleList.value[0].sampleName}所${measureCategoryDict.value[form.value.measureCategory]}指标不符合技术说明书要求。` // 检校类别
}
else {
form.value.meterIdentify = '停用'
form.value.remark = `经${measureCategoryDict.value[form.value.measureCategory]}，该${sampleList.value[0].sampleName}所${measureCategoryDict.value[form.value.measureCategory]}指标除*外所检项目符合技术说明书要求。` // 检校类别
}
emits('changeMeterIdentify', form.value.meterIdentify)
}
// 计量标识变化
const changeMeterIdentify = () => {
emits('changeMeterIdentify')
}
defineExpose({
fetchInfo,
checkout,
form,
list,
measureDataCalibratorList,
ruleFormRef,
sampleList,
pageType,
measureItemConfigCalibrator,
checkoutCommonForm,
})
</script>
<template>
<!-- 表单 -->
<detail-block title="">
<el-form
ref="ruleFormRef"
:model="form"
label-width="180"
label-position="right"
:rules="rules"
>
<el-row :gutter="24">
<el-col :span="8">
<el-form-item label="检定数据编号:" prop="dataNo">
<el-input
v-model="form.dataNo"
disabled
placeholder="系统自动生成"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="检校类别:" prop="measureCategory">
<el-select
v-model="form.measureCategory"
placeholder="检校类别"
filterable
:disabled="pageType === 'detail'"
class="full-width-input"
>
<el-option
v-for="item in measureCategoryList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="委托单位:" prop="customerName">
<el-input
v-model="form.customerName"
disabled
:placeholder="pageType === 'detail' ? ' ' : '系统自动生成'"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="测试、校准或检定日期:" prop="traceDate">
<el-date-picker
v-model="form.traceDate"
type="date"
format="YYYY-MM-DD"
value-format="YYYY-MM-DD"
:placeholder="pageType === 'detail' ? ' ' : '请选择日期'"
:disabled="pageType === 'detail'"
class="full-width-input"
@change="changeMeterIdentify"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="检定有效期:" prop="measureValidDate">
<el-date-picker
v-model="form.measureValidDate"
type="date"
format="YYYY-MM-DD"
value-format="YYYY-MM-DD"
:placeholder="pageType === 'detail' ? ' ' : '请选择日期'"
:disabled="pageType === 'detail'"
class="full-width-input"
@change="changeMeterIdentify"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="测试、校准或检定地点:" prop="measureAddress">
<el-select
v-model="form.measureAddress"
placeholder="测试、校准或检定地点"
filterable
:disabled="pageType === 'detail'"
class="full-width-input"
@change="handleChangeAddress"
>
<el-option
v-for="item in positionList"
:key="item.id"
:label="item.name"
:value="item.name"
/>
</el-select>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="温度(℃):" prop="temperature">
<el-input
v-model="form.temperature"
:disabled="pageType === 'detail'"
:placeholder="pageType === 'detail' ? ' ' : '请输入温度'"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="相对湿度(%RH):" prop="humidity">
<el-input
v-model="form.humidity"
:disabled="pageType === 'detail'"
:placeholder="pageType === 'detail' ? ' ' : '请输入相对湿度'"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="任务单编号:" prop="orderNo">
<span class="link" @click="handleClickOrder">{{ form.orderNo }}</span>
<!-- <el-input
v-model="form.orderNo"
disabled
placeholder="任务单编号"
/> -->
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="实验室" prop="labCode">
<el-select
v-model="form.labCode"
:placeholder="pageType === 'detail' ? ' ' : '请选择实验室'"
disabled
class="full-width-input"
>
<el-option
v-for="item in labCodeList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="部门" prop="groupCode">
<el-select
v-model="form.groupCode"
:placeholder="pageType === 'detail' ? ' ' : '请选择部门'"
disabled
class="full-width-input"
>
<el-option
v-for="item in groupCodeList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="检定员:" prop="dacreateUserNametaNo">
<el-input
v-model="form.createUserName"
disabled
placeholder="检定员"
/>
</el-form-item>
</el-col>
<el-col v-if="pageType !== 'add'" :span="8">
<el-form-item label="数据来源:" prop="dataSource">
<el-input
v-model="form.dataSource"
disabled
placeholder="数据来源"
/>
</el-form-item>
</el-col>
<el-col :span="8">
<el-form-item label="计量标识:" prop="meterIdentify">
<el-select
v-model="form.meterIdentify"
class="full-width-input"
:disabled="pageType === 'detail'"
placeholder="计量标识"
@change="changeMeterIdentify"
>
<el-option v-for="item of meterIdentifyDict" :key="item.value" :label="item.name" :value="item.name" />
</el-select>
</el-form-item>
</el-col>
<el-col v-if="form.measureCategory !== '2'" :span="8">
<el-form-item label="检定结论:" prop="conclusion">
<el-select
v-model="form.conclusion"
placeholder="请选择检定结论"
filterable
:disabled="pageType === 'detail'"
class="full-width-input"
@change="changeConclusion"
>
<el-option
v-for="item in conclusionList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
<el-col v-if="form.conclusion === '除*外其余所检项目合格'" :span="16">
<el-form-item label="限用说明:" prop="restrictionInstruction">
<el-input
v-model="form.restrictionInstruction"
type="textarea"
autosize
:disabled="pageType === 'detail'"
placeholder="请输入限用说明"
/>
</el-form-item>
</el-col>
</el-row>
<el-row :gutter="24" class="marg">
<el-col :span="24">
<el-form-item label="依据的技术文件:" prop="technologyFile">
<div
v-for="(item, index) in form.technologyFile"
:key="index"
style="display: flex;"
>
<show-photo :minio-file-name="item">
<span v-if="pageType !== 'detail'" class="photo-close" @click="delFile(index)">×</span>
</show-photo>
</div>
<span v-if="pageType === 'detail' && !form.technologyFile">无</span>
</el-form-item>
</el-col>
</el-row>
</el-form>
</detail-block>
<!-- 被检件信息 -->
<detail-block title="被检件信息">
<el-table :data="sampleList" border style="width: 100%;">
<el-table-column align="center" label="序号" width="80" type="index" />
<el-table-column
v-for="item in columns"
:key="item.value"
:prop="item.value"
:label="item.text"
align="center"
/>
</el-table>
</detail-block>
<detail-block title="所使用的标准，主要测量智能模型">
<template v-if="pageType !== 'detail'" #btns>
<el-button type="primary" @click="multiFilesAdd">
批量添加
</el-button>
<el-button type="info" @click="delRow">
删除行
</el-button>
</template>
<el-table
v-loading="tableLoading"
:data="measureDataCalibratorList"
border
style="width: 100%;"
@selection-change="handleSelectionChange"
>
<el-table-column
v-if="pageType !== 'detail'"
type="selection"
width="38"
/>
<el-table-column align="center" label="序号" width="80" type="index" />
<el-table-column
v-for="item in measureDataCalibratorColumns"
:key="item.value"
:prop="item.value"
:label="item.text"
:width="item.width"
align="center"
/>
</el-table>
</detail-block>
<!-- 从未定义过的检定项分类\const展示 -->
<detail-block
v-if="isNeverDefineItemCategory || form.dataSource === '康斯特自动检定系统'"
title="检定数据"
:class="pageType === 'detail' ? 'setBottom' : ''"
>
<el-form
v-if="form.dataSource !== '康斯特自动检定系统'"
ref="ruleFormFileRef"
:model="form"
label-width="100"
label-position="right"
:rules="rules"
>
<el-row :gutter="24">
<el-col :span="12">
<el-form-item label="检校证书:" prop="constCertificateExcelData">
<show-photo v-if="form.constCertificateExcelData" :minio-file-name="form.constCertificateExcelData" />
<span v-if="!form.constCertificateExcelData && pageType === 'detail'" style="margin-right: 10px;">无</span>
<input v-show="pageType === ''" ref="certificateFileRef" type="file" @change="onCertificateFileChange">
<el-button v-if="pageType !== 'detail'" id="file" type="primary" :style="{ 'margin-left': form.constCertificateExcelData === '' ? '0px' : '20px' }" @click="upload(certificateFileRef)">
{{ form.constCertificateExcelData === '' ? '上传' : '更换附件' }}
</el-button>
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="原始记录:" prop="constRecordExcelData">
<show-photo v-if="form.constRecordExcelData" :minio-file-name="form.constRecordExcelData" />
<span v-if="!form.constRecordExcelData && pageType === 'detail'" style="margin-right: 10px;">无</span>
<input v-show="pageType === ''" ref="originalRecordFileRef" type="file" @change="onOriginalRecordFileChange">
<el-button v-if="pageType !== 'detail'" id="file" type="primary" :style="{ 'margin-left': form.constRecordExcelData === '' ? '0px' : '20px' }" @click="upload(originalRecordFileRef)">
{{ form.constRecordExcelData === '' ? '上传' : '更换附件' }}
</el-button>
</el-form-item>
</el-col>
</el-row>
</el-form>
<!-- 新增检定项分类预览word -->
<div v-if="isNeverDefineItemCategory && form.dataSource !== '康斯特自动检定系统'" style="display: flex; padding: 10px 10px 20px 0;box-sizing: border-box;">
<word-oreview style="flex: 1;margin-right: 10px;" :print-file-name="form.constCertificateExcelData" />
<word-oreview style="flex: 1;" :print-file-name="form.constRecordExcelData" />
</div>
<!-- 康斯特预览PDF -->
<div v-if="!isNeverDefineItemCategory && form.dataSource === '康斯特自动检定系统'" style="display: flex; padding: 10px 10px 20px 0;box-sizing: border-box;">
<file-preview-url style="flex: 1;margin-right: 10px;" :print-file-name="form.constCertificateExcelData" />
<file-preview-url style="flex: 1;" :print-file-name="form.constRecordExcelData" />
</div>
</detail-block>
<!-- 标签 -->
<detail-block
v-if="!isNeverDefineItemCategory && form.dataSource !== '康斯特自动检定系统'"
: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'"
ref="formRef"
:model="form"
label-width="150"
label-position="right"
:rules="rules"
style="margin-top: 20px;"
>
<el-row v-if="`${appearanceFunctionCheck}` !== '0'">
<el-col :span="12">
<el-form-item
label="外观及功能性检查:"
prop="appearanceFunctionCheck"
>
<el-input
v-model="form.appearanceFunctionCheck"
class="full-width-input"
autosize
type="textarea"
:disabled="pageType === 'detail'"
/>
</el-form-item>
</el-col>
</el-row>
<!-- 多功能电力参数测量仪 -->
<el-row v-if="itemCategoryName === '多功能电力参数测量仪'" :gutter="24">
<el-col :span="12" style="display: flex; justify-content: flex-start;">
<el-form-item label="电流转换系数:" prop="ipri">
<el-input
v-model="form.ipri"
placeholder="Ipri"
:disabled="pageType === 'detail'"
style="flex: 1;"
/>
</el-form-item>
<el-form-item label-width="10" prop="ipriUnit">
<!-- 单位 -->
<el-select
v-model="form.ipriUnit"
placeholder="单位"
:disabled="pageType === 'detail'"
filterable
style="width: 100px;"
>
<el-option
v-for="item in IUnitList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
<span style="margin-left: 10px;">/</span>
<el-form-item label="" label-width="10" prop="isec">
<el-input
v-model="form.isec"
placeholder="Isec"
:disabled="pageType === 'detail'"
style="flex: 1;"
/>
</el-form-item>
<el-form-item label-width="10" prop="isecUnit">
<!-- 单位 -->
<el-select
v-model="form.isecUnit"
placeholder="单位"
:disabled="pageType === 'detail'"
filterable
style="width: 100px;"
>
<el-option
v-for="item in IUnitList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
<el-col :span="12" style="display: flex; justify-content: flex-start;">
<el-form-item label="电压转换系数:" prop="vpri">
<el-input
v-model="form.vpri"
placeholder="Vpri"
:disabled="pageType === 'detail'"
style="flex: 1;"
/>
</el-form-item>
<el-form-item label-width="10" prop="vpriUnit">
<!-- 单位 -->
<el-select
v-model="form.vpriUnit"
placeholder="单位"
:disabled="pageType === 'detail'"
filterable
style="width: 100px;"
>
<el-option
v-for="item in UUnitList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
<span style="margin-left: 10px;">/</span>
<el-form-item label="" label-width="10" prop="vsec">
<el-input
v-model="form.vsec"
placeholder="Vsec"
:disabled="pageType === 'detail'"
style="flex: 1;"
/>
</el-form-item>
<el-form-item label-width="10" prop="vsecUnit">
<!-- 单位 -->
<el-select
v-model="form.vsecUnit"
placeholder="单位"
:disabled="pageType === 'detail'"
filterable
style="width: 100px;"
>
<el-option
v-for="item in UUnitList"
:key="item.id"
:label="item.name"
:value="item.value"
/>
</el-select>
</el-form-item>
</el-col>
</el-row>
<div style="display: flex; justify-content: space-between;">
<div style="font-size: 14px; color: #606266; padding: 0 20px 20px;">
示值误差:
</div>
<el-button
v-if="pageType !== 'detail'"
type="primary"
@click="createResult"
>
生成结果处理
</el-button>
</div>
<!-- 交流电压表、交流电流表、直流电压表、直流电流表、75mV电流表 -->
<div
v-if="
itemCategoryName === '交流电压表'
|| itemCategoryName === '交流电流表'
|| itemCategoryName === '直流电压表'
|| itemCategoryName === '直流电流表'
|| itemCategoryName === '75mV电流表'
"
style="font-size: 14px; color: #606266; padding: 0 80px 20px;"
>
<span>转换系数：<span style="font-weight: 600;">{{ measureItemConfigCalibrator.fullScaleValue }}({{
measureItemConfigCalibrator.fullScaleValueUnit
}}) / {{ measureItemConfigCalibrator.standardValueUpper }}({{
measureItemConfigCalibrator.standardValueUpperUnit
}})</span></span>
<span style="display: inline-block; margin-left: 20px;">准确度等级:<span
style="display: inline-block; font-weight: 600; margin-left: 10px;"
>{{ measureItemConfigCalibrator.accuracyLevel }}</span>
</span>
</div>
</el-form>
<!-- 检定数据表格 -->
<el-table
v-show="current === 'measure-data'"
ref="tableRef"
v-loading="measureTableLoading"
:data="list"
border
style="width: 100%;"
@selection-change="handleSelectionChange"
>
<el-table-column align="center" label="序号" width="80" type="index" />
<el-table-column
v-for="item in measureColumns"
:key="item.value"
:prop="item.value"
:label="item.text"
:width="item.width"
align="center"
>
<template #header>
<span v-show="item.required" style="color: red;">*</span><span>{{ item.text }}</span>
</template>
<template #default="scope">
<!-- 频率,频率单位 -->
<span v-if="(item.value === 'frequency' && scope.row.params !== 'ACV' && scope.row.params !== 'ACI') || (item.value === 'frequencyUnit' && scope.row.params !== 'ACV' && scope.row.params !== 'ACI')">/</span>
<!-- 两线/四线模式 -->
<!-- <el-select
v-if="pageType !== 'detail' && item.value === 'lineMode' && scope.row.params === 'R'"
v-model="scope.row[item.value]"
placeholder="请选择"
filterable
>
<el-option v-for="item in lineModeList" :key="item.id" :label="item.name" :value="item.value" />
</el-select> -->
<!-- 示值 -->
<el-autocomplete
v-if="pageType !== 'detail' && item.value === 'indicatingValue' && (itemCategoryName === '数字多用表(手持)' || itemCategoryName === '数字多用表(台式)' || itemCategoryName === '钳形电流表')"
v-model="scope.row[item.value]"
:fetch-suggestions="suggestions_number"
:placeholder="pageType === 'detail' ? '' : `${item.text}`"
:disabled="pageType === 'detail'"
style="width: 90%;"
clearable
@focus="indicatingValueFocus(scope.row)"
/>
<!-- <el-input
v-if="itemCategoryName !== '指针式万用表' && itemCategoryName !== '交流电压表' && itemCategoryName !== '交流电流表' && itemCategoryName !== '直流电压表'
&& itemCategoryName !== '直流电流表'
&& itemCategoryName !== '75mV电流表'
&& pageType !== 'detail'
&& item.value === 'indicatingValue'
&& itemCategoryName !== '数字多用表(手持)' && itemCategoryName !== '数字多用表(台式)' && itemCategoryName === '钳形电流表'
"
v-model="scope.row[item.value]"
:placeholder="`${item.text}`"
class="input"
@focus="indicatingValueFocus(scope.row)"
/> -->
<!-- 标准值 -->
<el-input
v-if="
(itemCategoryName === '指针式万用表'
|| itemCategoryName === '交流电压表'
|| itemCategoryName === '交流电流表'
|| itemCategoryName === '直流电压表'
|| itemCategoryName === '直流电流表'
|| itemCategoryName === '75mV电流表')
&& pageType !== 'detail'
&& item.value === 'standardValue'
"
v-model="scope.row[item.value]"
:placeholder="`${item.text}`"
class="input"
/>
<!-- 输出备注 -->
<el-input
v-if="pageType !== 'detail' && item.value === 'remark'"
v-model="scope.row[item.value]"
type="textarea"
autosize
:placeholder="`${item.text}`"
class="input"
/>
<!-- AN、BN、CN -->
<precision-input-number
v-if="pageType !== 'detail' && (item.value === 'an' || item.value === 'bn' || item.value === 'cn')"
v-model="scope.row[item.value]"
:placeholder="pageType === 'detail' ? '' : '请输入'"
:disabled="pageType === 'detail'"
/>
<!-- 绝对误差 -->
<div v-if="item.value === 'absoluteError'">
<span>{{ scope.row.absoluteError }}</span>
<span
v-if="scope.row.redStar === 'error' && `${scope.row.absoluteError}` !== ''"
style="color: red;"
>*</span>
</div>
<!-- △AN标星 -->
<div v-if="item.value === 'deltaAn'">
<span>{{ scope.row.deltaAn }}</span>
<span v-if="scope.row.ANRedStar === 'error' && `${scope.row.deltaAn}` !== ''" style="color: red;">*</span>
</div>
<!-- △BN标星 -->
<div v-if="item.value === 'deltaBn'">
<span>{{ scope.row.deltaBn }}</span>
<span v-if="scope.row.BNRedStar === 'error' && `${scope.row.deltaBn}` !== ''" style="color: red;">*</span>
</div>
<!-- △CN标星 -->
<div v-if="item.value === 'deltaCn'">
<span>{{ scope.row.deltaCn }}</span>
<span v-if="scope.row.CNRedStar === 'error' && `${scope.row.deltaCn}` !== ''" style="color: red;">*</span>
</div>
</template>
</el-table-column>
</el-table>
<!-- 历史修改记录 -->
<change-record
v-if="pageType === 'detail' && current === 'change-record'"
:info-id="getInfoId"
/>
</detail-block>
<el-form
v-if="current === 'measure-data' && !isNeverDefineItemCategory && form.dataSource !== '康斯特自动检定系统'"
ref="formRef"
:model="form"
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="form.remark"
autosize
type="textarea"
:disabled="pageType === 'detail'"
:placeholder="pageType === 'detail' ? ' ' : '请输入备注'"
/>
</el-form-item>
</el-col>
</el-row>
</el-form>
<!-- 选择标准库组件 -->
<select-standard
ref="selectStandardRef"
:is-multi="true"
@confirm="confirmSelectStandard"
/>
</template>
<style lang="scss" scoped>
.link {
text-decoration: underline;
color: #3d7eff;
cursor: pointer;
}
.setBottom {
padding-bottom: 20px;
}
</style>