eln_web/src/views/business/comps/template/mixins/templateMixin.js

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) {
						// 试验物质：供试品、给药制剂 
                        // 试验试剂：试剂
						//试验试剂信息 type 类型：1：试剂；3：给药制剂；5：麻精药；7：供试品
						this.resource = _.filter(JSON.parse(v.resource),function(o){
							return o.type==1
						})
						this.resourceWz =_.filter(JSON.parse(v.resource),function(o){
							return o.type==3||o.type==7
						})
					}
					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: [], //试验试剂信息
			wzResource: [], //物资信息
			yqResource: [], //仪器信息

			resourceTmp:[],//试验试剂信息提交用
			yqResourceTmp: [], //仪器信息提交用
			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" },//失效日期
			],
			sywzColumns: [
				{ label: 'template.common.wzName', prop: "mc" },//名称
				{ label: 'template.common.wzCode', prop: "bh" },//编号
				{ label: 'template.common.wzSource', prop: "source" },//来源
				{ label: 'template.common.wzConcentration', prop: "nd" },//浓度
				{ label: 'template.common.wzExpireDate', 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 });
			}
		}
	}
}