You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
12 KiB
390 lines
12 KiB
import moment from 'moment'
|
|
import { getLatestSn } from '@/api/template';
|
|
import { sj_subpackage, sj_startConfiguration, sj_configurationCompleted } from '@/api/business/sj/sj';
|
|
export default {
|
|
dicts: [
|
|
'business_pztj',
|
|
'business_cctj',
|
|
'business_nddw',
|
|
'business_tjdw',
|
|
'business_yxqdw',
|
|
'business_rqcz',
|
|
|
|
'business_sp_jmdyzqdyp', //色谱-编号-准确度与精密度
|
|
'business_sp_nbgzy', //色谱-编号-内标工作液
|
|
'business_sp_zkgzy', //色谱-编号-质控工作液
|
|
'business_sp_bqgzy', //色谱-编号-标曲工作液
|
|
'business_sp_bzqxzkypzbb', //色谱-编号-标准曲线/质控样品制备表
|
|
'business_sp_tqhsl', //色谱-编号-提取回收率
|
|
'business_sp_qxwdx', //色谱-编号-全血稳定性
|
|
'business_sp_cbyhgzywdx', //色谱-编号-储备液和工作液稳定性
|
|
'business_sp_rxjzxy', //色谱-编号-溶血基质效应
|
|
'business_sp_jzxy', //色谱-编号-基质效应
|
|
'business_sp_xzxytyx', //色谱-编号-选择性与特异性
|
|
'business_sp_zdybs', //色谱-编号-最大样本数
|
|
'business_sp_xskkx', //色谱-编号-稀释可靠性
|
|
'business_sp_cbydb' //色谱-编号-储备液对比
|
|
],
|
|
props: {
|
|
templateData: {
|
|
type: Object,
|
|
default: () => { }
|
|
}
|
|
},
|
|
watch: {
|
|
templateData: {
|
|
immediate: true,
|
|
deep: true,
|
|
handler(v) {
|
|
if (v) {
|
|
const {
|
|
studySubjectId,
|
|
studyId,
|
|
studyMc,
|
|
studySn,
|
|
templateMc,
|
|
templateMcEn,
|
|
templateSn,
|
|
startDate,
|
|
bdmc,
|
|
endDate,
|
|
id
|
|
} = v
|
|
if (v.resource) {
|
|
//试验试剂信息
|
|
this.resource = JSON.parse(v.resource)
|
|
}
|
|
if (v.yqResource) {
|
|
//仪器信息
|
|
this.yqResource = JSON.parse(v.yqResource)
|
|
}
|
|
if (v.bdnr) {
|
|
this.formData = {
|
|
...JSON.parse(v.bdnr),
|
|
studySubjectId,
|
|
studyId,
|
|
studyMc,
|
|
studySn,
|
|
templateMc,
|
|
templateMcEn,
|
|
templateSn,
|
|
startDate,
|
|
bdmc,
|
|
endDate,
|
|
id
|
|
}
|
|
} else {
|
|
this.formData = {
|
|
studySubjectId,
|
|
studyId,
|
|
studyMc,
|
|
studySn,
|
|
templateMc,
|
|
templateMcEn,
|
|
templateSn,
|
|
startDate,
|
|
bdmc,
|
|
endDate,
|
|
id
|
|
}
|
|
}
|
|
const { effectivePeriod, effectivePeriodUnit, expireDate } =
|
|
this.formData
|
|
//实际填报的时候，如果有了开始时间，并且有有效周期，但是没有失效日，就计算失效日为开始时间+有效周期
|
|
if (
|
|
startDate &&
|
|
this.fillType === 'actFill' &&
|
|
effectivePeriod &&
|
|
effectivePeriodUnit &&
|
|
!expireDate
|
|
) {
|
|
const start = moment(startDate)
|
|
const unit = effectivePeriodUnit === '天' ? 'days' : 'hours'
|
|
const end = start
|
|
.add(Number(effectivePeriod), unit)
|
|
.format('YYYY-MM-DD HH:mm:ss')
|
|
this.formData = { ...this.formData, expireDate: end }
|
|
}
|
|
console.log(this.formData, 'formData from templateData')
|
|
this.setTemplateData(v)
|
|
}
|
|
}
|
|
}
|
|
},
|
|
data() {
|
|
return {
|
|
formData: {},
|
|
templateDetail: {},
|
|
resource: [], //试验试剂信息
|
|
yqResource: [], //仪器信息
|
|
yqResourceTmp: [], //仪器信息提交用
|
|
resourceTmp:[],//试验试剂信息提交用
|
|
sysjColumns: [
|
|
{ label: 'template.common.reagentName', prop: "mc" },//名称
|
|
{ label: 'template.common.reagentCode', prop: "bh" },//编号
|
|
{ label: 'template.common.reagentNo', prop: "ph" },//批号 试剂，供试品才有
|
|
{ label: 'template.common.concentration', prop: "nd" },//浓度
|
|
{ label: 'template.common.source', prop: "source" },//来源
|
|
{ label: 'template.common.reagentExpireDate', prop: "sxrq" },//失效日期
|
|
],
|
|
yqsColumns: [
|
|
{ label: 'template.common.instrumentName', prop: "mc" },//仪器名称
|
|
{ label: 'template.common.instrumentModel', prop: "xh" },//仪器型号
|
|
{ label: 'template.common.instrumentCode', prop: "bh" },//仪器编号
|
|
{ label: 'template.common.nextTestDate', prop: "jzrq" },//下次测试/校准/检定日期
|
|
],
|
|
}
|
|
},
|
|
mounted() { },
|
|
unmounted() {
|
|
this.setTemplateData({})
|
|
},
|
|
methods: {
|
|
//开始配置
|
|
//postData: {bh: '123456'}
|
|
async startConfigRequest(postData) {
|
|
const res = await sj_startConfiguration(postData)
|
|
if (res.code === 200) {
|
|
this.$message.success('开始配置成功')
|
|
} else {
|
|
this.$message.error('开始配置失败')
|
|
}
|
|
},
|
|
//完成配置
|
|
async configCompleteRequest(postData) {
|
|
const res = await sj_configurationCompleted(postData)
|
|
if (res.code === 200) {
|
|
this.$message.success('完成配置成功')
|
|
} else {
|
|
this.$message.error('完成配置失败')
|
|
}
|
|
},
|
|
//分装
|
|
async subPackageRequest(postData) {
|
|
const res = await sj_subpackage(postData)
|
|
if (res.code === 200) {
|
|
this.$message.success('分装成功')
|
|
} else {
|
|
this.$message.error('分装失败')
|
|
}
|
|
},
|
|
//获取打印配置
|
|
getBasePrintConfig(data = {}) {
|
|
const { printCode, type, row = {} } = data;
|
|
const { stepStorageCondition, startDate, expireDate } = this.formData;;
|
|
const { nickName, name } = this.$store.getters;
|
|
const lang = this.$i18n.locale;
|
|
const printConfig = {
|
|
"品名": "暂时还不知道品名是哪个字段",
|
|
"存储条件": stepStorageCondition,
|
|
"配制日期": moment(startDate).format("YYYY-MM-DD"),
|
|
"有效期至": moment(expireDate).format("YYYY-MM-DD HH:mm"),
|
|
"配置者": lang === "zh_CN" ? nickName : name,
|
|
//type==="subPackage"从分装打印过来的，
|
|
//type==="row" 从列表上点过来的
|
|
"编号": type === "subPackage" ? printCode : (row.targetSolutionCode + row.subTargetSolutionCode),
|
|
}
|
|
return printConfig
|
|
},
|
|
async getLatestSn(count = 1) {
|
|
const res = await getLatestSn({ count })
|
|
if (res.code === 200) {
|
|
return res.data
|
|
}
|
|
return null
|
|
},
|
|
getResource() {
|
|
return this.resourceTmp
|
|
},
|
|
getYqResource() {
|
|
return this.yqResourceTmp
|
|
},
|
|
//根据ref数组获取直接formData
|
|
getFilledFormDataByRefs(refArr = []) {
|
|
let result = {}
|
|
refArr.map((ref) => {
|
|
const refData = this.$refs[ref]?.getFilledFormData() || {}
|
|
for (const [key, value] of Object.entries(refData)) {
|
|
let index = 0
|
|
// 如果当前键是可能重复的字段，且结果对象中已经存在该键，则添加索引后缀
|
|
if (
|
|
(key === 'headerSelectFields' || key === 'stepTableFormData') &&
|
|
result.hasOwnProperty(key)
|
|
) {
|
|
// 为重复字段生成带索引的键名，从1开始（因为第一个组件不需要后缀）
|
|
const newKey = `${key}_${++index}`
|
|
result[newKey] = value
|
|
} else {
|
|
// 正常合并其他字段
|
|
result[key] = value
|
|
}
|
|
}
|
|
})
|
|
return result
|
|
},
|
|
//统一校验form表单是否填写
|
|
async validFormFields(refArr = []) {
|
|
let result = {}
|
|
const refs = refArr.map((ref) => {
|
|
let refData = {}
|
|
if (this.$refs[ref][0]) {
|
|
refData = this.$refs[ref][0]?.getFormData() || {}
|
|
} else {
|
|
refData = this.$refs[ref]?.getFormData() || {}
|
|
}
|
|
return refData
|
|
})
|
|
const validFormData = await Promise.all(refs).catch((err) => {
|
|
// this.$message.error(err);
|
|
if (err.errorType && err.errorType === 'step') {
|
|
this.$message.error('请添加步骤')
|
|
return
|
|
}
|
|
this.$message.error('表单内容未填完,请填写后再提交')
|
|
})
|
|
if (validFormData) {
|
|
validFormData.forEach((item) => {
|
|
for (const [key, value] of Object.entries(item)) {
|
|
let index = 0
|
|
// 如果当前键是可能重复的字段，且结果对象中已经存在该键，则添加索引后缀
|
|
if (
|
|
(key === 'headerSelectFields' || key === 'stepTableFormData') &&
|
|
result.hasOwnProperty(key)
|
|
) {
|
|
// 为重复字段生成带索引的键名，从1开始（因为第一个组件不需要后缀）
|
|
const newKey = `${key}_${++index}`
|
|
result[newKey] = value
|
|
} else {
|
|
// 正常合并其他字段
|
|
result[key] = value
|
|
}
|
|
}
|
|
})
|
|
return result
|
|
}
|
|
return false
|
|
},
|
|
//试验配制条件options
|
|
getDictOptions(dictType) {
|
|
return this.dict.type[dictType] || []
|
|
},
|
|
|
|
setTemplateData(data) {
|
|
this.$store.commit('template/SET_TEMPLATE_DATA', data)
|
|
},
|
|
//统一处理删除行
|
|
deleteRow(index) {
|
|
this.$refs.stepTableRef.deleteRow(index)
|
|
},
|
|
|
|
//统一处理blur事件，因为有效周期和过期日期是相关的，所以需要在有效周期失焦时更新过期日期
|
|
onHandleBlur(fields) {
|
|
const {
|
|
key,
|
|
effectivePeriodUnit,
|
|
effectivePeriod,
|
|
codeSTD,
|
|
targetStartSolution
|
|
} = fields
|
|
const { startDate } = this.formData
|
|
if (key === 'codeSTD') {
|
|
//起始编号STD失焦时，更新stepDataSource
|
|
const arr = Array.from({ length: codeSTD }, (item, index) => ({
|
|
actSolutionVolumePrecision: 3, //小数点精度默认为3
|
|
actSolutionConcentrationPrecision: 3, //小数点精度默认为3
|
|
targetDiluentVolumePrecision: 3, //小数点精度默认为3
|
|
targetStartSolutionVolumePrecision: 3, //小数点精度默认为3
|
|
targetSolutionCode: `STD${Number(codeSTD) - index}`
|
|
}))
|
|
this.$refs.stepTableRef.updateDataSource(arr)
|
|
} else if (key === 'targetStartSolution') {
|
|
//起始溶液体积失焦时，更新目标溶液预计浓度
|
|
const arr = this.$refs.stepTableRef?.getDataSource()
|
|
arr.forEach((item, rowIndex) => {
|
|
this.updateTargetStartSolutionVolume(
|
|
rowIndex,
|
|
item,
|
|
targetStartSolution
|
|
)
|
|
})
|
|
}
|
|
},
|
|
//统一处理table失焦事件
|
|
onHandleTableBlur(params) {
|
|
const { rowIndex, colKey, value, item } = params
|
|
if (
|
|
colKey === 'targetSolutionVolume' ||
|
|
colKey === 'targetSolutionConcentration' ||
|
|
colKey === 'targetStartSolutionVolumePrecision' ||
|
|
colKey === 'targetDiluentVolumePrecision'
|
|
) {
|
|
const volume =
|
|
this.$refs.stepFormPackageRef?.getFormDataByKey(
|
|
'targetStartSolution'
|
|
) || 0
|
|
if (volume) {
|
|
this.updateTargetStartSolutionVolume(item, volume)
|
|
}
|
|
} else if (
|
|
colKey === 'actStartSolutionVolume' ||
|
|
colKey === 'actDiluentVolume'
|
|
) {
|
|
//实际起始溶液体积和实际目标溶液体积
|
|
const targetAcSolution =
|
|
this.$refs.stepFormPackageRef?.getFormDataByKey('targetAcSolution') ||
|
|
0 //获取实际起始溶液浓度
|
|
if (targetAcSolution) {
|
|
const { actVol, actNd } = this.updateSjmbrynd(item, targetAcSolution);
|
|
this.$refs.stepTableRef?.updateDataSourceByRowIndex(rowIndex, { actSolutionVolume: actVol })
|
|
this.$refs.stepTableRef?.updateDataSourceByRowIndex(rowIndex, { actSolutionConcentration: actNd })
|
|
}
|
|
}
|
|
},
|
|
|
|
//计算并更新实际目标溶液浓度 先计算实际目标溶液体积再计算实际目标溶液浓度
|
|
updateSjmbrynd(item, targetAcSolution) {
|
|
//实际源溶液浓度÷（实际终体积÷源溶液加入体积）；
|
|
const precision = item.actSolutionConcentrationPrecision || 0
|
|
const volPrecision = item.actSolutionVolumePrecision || 0
|
|
//实际稀释液体积
|
|
const actDiluentVolume = item.actDiluentVolume || 0
|
|
const actStartSolutionVolume = item.actStartSolutionVolume || 0
|
|
//实际高源溶液加入体积+实际稀释液加入体积
|
|
const actVol = (
|
|
Number(actStartSolutionVolume) + Number(actDiluentVolume)
|
|
).toFixed(volPrecision)
|
|
//实际目标溶液体积
|
|
// item.actSolutionVolume = actVol
|
|
//实际目标溶液浓度
|
|
const actNd = (
|
|
targetAcSolution /
|
|
actStartSolutionVolume /
|
|
actVol
|
|
).toFixed(precision)
|
|
const nd = actNd === 'Infinity' ? 0 : actNd
|
|
console.log(actNd, targetAcSolution, actStartSolutionVolume, actVol, "actNd")
|
|
|
|
// item.actSolutionConcentration = actNd === 'Infinity' ? 0 : actNd
|
|
return { actVol, actNd: nd }
|
|
},
|
|
//更新起始溶液体积时，计算目标溶液预计浓度
|
|
updateTargetStartSolutionVolume(item, volume) {
|
|
const precision = item.targetStartSolutionVolumePrecision || 0
|
|
const concentration = item.targetSolutionConcentration || 0
|
|
const targetVolume = item.targetSolutionVolume || 0
|
|
//目标溶液预计浓度:（目标溶液预计体积 乘以 起始溶液浓度）除以 起始溶液体积
|
|
const result = ((concentration * targetVolume) / volume).toFixed(
|
|
precision
|
|
)
|
|
item.targetStartSolutionVolume = result
|
|
// this.$refs.stepTableRef.updateDataSourceByRowIndex(rowIndex, { targetStartSolutionVolume: result });
|
|
if (targetVolume) {
|
|
//预设稀释液体积:目标溶液预计体积 减去 源溶液预计体积；
|
|
const precision1 = item.targetDiluentVolumePrecision || 0
|
|
const result1 = (targetVolume - result).toFixed(precision1)
|
|
item.targetDiluentVolume = result1
|
|
// this.$refs.stepTableRef.updateDataSourceByRowIndex(rowIndex, { targetDiluentVolume: result1 });
|
|
}
|
|
}
|
|
}
|
|
}
|